diff --git a/docs/research/decompiled/INDEX.md b/docs/research/decompiled/INDEX.md new file mode 100644 index 0000000..625095d --- /dev/null +++ b/docs/research/decompiled/INDEX.md @@ -0,0 +1,63 @@ +# Decompiled acclient.exe — Full Index + +- Total functions: 22226 +- Successfully decompiled: 22225 +- Failed: 1 +- Time: 75s + +## Files by address chunk + +- `chunk_00400000.c` — 27183 lines +- `chunk_00410000.c` — 26338 lines +- `chunk_00420000.c` — 20753 lines +- `chunk_00430000.c` — 25677 lines +- `chunk_00440000.c` — 26028 lines +- `chunk_00450000.c` — 25113 lines +- `chunk_00460000.c` — 24486 lines +- `chunk_00470000.c` — 21998 lines +- `chunk_00480000.c` — 18223 lines +- `chunk_00490000.c` — 18343 lines +- `chunk_004A0000.c` — 15931 lines +- `chunk_004B0000.c` — 11281 lines +- `chunk_004C0000.c` — 19050 lines +- `chunk_004D0000.c` — 15220 lines +- `chunk_004E0000.c` — 18282 lines +- `chunk_004F0000.c` — 21835 lines +- `chunk_00500000.c` — 28121 lines +- `chunk_00510000.c` — 28028 lines +- `chunk_00520000.c` — 23705 lines +- `chunk_00530000.c` — 23720 lines +- `chunk_00540000.c` — 26339 lines +- `chunk_00550000.c` — 24576 lines +- `chunk_00560000.c` — 21414 lines +- `chunk_00570000.c` — 15793 lines +- `chunk_00580000.c` — 21493 lines +- `chunk_00590000.c` — 23709 lines +- `chunk_005A0000.c` — 24042 lines +- `chunk_005B0000.c` — 24113 lines +- `chunk_005C0000.c` — 24425 lines +- `chunk_005D0000.c` — 24483 lines +- `chunk_005E0000.c` — 27149 lines +- `chunk_005F0000.c` — 26972 lines +- `chunk_00600000.c` — 14936 lines +- `chunk_00610000.c` — 14454 lines +- `chunk_00620000.c` — 10453 lines +- `chunk_00630000.c` — 15174 lines +- `chunk_00640000.c` — 21923 lines +- `chunk_00650000.c` — 37209 lines +- `chunk_00660000.c` — 22737 lines +- `chunk_00670000.c` — 23715 lines +- `chunk_00680000.c` — 27365 lines +- `chunk_00690000.c` — 24155 lines +- `chunk_006A0000.c` — 27857 lines +- `chunk_006B0000.c` — 20525 lines +- `chunk_006C0000.c` — 5584 lines +- `chunk_00700000.c` — 60 lines +- `chunk_00720000.c` — 29398 lines +- `chunk_00730000.c` — 45271 lines +- `chunk_00740000.c` — 45251 lines +- `chunk_00750000.c` — 45773 lines +- `chunk_00760000.c` — 49981 lines +- `chunk_00770000.c` — 49778 lines +- `chunk_00780000.c` — 45954 lines +- `chunk_00790000.c` — 8918 lines diff --git a/docs/research/decompiled/chunk_00400000.c b/docs/research/decompiled/chunk_00400000.c new file mode 100644 index 0000000..9b16032 --- /dev/null +++ b/docs/research/decompiled/chunk_00400000.c @@ -0,0 +1,14187 @@ +// Decompiled from acclient.exe — chunk 0x00400000 +// Ghidra 12.0.4 + pyghidra headless + +// --- FUN_00401000 at 0x00401000 (size: 48) --- + +void FUN_00401000(undefined4 param_1,undefined4 param_2,int param_3,code *param_4) + +{ + if (-1 < param_3 + -1) { + do { + (*param_4)(); + param_3 = param_3 + -1; + } while (param_3 != 0); + } + return; +} + + + +// --- FUN_00401030 at 0x00401030 (size: 49) --- + +void FUN_00401030(undefined4 param_1,undefined4 param_2,int param_3,code *param_4) + +{ + if (-1 < param_3 + -1) { + do { + (*param_4)(); + param_3 = param_3 + -1; + } while (param_3 != 0); + } + return; +} + + + +// --- FUN_00401070 at 0x00401070 (size: 28) --- + +void FUN_00401070(int param_1,char *param_2) + +{ + char cVar1; + + param_1 = param_1 - (int)param_2; + do { + cVar1 = *param_2; + param_2[param_1] = cVar1; + param_2 = param_2 + 1; + } while (cVar1 != '\0'); + return; +} + + + +// --- FUN_004010a0 at 0x004010A0 (size: 40) --- + +LONG __fastcall FUN_004010a0(undefined4 *param_1) + +{ + LONG LVar1; + + LVar1 = InterlockedDecrement(param_1 + 1); + if (LVar1 != 0) { + return param_1[1]; + } + if (param_1 != (undefined4 *)0x0) { + (**(code **)*param_1)(1); + } + return 0; +} + + + +// --- FUN_004010d0 at 0x004010D0 (size: 18) --- + +bool FUN_004010d0(uint param_1,uint param_2) + +{ + return (param_1 & param_2) == param_2; +} + + + +// --- FUN_004010f0 at 0x004010F0 (size: 34) --- + +void FUN_004010f0(int *param_1) + +{ + if (param_1 != (int *)0x0) { + (**(code **)(*param_1 + 0x20))(); + (**(code **)(*param_1 + 0x14))(); + } + FUN_0054ba90(); + FUN_00555a20(); + return; +} + + + +// --- FUN_00401120 at 0x00401120 (size: 54) --- + +void FUN_00401120(void) + +{ + FUN_00405fa0(0,0x80017); + _control87(0x10000,0x30000); + _control87(0,0x300); + _control87(0,0x40000); + return; +} + + + +// --- FUN_00401160 at 0x00401160 (size: 67) --- + +uint FUN_00401160(undefined4 param_1) + +{ + int *piVar1; + undefined *puVar2; + undefined4 uVar3; + uint *puVar4; + uint local_8; + int local_4; + + puVar4 = &local_8; + uVar3 = 0; + puVar2 = &DAT_00793840; + piVar1 = &local_4; + local_8 = 0; + FUN_00406d10(piVar1,param_1,&DAT_00793840,0,&local_8); + FUN_00406650(piVar1,param_1,puVar2,uVar3,puVar4); + return (local_4 < 0) - 1 & local_8; +} + + + +// --- FUN_004011b0 at 0x004011B0 (size: 34) --- + +void __fastcall FUN_004011b0(int *param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)(*param_1 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*param_1 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return; +} + + + +// --- FUN_004011e0 at 0x004011E0 (size: 149) --- + +int * __thiscall FUN_004011e0(int *param_1,byte param_2) + +{ + undefined4 *puVar1; + LONG LVar2; + int *piVar3; + int local_4; + + if ((param_2 & 2) == 0) { + puVar1 = (undefined4 *)*param_1; + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; + } + local_4 = param_1[-1]; + piVar3 = param_1 + local_4; + if (-1 < local_4 + -1) { + do { + puVar1 = (undefined4 *)piVar3[-1]; + piVar3 = piVar3 + -1; + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + local_4 = local_4 + -1; + } while (local_4 != 0); + } + if ((param_2 & 1) != 0) { + operator_delete__(param_1 + -1); + } + return param_1 + -1; +} + + + +// --- FUN_00401280 at 0x00401280 (size: 186) --- + +undefined4 __thiscall FUN_00401280(int *param_1,uint param_2) + +{ + undefined4 *puVar1; + int iVar2; + int iVar3; + + if (param_2 < 0x10) { + iVar2 = 0; + iVar3 = 0x24; + } + else { + if (param_2 < 0x10001) { + iVar3 = 0x1f; + if (param_2 * 2 != 0) { + for (; param_2 * 2 >> iVar3 == 0; iVar3 = iVar3 + -1) { + } + } + iVar3 = 1 << ((char)iVar3 + 1U & 0x1f); + } + else { + iVar3 = (param_2 & 0xffff0000) + 0x10000; + } + iVar2 = iVar3 + -0x10; + if (iVar2 == 0) { + iVar3 = 0x24; + } + else { + iVar3 = iVar3 + 0x14; + } + } + puVar1 = (undefined4 *)thunk_FUN_005df0f5(iVar3); + if (puVar1 == (undefined4 *)0x0) { + return 0; + } + puVar1[1] = 1; + *puVar1 = &PTR_LAB_007cae34; + puVar1[4] = 1; + puVar1[2] = 1; + puVar1[3] = 0xffffffff; + *(undefined1 *)(puVar1 + 5) = 0; + *param_1 = (int)(puVar1 + 5); + *(uint *)(*param_1 + -4) = param_2 + 1; + *(int *)(*param_1 + -0xc) = iVar2 + 0x10; + return 1; +} + + + +// --- FUN_00401340 at 0x00401340 (size: 88) --- + +undefined4 * __thiscall FUN_00401340(undefined4 *param_1,char *param_2) + +{ + char cVar1; + char *pcVar2; + LONG *lpAddend; + + if ((param_2 != (char *)0x0) && (*param_2 != '\0')) { + pcVar2 = param_2; + do { + cVar1 = *pcVar2; + pcVar2 = pcVar2 + 1; + } while (cVar1 != '\0'); + FUN_00401280((int)pcVar2 - (int)(param_2 + 1)); + pcVar2 = (char *)*param_1; + do { + cVar1 = *param_2; + param_2 = param_2 + 1; + *pcVar2 = cVar1; + pcVar2 = pcVar2 + 1; + } while (cVar1 != '\0'); + return param_1; + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + return param_1; +} + + + +// --- FUN_004013a0 at 0x004013A0 (size: 489) --- + +/* WARNING: Removing unreachable block (ram,0x004014bc) */ +/* WARNING: Removing unreachable block (ram,0x0040150a) */ +/* WARNING: Removing unreachable block (ram,0x004014c1) */ +/* WARNING: Removing unreachable block (ram,0x00401434) */ + +undefined4 FUN_004013a0(void) + +{ + char cVar1; + int *piVar2; + + cVar1 = FUN_00406300(); + if (cVar1 == '\0') { + FUN_00555810(); + FUN_005557a0(); + return 1; + } + FUN_00406d60(); + GetCommandLineA(); + cVar1 = thunk_FUN_004096b0(); + if (cVar1 == '\0') { + FUN_00406f90(); + return 1; + } + FUN_00401120(); + DAT_00837720 = 0x40000001; + FUN_00413850(0,&PTR_DAT_008183b4); + FUN_0055af00(); + FUN_00555990(uRam00000000); + FUN_00558230(); + piVar2 = (int *)FUN_00401160(&DAT_007936b8); + if (piVar2 == (int *)0x0) { + FUN_0054ba90(); + FUN_00555a20(); + } + else { + cVar1 = (**(code **)(piVar2[1] + 0x10))(0,0,1); + if (cVar1 == '\0') { + FUN_004010f0(piVar2); + } + else { + FUN_00401340("Asheron\'s Call"); + cVar1 = (**(code **)(*piVar2 + 0x1c))(&stack0xffffffd8,1,1); + if (cVar1 != '\0') { + (**(code **)(*piVar2 + 0x2c))(); + FUN_004010f0(piVar2); + FUN_004011b0(); + FUN_004020c0(); + FUN_00406f90(); + return 0; + } + FUN_004010f0(piVar2); + FUN_004011b0(); + FUN_004020c0(); + } + } + FUN_00406f90(); + return 1; +} + + + +// --- FUN_00401590 at 0x00401590 (size: 76) --- + +void FUN_00401590(undefined4 *param_1,uint param_2,int param_3) + +{ + undefined4 *puVar1; + uint uVar2; + + puVar1 = (undefined4 *)FUN_0040acf0(param_2); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_3 + 4) & 1) != 0) { + for (uVar2 = param_2 >> 2; uVar2 != 0; uVar2 = uVar2 - 1) { + *puVar1 = *param_1; + param_1 = param_1 + 1; + puVar1 = puVar1 + 1; + } + for (param_2 = param_2 & 3; param_2 != 0; param_2 = param_2 - 1) { + *(undefined1 *)puVar1 = *(undefined1 *)param_1; + param_1 = (undefined4 *)((int)param_1 + 1); + puVar1 = (undefined4 *)((int)puVar1 + 1); + } + return; + } + for (uVar2 = param_2 >> 2; uVar2 != 0; uVar2 = uVar2 - 1) { + *param_1 = *puVar1; + puVar1 = puVar1 + 1; + param_1 = param_1 + 1; + } + for (param_2 = param_2 & 3; param_2 != 0; param_2 = param_2 - 1) { + *(undefined1 *)param_1 = *(undefined1 *)puVar1; + puVar1 = (undefined4 *)((int)puVar1 + 1); + param_1 = (undefined4 *)((int)param_1 + 1); + } + } + return; +} + + + +// --- FUN_00401600 at 0x00401600 (size: 85) --- + +undefined4 * __fastcall FUN_00401600(undefined4 *param_1) + +{ + undefined4 uVar1; + + *param_1 = &PTR_FUN_00793b3c; + param_1[1] = 0; + param_1[2] = 0; + FUN_00406d60(); + param_1[6] = 0; + param_1[7] = 0; + param_1[8] = 0; + *param_1 = &PTR_FUN_00793b50; + uVar1 = FUN_00406d60(); + FUN_0040afb0(&PTR_PTR_008183b8,uVar1); + FUN_00406f90(); + return param_1; +} + + + +// --- FUN_004016b0 at 0x004016B0 (size: 66) --- + +uint FUN_004016b0(char *param_1) + +{ + uint uVar1; + char cVar2; + + cVar2 = *param_1; + uVar1 = 0; + if (cVar2 != '\0') { + do { + uVar1 = uVar1 * 0x10 + (int)cVar2; + if ((uVar1 & 0xf0000000) != 0) { + uVar1 = ((uVar1 & 0xf0000000) >> 0x18 ^ uVar1) & 0xfffffff; + } + cVar2 = param_1[1]; + param_1 = param_1 + 1; + } while (cVar2 != '\0'); + if (uVar1 == 0xffffffff) { + uVar1 = 0xfffffffe; + } + } + return uVar1; +} + + + +// --- FUN_00401700 at 0x00401700 (size: 69) --- + +void __thiscall FUN_00401700(int *param_1,int *param_2) + +{ + int iVar1; + LONG LVar2; + + iVar1 = *param_1; + if (iVar1 != *param_2) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *param_2; + *param_1 = iVar1; + /* WARNING: Could not recover jumptable at 0x0040173a. Too many branches */ + /* WARNING: Treating indirect jump as call */ + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + return; + } + return; +} + + + +// --- FUN_00401750 at 0x00401750 (size: 47) --- + +void FUN_00401750(void) + +{ + int iVar1; + + if (DAT_008380c8 == 0) { + iVar1 = FUN_005df0f5(0x8100); + if (iVar1 != 0) { + DAT_008380c8 = FUN_00433d20(); + return; + } + DAT_008380c8 = 0; + } + return; +} + + + +// --- FUN_004017c0 at 0x004017C0 (size: 22) --- + +void __fastcall FUN_004017c0(int param_1) + +{ + (**(code **)(**(int **)(param_1 + 0x118) + 0x20))(); + FUN_00411fa0(); + return; +} + + + +// --- FUN_004017e0 at 0x004017E0 (size: 287) --- + +void FUN_004017e0(void) + +{ + FUN_005def70(&DAT_008375b0); + FUN_005def70(&DAT_008375b4); + FUN_005def70(&DAT_008375b8); + FUN_005def70(&DAT_008375bc); + FUN_005def70(&DAT_008375c0); + FUN_005def70(&DAT_008375c4); + FUN_005def70(&DAT_008375c8); + FUN_005def70(&DAT_008375cc); + FUN_005def70(&DAT_008375dc); + FUN_005def70(&DAT_008375d8); + FUN_005def70(&DAT_008375e0); + FUN_005def70(&DAT_008375e8); + FUN_005def70(&DAT_0083761c); + FUN_005def70(&DAT_008375f0); + FUN_005def70(&DAT_008375f4); + FUN_005def70(&DAT_008375f8); + FUN_005def70(&DAT_008375fc); + FUN_005def70(&DAT_00837600); + FUN_005def70(&DAT_00837598); + FUN_005def70(&DAT_008375a0); + FUN_005def70(&DAT_00837594); + FUN_005def70(&DAT_00837688); + FUN_005def70(&DAT_00837690); + FUN_005def70(&DAT_008375a4); + FUN_005def70(&DAT_008375a8); + FUN_005def70(&DAT_008375ac); + FUN_005def70(&DAT_00837564); + FUN_005def70(&DAT_00837568); + return; +} + + + +// --- FUN_00401920 at 0x00401920 (size: 119) --- + +uint __thiscall FUN_00401920(undefined4 *param_1,undefined4 *param_2) + +{ + byte bVar1; + byte *pbVar2; + int iVar3; + byte *pbVar4; + bool bVar5; + + pbVar4 = (byte *)*param_2; + pbVar2 = (byte *)*param_1; + if (*(int *)(pbVar2 + -4) == *(int *)(pbVar4 + -4)) { + if (((*(int *)(pbVar2 + -8) == *(int *)(pbVar4 + -8)) || (*(int *)(pbVar2 + -8) == -1)) || + (*(int *)(pbVar4 + -8) == -1)) { + while( true ) { + bVar1 = *pbVar2; + bVar5 = bVar1 < *pbVar4; + if (bVar1 != *pbVar4) break; + if (bVar1 == 0) { + return 1; + } + bVar1 = pbVar2[1]; + bVar5 = bVar1 < pbVar4[1]; + if (bVar1 != pbVar4[1]) break; + pbVar2 = pbVar2 + 2; + pbVar4 = pbVar4 + 2; + if (bVar1 == 0) { + return 1; + } + } + iVar3 = (1 - (uint)bVar5) - (uint)(bVar5 != 0); + return CONCAT31((int3)((uint)iVar3 >> 8),iVar3 == 0); + } + } + return (uint)pbVar2 & 0xffffff00; +} + + + +// --- FUN_004019a0 at 0x004019A0 (size: 49) --- + +void FUN_004019a0(undefined1 *param_1,int param_2) + +{ + undefined1 *puVar1; + + FUN_0040ad10(1); + puVar1 = (undefined1 *)FUN_0040acf0(1); + if (puVar1 != (undefined1 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *puVar1 = *param_1; + return; + } + *param_1 = *puVar1; + } + return; +} + + + +// --- FUN_004019e0 at 0x004019E0 (size: 53) --- + +void FUN_004019e0(undefined2 *param_1,int param_2) + +{ + undefined2 *puVar1; + + FUN_0040ad10(2); + puVar1 = (undefined2 *)FUN_0040acf0(2); + if (puVar1 != (undefined2 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *puVar1 = *param_1; + return; + } + *param_1 = *puVar1; + } + return; +} + + + +// --- FUN_00401a20 at 0x00401A20 (size: 20) --- + +undefined4 FUN_00401a20(int param_1) + +{ + undefined4 uVar1; + + if (param_1 != 0) { + uVar1 = FUN_004016b0(); + return uVar1; + } + return 0; +} + + + +// --- FUN_00401a40 at 0x00401A40 (size: 26) --- + +undefined4 * __fastcall FUN_00401a40(undefined4 *param_1) + +{ + LONG *lpAddend; + + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + return param_1; +} + + + +// --- FUN_00401a60 at 0x00401A60 (size: 26) --- + +undefined4 * __fastcall FUN_00401a60(undefined4 *param_1) + +{ + LONG *lpAddend; + + lpAddend = (LONG *)(PTR_DAT_00818340 + -0x10); + *param_1 = PTR_DAT_00818340; + InterlockedIncrement(lpAddend); + return param_1; +} + + + +// --- FUN_00401a80 at 0x00401A80 (size: 362) --- + +void FUN_00401a80(undefined4 param_1,uint *param_2,uint param_3) + +{ + uint uVar1; + undefined1 *puVar2; + byte *pbVar3; + uint uVar4; + ushort local_8 [2]; + uint local_4; + + uVar1 = param_3; + if ((*(byte *)(param_3 + 4) & 1) == 0) { + if ((~*(byte *)(param_3 + 4) & 1) != 0) { + FUN_0040ad10(1); + pbVar3 = (byte *)FUN_0040acf0(1); + if (pbVar3 == (byte *)0x0) { + uVar4 = param_3 & 0xff; + } + else if ((*(byte *)(uVar1 + 4) & 1) == 0) { + uVar4 = (uint)*pbVar3; + } + else { + uVar4 = param_3 & 0xff; + *pbVar3 = (byte)param_3; + } + if ((char)uVar4 < '\0') { + FUN_004019a0(¶m_3,uVar1); + if ((uVar4 & 0x40) != 0) { + FUN_004019e0(local_8,uVar1); + *param_2 = ((uVar4 & 0x3f) << 8 | param_3 & 0xff) << 0x10 | (uint)local_8[0]; + return; + } + *param_2 = (uVar4 & 0x7f) << 8 | param_3 & 0xff; + return; + } + *param_2 = uVar4; + } + } + else { + local_4 = *param_2; + if (0x7f < local_4) { + if (local_4 < 0x4000) { + param_3 = CONCAT31(param_3._1_3_,*(undefined1 *)((int)param_2 + 1)) | 0x80; + local_8[0] = CONCAT11(local_8[0]._1_1_,(char)*param_2); + FUN_004019a0(¶m_3,uVar1); + FUN_004019a0(local_8,uVar1); + return; + } + param_3 = CONCAT31(param_3._1_3_,(char)(local_4 >> 0x18)) | 0xc0; + local_8[0] = CONCAT11(local_8[0]._1_1_,(char)(local_4 >> 0x10)); + FUN_004019a0(¶m_3,uVar1); + FUN_004019a0(local_8,uVar1); + FUN_004019e0(&local_4,uVar1); + return; + } + FUN_0040ad10(1); + puVar2 = (undefined1 *)FUN_0040acf0(1); + if ((puVar2 != (undefined1 *)0x0) && ((*(byte *)(uVar1 + 4) & 1) != 0)) { + *puVar2 = (char)local_4; + return; + } + } + return; +} + + + +// --- FUN_00401c50 at 0x00401C50 (size: 301) --- + +void __fastcall FUN_00401c50(undefined4 *param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)(param_1[0x4f] + -0x14); + param_1[-7] = &PTR_LAB_00793c48; + param_1[-6] = &PTR_LAB_00793bf8; + *param_1 = &PTR_FUN_00793bec; + param_1[2] = &PTR_LAB_00793be0; + param_1[3] = &PTR_LAB_00793bd0; + param_1[0x47] = &PTR_FUN_00793b70; + LVar1 = InterlockedDecrement((LONG *)(param_1[0x4f] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x4e] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x4e] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x4d] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x4d] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x4c] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x4c] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x4a] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x4a] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x49] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x49] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x48] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x48] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_0043c610(); + FUN_00412b70(); + return; +} + + + +// --- FUN_00401db0 at 0x00401DB0 (size: 7) --- + +undefined4 __fastcall FUN_00401db0(int param_1) + +{ + return *(undefined4 *)(param_1 + 0x94); +} + + + +// --- FUN_00401dc0 at 0x00401DC0 (size: 13) --- + +void __thiscall FUN_00401dc0(int param_1,undefined4 param_2) + +{ + *(undefined4 *)(param_1 + 0x94) = param_2; + return; +} + + + +// --- FUN_00401e70 at 0x00401E70 (size: 37) --- + +int __fastcall FUN_00401e70(int param_1) + +{ + int iVar1; + + iVar1 = FUN_00401ea0(); + if ((iVar1 == 0) && (param_1 != 0)) { + (*(code *)**(undefined4 **)(param_1 + 0x1c))(1); + } + return iVar1; +} + + + +// --- FUN_00401ea0 at 0x00401EA0 (size: 23) --- + +LONG __fastcall FUN_00401ea0(int param_1) + +{ + LONG LVar1; + + LVar1 = InterlockedDecrement((LONG *)(param_1 + 4)); + if (LVar1 != 0) { + return *(LONG *)(param_1 + 4); + } + return 0; +} + + + +// --- FUN_00402000 at 0x00402000 (size: 17) --- + +undefined4 FUN_00402000(undefined4 param_1) + +{ + FUN_00413180(param_1); + return param_1; +} + + + +// --- FUN_00402020 at 0x00402020 (size: 77) --- + +void __thiscall FUN_00402020(int param_1,int *param_2) + +{ + int iVar1; + LONG LVar2; + + iVar1 = *(int *)(param_1 + 0x144); + if (iVar1 != *param_2) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *param_2; + *(int *)(param_1 + 0x144) = iVar1; + /* WARNING: Could not recover jumptable at 0x00402062. Too many branches */ + /* WARNING: Treating indirect jump as call */ + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + return; + } + return; +} + + + +// --- FUN_00402070 at 0x00402070 (size: 66) --- + +int * __thiscall FUN_00402070(int *param_1,int *param_2) + +{ + int iVar1; + LONG LVar2; + + iVar1 = *param_1; + if (iVar1 != *param_2) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *param_2; + *param_1 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + return param_1; +} + + + +// --- FUN_004020c0 at 0x004020C0 (size: 25) --- + +void __fastcall FUN_004020c0(undefined4 *param_1) + +{ + if ((param_1[1] & 0x80000000) == 0x80000000) { + operator_delete__((void *)*param_1); + } + return; +} + + + +// --- FUN_004020e0 at 0x004020E0 (size: 126) --- + +void __thiscall +FUN_004020e0(int param_1,int *param_2,undefined4 param_3,undefined4 param_4,undefined4 param_5, + undefined4 param_6,undefined4 param_7) + +{ + int *piVar1; + char cVar2; + int iVar3; + + piVar1 = param_2; + if (param_1 != 0) { + FUN_004369a0(param_1,0xd,param_2,param_3,param_4,param_5,param_6,param_7); + } + if (DAT_008380c8 == 0) { + iVar3 = FUN_005df0f5(0x8100); + if (iVar3 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar2 = FUN_00433710(piVar1,¶m_2); + if ((cVar2 != '\0') && (iVar3 = (**(code **)(*param_2 + 0x44))(), iVar3 != 0)) { + *(undefined1 *)(iVar3 + 0x28) = 1; + } + return; +} + + + +// --- FUN_00402160 at 0x00402160 (size: 126) --- + +void __thiscall +FUN_00402160(int param_1,int *param_2,undefined4 param_3,undefined4 param_4,undefined4 param_5, + undefined4 param_6,undefined4 param_7) + +{ + int *piVar1; + char cVar2; + int iVar3; + + piVar1 = param_2; + if (param_1 != 0) { + FUN_004369a0(param_1,4,param_2,param_3,param_4,param_5,param_6,param_7); + } + if (DAT_008380c8 == 0) { + iVar3 = FUN_005df0f5(0x8100); + if (iVar3 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar2 = FUN_00433710(piVar1,¶m_2); + if ((cVar2 != '\0') && (iVar3 = (**(code **)(*param_2 + 0x44))(), iVar3 != 0)) { + *(undefined1 *)(iVar3 + 0x28) = 1; + } + return; +} + + + +// --- FUN_004021e0 at 0x004021E0 (size: 77) --- + +void __thiscall FUN_004021e0(int param_1,int *param_2) + +{ + int iVar1; + LONG LVar2; + + iVar1 = *(int *)(param_1 + 0x8c); + if (iVar1 != *param_2) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *param_2; + *(int *)(param_1 + 0x8c) = iVar1; + /* WARNING: Could not recover jumptable at 0x00402222. Too many branches */ + /* WARNING: Treating indirect jump as call */ + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + return; + } + return; +} + + + +// --- FUN_00402230 at 0x00402230 (size: 77) --- + +void __thiscall FUN_00402230(int param_1,int *param_2) + +{ + int iVar1; + LONG LVar2; + + iVar1 = *(int *)(param_1 + 0xa8); + if (iVar1 != *param_2) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *param_2; + *(int *)(param_1 + 0xa8) = iVar1; + /* WARNING: Could not recover jumptable at 0x00402272. Too many branches */ + /* WARNING: Treating indirect jump as call */ + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + return; + } + return; +} + + + +// --- FUN_00402280 at 0x00402280 (size: 71) --- + +void __fastcall FUN_00402280(int param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)(*(int *)(param_1 + 0xc) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)(param_1 + 0xc) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(*(int *)(param_1 + 8) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)(param_1 + 8) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return; +} + + + +// --- FUN_004022d0 at 0x004022D0 (size: 189) --- + +undefined4 __thiscall FUN_004022d0(int *param_1,uint param_2) + +{ + undefined4 *puVar1; + int iVar2; + int iVar3; + + if (param_2 < 0x10) { + iVar2 = 0; + iVar3 = 0x34; + } + else { + if (param_2 < 0x10001) { + iVar3 = 0x1f; + if (param_2 * 2 != 0) { + for (; param_2 * 2 >> iVar3 == 0; iVar3 = iVar3 + -1) { + } + } + iVar3 = 1 << ((char)iVar3 + 1U & 0x1f); + } + else { + iVar3 = (param_2 & 0xffff0000) + 0x10000; + } + iVar2 = iVar3 + -0x10; + if (iVar2 == 0) { + iVar3 = 0x34; + } + else { + iVar3 = iVar3 + 0x24 + iVar2; + } + } + puVar1 = (undefined4 *)thunk_FUN_005df0f5(iVar3); + if (puVar1 == (undefined4 *)0x0) { + return 0; + } + puVar1[1] = 1; + *puVar1 = &PTR_LAB_007cae34; + puVar1[4] = 1; + puVar1[2] = 1; + puVar1[3] = 0xffffffff; + *(undefined2 *)(puVar1 + 5) = 0; + *param_1 = (int)(puVar1 + 5); + *(uint *)(*param_1 + -4) = param_2 + 1; + *(int *)(*param_1 + -0xc) = iVar2 + 0x10; + return 1; +} + + + +// --- FUN_00402390 at 0x00402390 (size: 97) --- + +int __thiscall FUN_00402390(int *param_1,char *param_2,va_list param_3) + +{ + int iVar1; + int iVar2; + LONG LVar3; + undefined4 *puVar4; + + iVar2 = _vscprintf(param_2,param_3); + iVar1 = *param_1; + puVar4 = (undefined4 *)(iVar1 + -0x14); + FUN_00401280(iVar2); + _vsnprintf((char *)*param_1,iVar2 + 1,param_2,param_3); + LVar3 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + return iVar2; +} + + + +// --- FUN_00402400 at 0x00402400 (size: 136) --- + +void __thiscall FUN_00402400(int *param_1,uint param_2) + +{ + uint uVar1; + uint uVar2; + uint uVar3; + + uVar1 = param_2; + if ((*(byte *)(param_2 + 4) & 1) != 0) { + param_2 = *(int *)(*param_1 + -4) - 1; + } + FUN_00401a80(¶m_2,¶m_2,uVar1); + uVar2 = param_2; + if ((*(uint *)(uVar1 + 4) >> 2 & 1) == 0) { + if ((~*(byte *)(uVar1 + 4) & 1) != 0) { + uVar3 = FUN_0040a8f0(); + if (uVar3 < uVar2) { + FUN_0040aa50(); + return; + } + FUN_004010a0(); + FUN_00401280(uVar2); + *(undefined1 *)(uVar2 + *param_1) = 0; + } + FUN_00401590(*param_1,uVar2,uVar1); + } + return; +} + + + +// --- FUN_00402490 at 0x00402490 (size: 137) --- + +void __thiscall FUN_00402490(int *param_1,wchar_t *param_2,size_t param_3) + +{ + uint uVar1; + wchar_t *_Source; + int iVar2; + + if (((param_2 != (wchar_t *)0x0) && (*param_2 != L'\0')) && (param_3 != 0)) { + _Source = (wchar_t *)*param_1; + iVar2 = *(int *)(_Source + -2); + uVar1 = iVar2 + param_3; + if ((*(int *)(_Source + -8) == 1) && (uVar1 <= *(uint *)(_Source + -6))) { + *(uint *)(_Source + -2) = uVar1; + *(undefined4 *)(*param_1 + -8) = 0xffffffff; + } + else { + FUN_004022d0(uVar1 - 1); + wcscpy((wchar_t *)*param_1,_Source); + FUN_004010a0(); + } + wcsncpy((wchar_t *)(*param_1 + -2 + iVar2 * 2),param_2,param_3); + *(undefined2 *)(*param_1 + -2 + *(int *)(*param_1 + -4) * 2) = 0; + } + return; +} + + + +// --- FUN_00402520 at 0x00402520 (size: 97) --- + +int __thiscall FUN_00402520(int *param_1,wchar_t *param_2,va_list param_3) + +{ + int iVar1; + int iVar2; + LONG LVar3; + undefined4 *puVar4; + + iVar2 = _vscwprintf(param_2,param_3); + iVar1 = *param_1; + puVar4 = (undefined4 *)(iVar1 + -0x14); + FUN_004022d0(iVar2); + _vsnwprintf((wchar_t *)*param_1,iVar2 + 1,param_2,param_3); + LVar3 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + return iVar2; +} + + + +// --- FUN_00402630 at 0x00402630 (size: 34) --- + +int __thiscall FUN_00402630(int param_1,byte param_2) + +{ + FUN_00401c50(); + if ((param_2 & 1) != 0) { + operator_delete((void *)(param_1 + -0x1c)); + } + return param_1 + -0x1c; +} + + + +// --- FUN_00402660 at 0x00402660 (size: 175) --- + +undefined1 +FUN_00402660(undefined4 param_1,undefined1 param_2,int *param_3,int *param_4,undefined4 param_5, + undefined4 param_6,undefined4 param_7) + +{ + undefined1 uVar1; + LONG LVar2; + undefined4 *puVar3; + undefined4 local_1c; + undefined1 local_18; + int local_14; + int local_10; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + local_1c = param_1; + local_14 = *param_3; + local_18 = param_2; + InterlockedIncrement((LONG *)(local_14 + -0x10)); + local_10 = *param_4; + InterlockedIncrement((LONG *)(local_10 + -0x10)); + local_c = param_5; + local_8 = param_6; + local_4 = param_7; + uVar1 = FUN_0040a0d0(&local_1c); + puVar3 = (undefined4 *)(local_10 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_10 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + puVar3 = (undefined4 *)(local_14 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_14 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + return uVar1; +} + + + +// --- FUN_00402710 at 0x00402710 (size: 20) --- + +void FUN_00402710(undefined4 param_1,undefined4 param_2) + +{ + FUN_00402390(param_2,&stack0x0000000c); + return; +} + + + +// --- FUN_00402730 at 0x00402730 (size: 83) --- + +undefined4 * __thiscall FUN_00402730(undefined4 *param_1,wchar_t *param_2) + +{ + size_t sVar1; + LONG *lpAddend; + + if ((param_2 != (wchar_t *)0x0) && (*param_2 != L'\0')) { + sVar1 = wcslen(param_2); + FUN_004022d0(sVar1); + wcscpy((wchar_t *)*param_1,param_2); + return param_1; + } + lpAddend = (LONG *)(PTR_DAT_00818340 + -0x10); + *param_1 = PTR_DAT_00818340; + InterlockedIncrement(lpAddend); + return param_1; +} + + + +// --- FUN_00402790 at 0x00402790 (size: 25) --- + +void FUN_00402790(int *param_1) + +{ + int iVar1; + + iVar1 = *(int *)(*param_1 + -4); + if (iVar1 != 1) { + FUN_00402490(*param_1,iVar1 + -1); + } + return; +} + + + +// --- FUN_004027b0 at 0x004027B0 (size: 20) --- + +void FUN_004027b0(undefined4 param_1,undefined4 param_2) + +{ + FUN_00402520(param_2,&stack0x0000000c); + return; +} + + + +// --- FUN_004027d0 at 0x004027D0 (size: 53) --- + +int __fastcall FUN_004027d0(void *param_1) + +{ + int iVar1; + LONG LVar2; + + LVar2 = InterlockedDecrement((LONG *)((int)param_1 + 8)); + if ((LVar2 != 0) && (iVar1 = *(LONG *)((int)param_1 + 8), iVar1 != 0)) { + return iVar1; + } + if (param_1 != (void *)0x0) { + *(undefined ***)((int)param_1 + 4) = &PTR_LAB_00793b6c; + operator_delete(param_1); + } + return 0; +} + + + +// --- FUN_00402810 at 0x00402810 (size: 628) --- + +undefined4 * __fastcall FUN_00402810(undefined4 *param_1) + +{ + char cVar1; + LONG LVar2; + BOOL BVar3; + size_t sVar4; + LONG *pLVar5; + wchar_t *pwVar6; + undefined4 *puVar7; + wchar_t *local_110; + char local_109; + undefined *local_108; + CHAR local_104 [260]; + + FUN_00412e50(0); + param_1[0x4e] = &PTR_FUN_00801670; + *param_1 = &PTR_LAB_00793c48; + param_1[1] = &PTR_LAB_00793bf8; + param_1[7] = &PTR_FUN_00793bec; + param_1[9] = &PTR_LAB_00793be0; + param_1[10] = &PTR_LAB_00793bd0; + param_1[0x4e] = &PTR_FUN_00793b70; + pLVar5 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x4f] = PTR_DAT_00818344; + InterlockedIncrement(pLVar5); + pLVar5 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x50] = PTR_DAT_00818344; + InterlockedIncrement(pLVar5); + pLVar5 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x51] = PTR_DAT_00818344; + InterlockedIncrement(pLVar5); + *(undefined1 *)(param_1 + 0x52) = 0; + pLVar5 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x53] = PTR_DAT_00818344; + InterlockedIncrement(pLVar5); + pLVar5 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x54] = PTR_DAT_00818344; + InterlockedIncrement(pLVar5); + pLVar5 = (LONG *)(PTR_DAT_00818340 + -0x10); + param_1[0x55] = PTR_DAT_00818340; + InterlockedIncrement(pLVar5); + pLVar5 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x56] = PTR_DAT_00818344; + InterlockedIncrement(pLVar5); + local_108 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + cVar1 = FUN_0040db30(&local_108); + if (cVar1 != '\0') { + local_110 = (wchar_t *)PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00402710(&local_110,"%s\\UserPreferences.ini",local_108); + thunk_FUN_0040da10(&local_110,0); + local_109 = FUN_0040b320(&local_110,0); + if (local_109 != '\0') { + FUN_00402070(&local_110); + } + pwVar6 = local_110 + -10; + LVar2 = InterlockedDecrement((LONG *)(local_110 + -8)); + if ((LVar2 == 0) && (pwVar6 != (wchar_t *)0x0)) { + (*(code *)**(undefined4 **)pwVar6)(1); + } + if (local_109 != '\0') goto LAB_004029d6; + } + BVar3 = SHGetSpecialFolderPathA((HWND)0x0,local_104,5,1); + if (BVar3 != 0) { + FUN_00402710(&local_108,"%s\\Asheron\'s Call",local_104); + thunk_FUN_0040df20(&local_108); + FUN_00402710(param_1 + 0x19,"%s\\UserPreferences.ini",local_108); + } +LAB_004029d6: + sVar4 = wcslen(L"http://acbm.turbinegames.com/IISAcBillingMigration/IISAcBillingMigration.dll?ac1" + ); + FUN_004022d0(sVar4); + wcscpy(local_110, + L"http://acbm.turbinegames.com/IISAcBillingMigration/IISAcBillingMigration.dll?ac1"); + pwVar6 = (wchar_t *)param_1[0x55]; + if (pwVar6 != local_110) { + LVar2 = InterlockedDecrement((LONG *)(pwVar6 + -8)); + if ((LVar2 == 0) && (pwVar6 + -10 != (wchar_t *)0x0)) { + (*(code *)**(undefined4 **)(pwVar6 + -10))(1); + } + param_1[0x55] = local_110; + InterlockedIncrement((LONG *)(local_110 + -8)); + } + pwVar6 = local_110 + -10; + LVar2 = InterlockedDecrement((LONG *)(local_110 + -8)); + if ((LVar2 == 0) && (pwVar6 != (wchar_t *)0x0)) { + (*(code *)**(undefined4 **)pwVar6)(1); + } + FUN_00695670(); + puVar7 = (undefined4 *)(local_108 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_108 + -0x10)); + if ((LVar2 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + return param_1; +} + + + +// --- FUN_00403350 at 0x00403350 (size: 310) --- + +undefined4 * __thiscall FUN_00403350(int *param_1,undefined4 *param_2,undefined2 param_3) + +{ + int iVar1; + DWORD DVar2; + DWORD DVar3; + LONG LVar4; + undefined4 *puVar5; + wchar_t *pwVar6; + undefined *local_4; + + local_4 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + iVar1 = *(int *)(*param_1 + -4); + if (iVar1 == 1) { + *param_2 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + } + else { + iVar1 = (*(code *)PTR_FUN_00837394)(param_3,0,*param_1,iVar1,0,0); + if (iVar1 == 0) { + DVar2 = GetLastError(); + DVar3 = GetLastError(); + pwVar6 = + L"Could not determine number of bytes needed to convert from codepage %hu! GetLastError %d (0x%08x)\n" + ; + } + else { + FUN_004022d0(iVar1); + iVar1 = (*(code *)PTR_FUN_00837394) + (param_3,0,*param_1,*(undefined4 *)(*param_1 + -4),local_4,iVar1); + if (iVar1 != 0) { + *(int *)(local_4 + -4) = iVar1; + *param_2 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + puVar5 = (undefined4 *)(local_4 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if (LVar4 != 0) { + return param_2; + } + if (puVar5 == (undefined4 *)0x0) { + return param_2; + } + (**(code **)*puVar5)(1); + return param_2; + } + DVar2 = GetLastError(); + DVar3 = GetLastError(); + pwVar6 = L"Failed conversion from codepage %hu! GetLastError %d (0x%08x)\n"; + } + FUN_004027b0(&local_4,pwVar6,param_3,DVar3,DVar2); + *param_2 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + } + puVar5 = (undefined4 *)(local_4 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar4 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + return param_2; + } + return param_2; +} + + + +// --- FUN_004034c0 at 0x004034C0 (size: 155) --- + +void __thiscall FUN_004034c0(int *param_1,char *param_2) + +{ + char cVar1; + undefined4 *puVar2; + LONG LVar3; + char *pcVar4; + LONG *lpAddend; + + if ((param_2 == (char *)0x0) || (*param_2 == '\0')) { + puVar2 = (undefined4 *)*param_1; + if (puVar2 != DAT_008ef11c) { + LVar3 = InterlockedDecrement(puVar2 + 1); + if ((LVar3 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + lpAddend = DAT_008ef11c + 1; + *param_1 = (int)DAT_008ef11c; + /* WARNING: Could not recover jumptable at 0x00403555. Too many branches */ + /* WARNING: Treating indirect jump as call */ + InterlockedIncrement(lpAddend); + return; + } + } + else { + puVar2 = (undefined4 *)*param_1; + LVar3 = InterlockedDecrement(puVar2 + 1); + if ((LVar3 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + pcVar4 = param_2; + do { + cVar1 = *pcVar4; + pcVar4 = pcVar4 + 1; + } while (cVar1 != '\0'); + FUN_00403560((int)pcVar4 - (int)(param_2 + 1)); + pcVar4 = (char *)(*param_1 + 0x14); + do { + cVar1 = *param_2; + param_2 = param_2 + 1; + *pcVar4 = cVar1; + pcVar4 = pcVar4 + 1; + } while (cVar1 != '\0'); + } + return; +} + + + +// --- FUN_00403560 at 0x00403560 (size: 114) --- + +void __thiscall FUN_00403560(int *param_1,uint param_2) + +{ + undefined4 *puVar1; + uint uVar2; + + uVar2 = 1; + do { + uVar2 = uVar2 * 2; + } while (uVar2 < param_2); + puVar1 = (undefined4 *)thunk_FUN_005df0f5(uVar2 + 0x18); + if (puVar1 != (undefined4 *)0x0) { + puVar1[1] = 1; + *puVar1 = &PTR_LAB_007cae34; + puVar1[2] = 1; + puVar1[3] = 1; + puVar1[4] = 0xffffffff; + *(undefined1 *)(puVar1 + 5) = 0; + *param_1 = (int)puVar1; + puVar1[2] = param_2 + 1; + *(uint *)(*param_1 + 0xc) = uVar2 + 1; + return; + } + *param_1 = 0; + iRam00000008 = param_2 + 1; + *(uint *)(*param_1 + 0xc) = uVar2 + 1; + return; +} + + + +// --- FUN_004036d0 at 0x004036D0 (size: 145) --- + +void __thiscall FUN_004036d0(int *param_1,undefined4 *param_2,int *param_3) + +{ + int iVar1; + int *piVar2; + int *piVar3; + int *unaff_ESI; + int *local_4; + + local_4 = param_1; + if (param_3 == (int *)0x0) { + FUN_00403770(0); + *param_2 = 0x80004002; + return; + } + iVar1 = *param_3; + param_3 = (int *)0x0; + piVar3 = (int *)(**(code **)(iVar1 + 0xc))(&local_4,&DAT_00793b20,¶m_3); + piVar2 = local_4; + iVar1 = *piVar3; + piVar3 = (int *)*param_1; + if (iVar1 < 0) { + if (piVar3 != (int *)0x0) { + (**(code **)(*piVar3 + 0x14))(); + } + *param_1 = 0; + param_1[1] = 0; + *unaff_ESI = iVar1; + return; + } + if (piVar3 != (int *)0x0) { + (**(code **)(*piVar3 + 0x14))(); + } + *param_1 = (int)piVar2; + param_1[1] = 0; + *unaff_ESI = iVar1; + return; +} + + + +// --- FUN_00403770 at 0x00403770 (size: 50) --- + +int * __thiscall FUN_00403770(int *param_1,int *param_2) + +{ + int *piVar1; + + piVar1 = (int *)*param_1; + if (piVar1 != param_2) { + *param_1 = (int)param_2; + if (param_2 != (int *)0x0) { + (**(code **)(*param_2 + 0x10))(); + } + if (piVar1 != (int *)0x0) { + (**(code **)(*piVar1 + 0x14))(); + } + param_1[1] = 0; + } + return param_1; +} + + + +// --- FUN_004037b0 at 0x004037B0 (size: 4588) --- + +void FUN_004037b0(void) + +{ + char cVar1; + undefined4 uVar2; + undefined4 uVar3; + void *local_60; + uint local_5c; + uint local_58; + void *local_54; + uint local_50; + uint local_4c; + void *local_48; + uint local_44; + uint local_40; + void *local_3c; + uint local_38; + uint local_34; + void *local_30; + uint local_2c; + uint local_28; + void *local_24; + uint local_20; + uint local_1c; + void *local_18; + uint local_14; + uint local_10; + void *local_c; + uint local_8; + uint local_4; + + uVar2 = FUN_004016b0("ID_Sound_DisableSound_Help"); + uVar2 = FUN_004016b0("ID_Sound_DisableSound",uVar2); + FUN_005dee50(&DAT_008375b0,4,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Sound_EffectVolume_Help"); + uVar2 = FUN_004016b0("ID_Sound_EffectVolume",uVar2); + FUN_005dee50(&DAT_008375b4,3,0x10000003,uVar2); + FUN_005de990(&DAT_008375b4,0,0x3f800000); + uVar2 = FUN_004016b0("ID_Sound_DisableAmbientSound_Help"); + uVar2 = FUN_004016b0("ID_Sound_DisableAmbientSound",uVar2); + FUN_005dee50(&DAT_008375b8,4,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Sound_AmbientVolume_Help"); + uVar2 = FUN_004016b0("ID_Sound_AmbientVolume",uVar2); + FUN_005dee50(&DAT_008375bc,3,0x10000003,uVar2); + FUN_005de990(&DAT_008375bc,0,0x3f800000); + uVar2 = FUN_004016b0("ID_Sound_DisableInterfaceSound_Help"); + uVar2 = FUN_004016b0("ID_Sound_DisableInterfaceSound",uVar2); + FUN_005dee50(&DAT_008375c0,4,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Sound_InterfaceVolume_Help"); + uVar2 = FUN_004016b0("ID_Sound_InterfaceVolume",uVar2); + FUN_005dee50(&DAT_008375c4,3,0x10000003,uVar2); + FUN_005de990(&DAT_008375c4,0,0x3f800000); + uVar2 = FUN_004016b0("ID_Sound_SoundFeatures_Help"); + uVar2 = FUN_004016b0("ID_Sound_SoundFeatures",uVar2); + FUN_005dee50(&DAT_008375c8,2,0x10000003,uVar2); + local_c = (void *)0x0; + local_8 = 0; + local_4 = 0; + uVar2 = FUN_004016b0("ID_Sound_Stereo"); + uVar3 = FUN_00453850(1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') { + *(undefined4 *)((int)local_c + local_4 * 4) = uVar2; + local_4 = local_4 + 1; + } + uVar2 = FUN_004016b0("ID_Sound_Mono"); + if (local_4 < (local_8 & 0x7fffffff)) { +LAB_0040399e: + *(undefined4 *)((int)local_c + local_4 * 4) = uVar2; + local_4 = local_4 + 1; + } + else { + uVar3 = FUN_00453850((local_8 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_0040399e; + } + FUN_005dea80(&DAT_008375c8,&local_c); + uVar2 = FUN_004016b0("ID_Sound_NoFocusNoSound_Help"); + uVar2 = FUN_004016b0("ID_Sound_NoFocusNoSound",uVar2); + FUN_005dee50(&DAT_008375cc,4,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Misc_TooltipDelay_Help"); + uVar2 = FUN_004016b0("ID_Misc_TooltipDelay",uVar2); + FUN_005dee50(&DAT_008375dc,3,0x10000003,uVar2); + FUN_005de990(&DAT_008375dc,0,0x41200000); + uVar2 = FUN_004016b0("ID_Misc_TooltipEnable_Help"); + uVar2 = FUN_004016b0("ID_Misc_TooltipEnable",uVar2); + FUN_005dee50(&DAT_008375d8,4,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_UI_ChatFontFace_Help"); + uVar2 = FUN_004016b0("ID_UI_ChatFontFace",uVar2); + FUN_005dee50(&DAT_00837564,2,0x10000003,uVar2); + local_30 = (void *)0x0; + local_2c = 0; + local_28 = 0; + uVar2 = FUN_004016b0("ID_UI_Value_Arial"); + uVar3 = FUN_00453850(1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') { + *(undefined4 *)((int)local_30 + local_28 * 4) = uVar2; + local_28 = local_28 + 1; + } + uVar2 = FUN_004016b0("ID_UI_Value_CourierNew"); + if (local_28 < (local_2c & 0x7fffffff)) { +LAB_00403afc: + *(undefined4 *)((int)local_30 + local_28 * 4) = uVar2; + local_28 = local_28 + 1; + } + else { + uVar3 = FUN_00453850((local_2c & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00403afc; + } + uVar2 = FUN_004016b0("ID_UI_Value_PalatinoLinotype"); + if (local_28 < (local_2c & 0x7fffffff)) { +LAB_00403b44: + *(undefined4 *)((int)local_30 + local_28 * 4) = uVar2; + local_28 = local_28 + 1; + } + else { + uVar3 = FUN_00453850((local_2c & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00403b44; + } + uVar2 = FUN_004016b0("ID_UI_Value_Tahoma"); + if (local_28 < (local_2c & 0x7fffffff)) { +LAB_00403b8c: + *(undefined4 *)((int)local_30 + local_28 * 4) = uVar2; + local_28 = local_28 + 1; + } + else { + uVar3 = FUN_00453850((local_2c & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00403b8c; + } + uVar2 = FUN_004016b0("ID_UI_Value_TimesNewRoman"); + if (local_28 < (local_2c & 0x7fffffff)) { +LAB_00403bd4: + *(undefined4 *)((int)local_30 + local_28 * 4) = uVar2; + local_28 = local_28 + 1; + } + else { + uVar3 = FUN_00453850((local_2c & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00403bd4; + } + FUN_005dea80(&DAT_00837564,&local_30); + uVar2 = FUN_004016b0("ID_UI_ChatFontSize_Help"); + uVar2 = FUN_004016b0("ID_UI_ChatFontSize",uVar2); + FUN_005dee50(&DAT_00837568,2,0x10000003,uVar2); + local_3c = (void *)0x0; + local_38 = 0; + local_34 = 0; + uVar2 = FUN_004016b0("ID_UI_Value_Tiny"); + uVar3 = FUN_00453850(1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') { + *(undefined4 *)((int)local_3c + local_34 * 4) = uVar2; + local_34 = local_34 + 1; + } + uVar2 = FUN_004016b0("ID_UI_Value_Small"); + if (local_34 < (local_38 & 0x7fffffff)) { +LAB_00403c9b: + *(undefined4 *)((int)local_3c + local_34 * 4) = uVar2; + local_34 = local_34 + 1; + } + else { + uVar3 = FUN_00453850((local_38 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00403c9b; + } + uVar2 = FUN_004016b0("ID_UI_Value_Medium"); + if (local_34 < (local_38 & 0x7fffffff)) { +LAB_00403ce3: + *(undefined4 *)((int)local_3c + local_34 * 4) = uVar2; + local_34 = local_34 + 1; + } + else { + uVar3 = FUN_00453850((local_38 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00403ce3; + } + uVar2 = FUN_004016b0("ID_UI_Value_Large"); + if (local_34 < (local_38 & 0x7fffffff)) { +LAB_00403d2b: + *(undefined4 *)((int)local_3c + local_34 * 4) = uVar2; + local_34 = local_34 + 1; + } + else { + uVar3 = FUN_00453850((local_38 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00403d2b; + } + uVar2 = FUN_004016b0("ID_UI_Value_XLarge"); + if (local_34 < (local_38 & 0x7fffffff)) { +LAB_00403d73: + *(undefined4 *)((int)local_3c + local_34 * 4) = uVar2; + local_34 = local_34 + 1; + } + else { + uVar3 = FUN_00453850((local_38 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00403d73; + } + FUN_005dea80(&DAT_00837568,&local_3c); + uVar2 = FUN_004016b0("ID_Graphics_TextureFiltering_Help"); + uVar2 = FUN_004016b0("ID_Graphics_TextureFiltering",uVar2); + FUN_005dee50(&DAT_008375e0,2,0x10000003,uVar2); + local_24 = (void *)0x0; + local_20 = 0; + local_1c = 0; + uVar2 = FUN_004016b0("ID_Graphics_TextureFiltering_Bilinear"); + uVar3 = FUN_00453850(1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') { + *(undefined4 *)((int)local_24 + local_1c * 4) = uVar2; + local_1c = local_1c + 1; + } + uVar2 = FUN_004016b0("ID_Graphics_TextureFiltering_Trilinear"); + if (local_1c < (local_20 & 0x7fffffff)) { +LAB_00403e3a: + *(undefined4 *)((int)local_24 + local_1c * 4) = uVar2; + local_1c = local_1c + 1; + } + else { + uVar3 = FUN_00453850((local_20 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00403e3a; + } + uVar2 = FUN_004016b0("ID_Graphics_TextureFiltering_Sharp"); + if (local_1c < (local_20 & 0x7fffffff)) { +LAB_00403e82: + *(undefined4 *)((int)local_24 + local_1c * 4) = uVar2; + local_1c = local_1c + 1; + } + else { + uVar3 = FUN_00453850((local_20 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00403e82; + } + uVar2 = FUN_004016b0("ID_Graphics_TextureFiltering_Anisotropic"); + if (local_1c < (local_20 & 0x7fffffff)) { +LAB_00403eca: + *(undefined4 *)((int)local_24 + local_1c * 4) = uVar2; + local_1c = local_1c + 1; + } + else { + uVar3 = FUN_00453850((local_20 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00403eca; + } + FUN_005dea80(&DAT_008375e0,&local_24); + uVar2 = FUN_004016b0("ID_Graphics_BuildingDetailTextures_Help"); + uVar2 = FUN_004016b0("ID_Graphics_BuildingDetailTextures",uVar2); + FUN_005dee50(&DAT_008375e8,4,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Graphics_MultiPassAlpha_Help"); + uVar2 = FUN_004016b0("ID_Graphics_MultiPassAlpha",uVar2); + FUN_005dee50(&DAT_0083761c,4,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Graphics_LandscapeTextureDetail_Help"); + uVar2 = FUN_004016b0("ID_Graphics_LandscapeTextureDetail",uVar2); + FUN_005dee50(&DAT_008375f0,2,0x10000003,uVar2); + local_48 = (void *)0x0; + local_44 = 0; + local_40 = 0; + uVar2 = FUN_004016b0("ID_Graphics_Value_VeryLow"); + uVar3 = FUN_00453850(1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') { + *(undefined4 *)((int)local_48 + local_40 * 4) = uVar2; + local_40 = local_40 + 1; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_Low"); + if (local_40 < (local_44 & 0x7fffffff)) { +LAB_00403feb: + *(undefined4 *)((int)local_48 + local_40 * 4) = uVar2; + local_40 = local_40 + 1; + } + else { + uVar3 = FUN_00453850((local_44 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00403feb; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_Medium"); + if (local_40 < (local_44 & 0x7fffffff)) { +LAB_00404033: + *(undefined4 *)((int)local_48 + local_40 * 4) = uVar2; + local_40 = local_40 + 1; + } + else { + uVar3 = FUN_00453850((local_44 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00404033; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_High"); + if (local_40 < (local_44 & 0x7fffffff)) { +LAB_0040407b: + *(undefined4 *)((int)local_48 + local_40 * 4) = uVar2; + local_40 = local_40 + 1; + } + else { + uVar3 = FUN_00453850((local_44 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_0040407b; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_VeryHigh"); + if (local_40 < (local_44 & 0x7fffffff)) { +LAB_004040c3: + *(undefined4 *)((int)local_48 + local_40 * 4) = uVar2; + local_40 = local_40 + 1; + } + else { + uVar3 = FUN_00453850((local_44 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_004040c3; + } + FUN_005dea80(&DAT_008375f0,&local_48); + uVar2 = FUN_004016b0("ID_Graphics_EnvironmentTextureDetail_Help"); + uVar2 = FUN_004016b0("ID_Graphics_EnvironmentTextureDetail",uVar2); + FUN_005dee50(&DAT_008375f4,2,0x10000003,uVar2); + local_54 = (void *)0x0; + local_50 = 0; + local_4c = 0; + uVar2 = FUN_004016b0("ID_Graphics_Value_VeryLow"); + uVar3 = FUN_00453850(1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') { + *(undefined4 *)((int)local_54 + local_4c * 4) = uVar2; + local_4c = local_4c + 1; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_Low"); + if (local_4c < (local_50 & 0x7fffffff)) { +LAB_0040418a: + *(undefined4 *)((int)local_54 + local_4c * 4) = uVar2; + local_4c = local_4c + 1; + } + else { + uVar3 = FUN_00453850((local_50 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_0040418a; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_Medium"); + if (local_4c < (local_50 & 0x7fffffff)) { +LAB_004041d2: + *(undefined4 *)((int)local_54 + local_4c * 4) = uVar2; + local_4c = local_4c + 1; + } + else { + uVar3 = FUN_00453850((local_50 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_004041d2; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_High"); + if (local_4c < (local_50 & 0x7fffffff)) { +LAB_0040421a: + *(undefined4 *)((int)local_54 + local_4c * 4) = uVar2; + local_4c = local_4c + 1; + } + else { + uVar3 = FUN_00453850((local_50 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_0040421a; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_VeryHigh"); + if (local_4c < (local_50 & 0x7fffffff)) { +LAB_00404262: + *(undefined4 *)((int)local_54 + local_4c * 4) = uVar2; + local_4c = local_4c + 1; + } + else { + uVar3 = FUN_00453850((local_50 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00404262; + } + FUN_005dea80(&DAT_008375f4,&local_54); + uVar2 = FUN_004016b0("ID_Graphics_SceneryDrawDistance_Help"); + uVar2 = FUN_004016b0("ID_Graphics_SceneryDrawDistance",uVar2); + FUN_005dee50(&DAT_008375f8,2,0x10000003,uVar2); + local_18 = (void *)0x0; + local_14 = 0; + local_10 = 0; + uVar2 = FUN_004016b0("ID_Graphics_Value_Low"); + uVar3 = FUN_00453850(1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') { + *(undefined4 *)((int)local_18 + local_10 * 4) = uVar2; + local_10 = local_10 + 1; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_Medium"); + if (local_10 < (local_14 & 0x7fffffff)) { +LAB_00404329: + *(undefined4 *)((int)local_18 + local_10 * 4) = uVar2; + local_10 = local_10 + 1; + } + else { + uVar3 = FUN_00453850((local_14 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00404329; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_High"); + if (local_10 < (local_14 & 0x7fffffff)) { +LAB_00404371: + *(undefined4 *)((int)local_18 + local_10 * 4) = uVar2; + local_10 = local_10 + 1; + } + else { + uVar3 = FUN_00453850((local_14 & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00404371; + } + FUN_005dea80(&DAT_008375f8,&local_18); + uVar2 = FUN_004016b0("ID_Graphics_LandscapeDrawDistance_Help"); + uVar2 = FUN_004016b0("ID_Graphics_LandscapeDrawDistance",uVar2); + FUN_005dee50(&DAT_008375fc,2,0x10000003,uVar2); + local_60 = (void *)0x0; + local_5c = 0; + local_58 = 0; + uVar2 = FUN_004016b0("ID_Graphics_Value_VeryLow"); + uVar3 = FUN_00453850(1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') { + *(undefined4 *)((int)local_60 + local_58 * 4) = uVar2; + local_58 = local_58 + 1; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_Low"); + if (local_58 < (local_5c & 0x7fffffff)) { +LAB_00404438: + *(undefined4 *)((int)local_60 + local_58 * 4) = uVar2; + local_58 = local_58 + 1; + } + else { + uVar3 = FUN_00453850((local_5c & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00404438; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_Medium"); + if (local_58 < (local_5c & 0x7fffffff)) { +LAB_00404480: + *(undefined4 *)((int)local_60 + local_58 * 4) = uVar2; + local_58 = local_58 + 1; + } + else { + uVar3 = FUN_00453850((local_5c & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00404480; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_High"); + if (local_58 < (local_5c & 0x7fffffff)) { +LAB_004044c8: + *(undefined4 *)((int)local_60 + local_58 * 4) = uVar2; + local_58 = local_58 + 1; + } + else { + uVar3 = FUN_00453850((local_5c & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_004044c8; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_VeryHigh"); + if (local_58 < (local_5c & 0x7fffffff)) { +LAB_00404510: + *(undefined4 *)((int)local_60 + local_58 * 4) = uVar2; + local_58 = local_58 + 1; + } + else { + uVar3 = FUN_00453850((local_5c & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 != '\0') goto LAB_00404510; + } + uVar2 = FUN_004016b0("ID_Graphics_Value_Extreme"); + if ((local_5c & 0x7fffffff) <= local_58) { + uVar3 = FUN_00453850((local_5c & 0x7fffffff) + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 == '\0') goto LAB_00404567; + } + *(undefined4 *)((int)local_60 + local_58 * 4) = uVar2; + local_58 = local_58 + 1; +LAB_00404567: + FUN_005dea80(&DAT_008375fc,&local_60); + uVar2 = FUN_004016b0("ID_Graphics_FieldOfView_Help"); + uVar2 = FUN_004016b0("ID_Graphics_FieldOfView",uVar2); + FUN_005dee50(&DAT_008375ec,3,0x10000003,uVar2); + FUN_005de990(&DAT_008375ec,0x41200000,0x43200000); + uVar2 = FUN_004016b0("ID_Graphics_ScreenBrightness_Help"); + uVar2 = FUN_004016b0("ID_Graphics_ScreenBrightness",uVar2); + FUN_005dee50(&DAT_00837600,3,0x10000003,uVar2); + FUN_005de990(&DAT_00837600,0xbf800000,0x3f800000); + uVar2 = FUN_004016b0("ID_Graphics_AdaptiveDegrade_Help"); + uVar2 = FUN_004016b0("ID_Graphics_AdaptiveDegrade",uVar2); + FUN_005dee50(&DAT_00837610,4,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Graphics_AdaptiveDegradeBias_Help"); + uVar2 = FUN_004016b0("ID_Graphics_AdaptiveDegradeBias",uVar2); + FUN_005dee50(&DAT_00837614,3,0x10000003,uVar2); + FUN_005de990(&DAT_00837614,0xbf800000,0x3f800000); + uVar2 = FUN_004016b0("ID_Graphics_DegradeDistance_Help"); + uVar2 = FUN_004016b0("ID_Graphics_DegradeDistance",uVar2); + FUN_005dee50(&DAT_00837618,3,0x10000003,uVar2); + FUN_005de990(&DAT_00837618,0,0x42c80000); + uVar2 = FUN_004016b0("ID_Rendering_FullScreen_Help"); + uVar2 = FUN_004016b0("ID_Rendering_FullScreen",uVar2); + FUN_005dee50(&DAT_00837598,4,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Rendering_SyncToDisplayRefresh_Help"); + uVar2 = FUN_004016b0("ID_Rendering_SyncToDisplayRefresh",uVar2); + FUN_005dee50(&DAT_008375a0,4,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Rendering_DisplayResolution_Help"); + uVar2 = FUN_004016b0("ID_Rendering_DisplayResolution",uVar2); + FUN_005dee50(&DAT_00837594,2,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Rendering_RefreshRate_Help"); + uVar2 = FUN_004016b0("ID_Rendering_RefreshRate",uVar2); + FUN_005dee50(&DAT_0083759c,2,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Input_MouseLookSensitivity_Help"); + uVar2 = FUN_004016b0("ID_Input_MouseLookSensitivity",uVar2); + FUN_005dee50(&DAT_00837688,3,0x10000003,uVar2); + FUN_005de990(&DAT_00837688,0x3c23d70a,0x3f800000); + uVar2 = FUN_004016b0("ID_Input_InvertMouseLookYAxis_Help"); + uVar2 = FUN_004016b0("ID_Input_InvertMouseLookYAxis",uVar2); + FUN_005dee50(&DAT_00837690,4,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Input_UseMouseTurning_Help"); + uVar2 = FUN_004016b0("ID_Input_UseMouseTurning",uVar2); + FUN_005dee50(&DAT_00837694,4,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Camera_AlignToSlope_Help"); + uVar2 = FUN_004016b0("ID_Camera_AlignToSlope",uVar2); + FUN_005dee50(&DAT_008375a4,4,0x10000003,uVar2); + uVar2 = FUN_004016b0("ID_Camera_Stiffness_Help"); + uVar2 = FUN_004016b0("ID_Camera_Stiffness",uVar2); + FUN_005dee50(&DAT_008375a8,3,0x10000003,uVar2); + FUN_005de990(&DAT_008375a8,0x3e924925,0x3f800000); + uVar2 = FUN_004016b0("ID_Camera_AdjustmentSpeed_Help"); + uVar2 = FUN_004016b0("ID_Camera_AdjustmentSpeed",uVar2); + FUN_005dee50(&DAT_008375ac,3,0x10000003,uVar2); + FUN_005de990(&DAT_008375ac,0x40a00000,0x42a00000); + if ((local_5c & 0x80000000) == 0x80000000) { + operator_delete__(local_60); + } + if ((local_14 & 0x80000000) == 0x80000000) { + operator_delete__(local_18); + } + if ((local_50 & 0x80000000) == 0x80000000) { + operator_delete__(local_54); + } + if ((local_44 & 0x80000000) == 0x80000000) { + operator_delete__(local_48); + } + if ((local_20 & 0x80000000) == 0x80000000) { + operator_delete__(local_24); + } + if ((local_38 & 0x80000000) == 0x80000000) { + operator_delete__(local_3c); + } + if ((local_2c & 0x80000000) == 0x80000000) { + operator_delete__(local_30); + } + if ((local_8 & 0x80000000) == 0x80000000) { + operator_delete__(local_c); + } + return; +} + + + +// --- FUN_00404a40 at 0x00404A40 (size: 148) --- + +undefined4 * __thiscall FUN_00404a40(undefined4 *param_1,undefined4 param_2,int param_3) + +{ + int iVar1; + int *piVar2; + LONG LVar3; + LONG *lpAddend; + undefined4 *puVar4; + undefined4 *local_4; + + lpAddend = (LONG *)(PTR_DAT_00818340 + -0x10); + *param_1 = PTR_DAT_00818340; + local_4 = param_1; + InterlockedIncrement(lpAddend); + FUN_00401340(param_3); + piVar2 = (int *)FUN_00403350(&local_4,0); + iVar1 = *(int *)(*piVar2 + -4); + if (iVar1 != 1) { + FUN_00402490(*piVar2,iVar1 + -1); + } + puVar4 = local_4 + -5; + LVar3 = InterlockedDecrement(local_4 + -4); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + LVar3 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(param_3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_3 + -0x14))(1); + } + return param_1; +} + + + +// --- FUN_00404b40 at 0x00404B40 (size: 89) --- + +int __thiscall FUN_00404b40(undefined4 *param_1,undefined4 *param_2,char param_3) + +{ + byte bVar1; + byte *pbVar2; + int iVar3; + byte *pbVar4; + bool bVar5; + + if (param_3 == '\0') { + iVar3 = _stricmp((char *)*param_1,(char *)*param_2); + return iVar3; + } + pbVar4 = (byte *)*param_2; + pbVar2 = (byte *)*param_1; + while( true ) { + bVar1 = *pbVar2; + bVar5 = bVar1 < *pbVar4; + if (bVar1 != *pbVar4) break; + if (bVar1 == 0) { + return 0; + } + bVar1 = pbVar2[1]; + bVar5 = bVar1 < pbVar4[1]; + if (bVar1 != pbVar4[1]) break; + pbVar2 = pbVar2 + 2; + pbVar4 = pbVar4 + 2; + if (bVar1 == 0) { + return 0; + } + } + return (1 - (uint)bVar5) - (uint)(bVar5 != 0); +} + + + +// --- FUN_00404ba0 at 0x00404BA0 (size: 298) --- + +undefined4 * FUN_00404ba0(uint param_1,uint *param_2) + +{ + int iVar1; + undefined4 *puVar2; + uint uVar3; + uint uVar4; + + uVar3 = *param_2 * param_1; + uVar4 = DAT_00837710 - (int)DAT_0083770c; + puVar2 = DAT_0083770c; + if (uVar4 < uVar3) { + do { + if (param_1 <= uVar4) { + *param_2 = uVar4 / param_1; + puVar2 = DAT_0083770c; + DAT_0083770c = (undefined4 *)((int)DAT_0083770c + (uVar4 / param_1) * param_1); + return puVar2; + } + iVar1 = ((DAT_00837708 >> 4) + 7 & 0xfffffff8) + uVar3 * 2; + if (uVar4 != 0) { + uVar3 = uVar4 - 1 >> 3; + *DAT_0083770c = *(undefined4 *)(&DAT_008376c8 + uVar3 * 4); + *(undefined4 **)(&DAT_008376c8 + uVar3 * 4) = DAT_0083770c; + } + DAT_0083770c = (undefined4 *)FUN_005df0f5(iVar1); + uVar3 = param_1; + if (DAT_0083770c == (undefined4 *)0x0) { + for (; uVar3 < 0x81; uVar3 = uVar3 + 8) { + uVar4 = uVar3 - 1 >> 3; + puVar2 = *(undefined4 **)(&DAT_008376c8 + uVar4 * 4); + if (puVar2 != (undefined4 *)0x0) { + *(undefined4 *)(&DAT_008376c8 + uVar4 * 4) = *puVar2; + DAT_00837710 = (int)puVar2 + uVar3; + DAT_0083770c = puVar2; + goto LAB_00404c6d; + } + } + DAT_00837710 = 0; + DAT_0083770c = (undefined4 *)FUN_005df0f5(iVar1); + } + DAT_00837708 = DAT_00837708 + iVar1; + DAT_00837710 = (int)DAT_0083770c + iVar1; +LAB_00404c6d: + uVar3 = *param_2 * param_1; + uVar4 = DAT_00837710 - (int)DAT_0083770c; + puVar2 = DAT_0083770c; + } while (uVar4 < uVar3); + } + DAT_0083770c = (undefined4 *)((int)puVar2 + uVar3); + return puVar2; +} + + + +// --- FUN_00404cd0 at 0x00404CD0 (size: 65) --- + +void __fastcall FUN_00404cd0(int *param_1) + +{ + undefined *puVar1; + LONG LVar2; + LONG *lpAddend; + + puVar1 = (undefined *)*param_1; + if (puVar1 != PTR_DAT_00818344) { + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + return; +} + + + +// --- FUN_00404d20 at 0x00404D20 (size: 23) --- + +bool FUN_00404d20(undefined4 param_1,undefined4 param_2) + +{ + int iVar1; + + iVar1 = FUN_00404b40(param_1,param_2); + return iVar1 == 0; +} + + + +// --- FUN_00404d40 at 0x00404D40 (size: 39) --- + +int __thiscall FUN_00404d40(int *param_1,undefined4 *param_2) + +{ + char *pcVar1; + + pcVar1 = strstr((char *)*param_1,(char *)*param_2); + if (pcVar1 == (char *)0x0) { + return -1; + } + return (int)pcVar1 - *param_1; +} + + + +// --- FUN_00404d70 at 0x00404D70 (size: 31) --- + +void __fastcall FUN_00404d70(undefined4 *param_1) + +{ + char *_Str; + int *piVar1; + + _Str = (char *)*param_1; + piVar1 = _errno(); + *piVar1 = 0; + strtoul(_Str,(char **)0x0,0); + return; +} + + + +// --- FUN_00404d90 at 0x00404D90 (size: 235) --- + +void FUN_00404d90(LONG *param_1) + +{ + uint uVar1; + LONG LVar2; + uint uVar3; + uint uVar4; + int iVar5; + int iVar6; + + LVar2 = InterlockedExchange(param_1,1); + uVar1 = DAT_00818298; + if (LVar2 != 0) { + uVar4 = 0; + if (DAT_00818298 != 0) { + uVar3 = DAT_00837714 >> 1; + do { + if (((uVar3 <= uVar4) && (*param_1 == 0)) && + (LVar2 = InterlockedExchange(param_1,1), LVar2 == 0)) { + DAT_00818298 = 1000; + DAT_00837714 = uVar4; + return; + } + uVar4 = uVar4 + 1; + } while (uVar4 < uVar1); + } + DAT_00818298 = 0x1e; + iVar6 = 6; + while( true ) { + iVar5 = iVar6; + if (0x1b < iVar6) { + iVar5 = 0x1b; + } + LVar2 = InterlockedExchange(param_1,1); + if (LVar2 == 0) break; + if (iVar5 < 0x15) { + Sleep(1); + iVar6 = iVar6 + 1; + } + else { + Sleep(1 << ((char)iVar5 - 0x14U & 0x1f)); + iVar6 = iVar6 + 1; + } + } + } + return; +} + + + +// --- FUN_00404e80 at 0x00404E80 (size: 104) --- + +void FUN_00404e80(int param_1) + +{ + undefined4 *puVar1; + int iVar2; + undefined4 *puVar3; + uint uVar4; + int local_4; + + uVar4 = param_1 + 7U & 0xfffffff8; + local_4 = 0x14; + iVar2 = FUN_00404ba0(uVar4,&local_4); + if (local_4 != 1) { + puVar3 = (undefined4 *)(iVar2 + uVar4); + *(undefined4 **)(&DAT_008376c8 + (uVar4 - 1 >> 3) * 4) = puVar3; + iVar2 = 1; + puVar1 = puVar3; + if (local_4 != 2) { + do { + puVar3 = (undefined4 *)((int)puVar1 + uVar4); + *puVar1 = puVar3; + iVar2 = iVar2 + 1; + puVar1 = puVar3; + } while (local_4 + -1 != iVar2); + } + *puVar3 = 0; + } + return; +} + + + +// --- FUN_00404ef0 at 0x00404EF0 (size: 133) --- + +void __thiscall FUN_00404ef0(int *param_1,char *param_2,size_t param_3) + +{ + uint uVar1; + int iVar2; + int iVar3; + + if (((param_2 != (char *)0x0) && (*param_2 != '\0')) && (param_3 != 0)) { + iVar2 = *param_1; + iVar3 = *(int *)(iVar2 + -4); + uVar1 = iVar3 + param_3; + if ((*(int *)(iVar2 + -0x10) == 1) && (uVar1 <= *(uint *)(iVar2 + -0xc))) { + *(uint *)(iVar2 + -4) = uVar1; + *(undefined4 *)(*param_1 + -8) = 0xffffffff; + } + else { + FUN_00401280(uVar1 - 1); + FUN_00401070(*param_1,iVar2); + FUN_004010a0(); + } + strncpy((char *)(*param_1 + -1 + iVar3),param_2,param_3); + *(undefined1 *)(*(int *)(*param_1 + -4) + -1 + *param_1) = 0; + } + return; +} + + + +// --- FUN_00404f80 at 0x00404F80 (size: 126) --- + +undefined4 * __thiscall FUN_00404f80(int *param_1,undefined4 *param_2,uint param_3,uint param_4) + +{ + int iVar1; + undefined *puVar2; + LONG LVar3; + uint uVar4; + + puVar2 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + iVar1 = *(int *)(*param_1 + -4); + uVar4 = iVar1 - 1; + if (param_3 < uVar4) { + if (uVar4 <= param_4) { + param_4 = iVar1 - 2; + } + FUN_00404ef0(*param_1 + param_3,(param_4 - param_3) + 1); + } + *param_2 = puVar2; + InterlockedIncrement((LONG *)(puVar2 + -0x10)); + LVar3 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + return param_2; +} + + + +// --- FUN_00405000 at 0x00405000 (size: 201) --- + +void __thiscall FUN_00405000(uint *param_1,char *param_2) + +{ + char cVar1; + uint uVar2; + char *pcVar3; + uint uVar4; + LONG LVar5; + LONG *lpAddend; + + if ((param_2 == (char *)0x0) || (*param_2 == '\0')) { + uVar2 = *param_1; + if ((undefined *)(-(uint)(uVar2 != 0x14) & uVar2) != PTR_DAT_00818344) { + LVar5 = InterlockedDecrement((LONG *)(uVar2 - 0x10)); + if ((LVar5 == 0) && ((undefined4 *)(uVar2 - 0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(uVar2 - 0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = (uint)PTR_DAT_00818344; + /* WARNING: Could not recover jumptable at 0x004050c3. Too many branches */ + /* WARNING: Treating indirect jump as call */ + InterlockedIncrement(lpAddend); + return; + } + } + else { + pcVar3 = param_2; + do { + cVar1 = *pcVar3; + pcVar3 = pcVar3 + 1; + } while (cVar1 != '\0'); + uVar4 = (int)pcVar3 - (int)(param_2 + 1); + uVar2 = *param_1; + if ((*(int *)(uVar2 - 0x10) == 1) && (uVar4 < *(uint *)(uVar2 - 0xc))) { + *(undefined4 *)(uVar2 - 8) = 0xffffffff; + *(uint *)(*param_1 - 4) = uVar4 + 1; + } + else { + LVar5 = InterlockedDecrement((LONG *)(uVar2 - 0x10)); + if ((LVar5 == 0) && ((undefined4 *)(uVar2 - 0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(uVar2 - 0x14))(1); + } + FUN_00401280(uVar4); + } + strncpy((char *)*param_1,param_2,uVar4 + 1); + } + return; +} + + + +// --- FUN_004050d0 at 0x004050D0 (size: 77) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_004050d0(int param_1) + +{ + int *piVar1; + + FUN_00404d90(&DAT_008376c0); + piVar1 = *(int **)(&DAT_008376c8 + (param_1 - 1U >> 3) * 4); + if (piVar1 != (int *)0x0) { + *(int *)(&DAT_008376c8 + (param_1 - 1U >> 3) * 4) = *piVar1; + _DAT_008376c0 = 0; + return; + } + FUN_00404e80(param_1); + _DAT_008376c0 = 0; + return; +} + + + +// --- FUN_00405120 at 0x00405120 (size: 153) --- + +uint __thiscall FUN_00405120(int param_1,int *param_2) + +{ + int *piVar1; + uint in_EAX; + LONG LVar2; + int iVar3; + undefined4 *puVar4; + + piVar1 = *(int **)(param_1 + 4); + if (piVar1 == (int *)0x0) { + return in_EAX & 0xffffff00; + } + iVar3 = piVar1[1]; + *(int *)(param_1 + 4) = iVar3; + if (iVar3 == 0) { + *(undefined4 *)(param_1 + 8) = 0; + } + else { + *(undefined4 *)(iVar3 + 8) = 0; + } + iVar3 = *param_2; + if (iVar3 != *piVar1) { + LVar2 = InterlockedDecrement((LONG *)(iVar3 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar3 + -0x14))(1); + } + iVar3 = *piVar1; + *param_2 = iVar3; + InterlockedIncrement((LONG *)(iVar3 + -0x10)); + } + puVar4 = (undefined4 *)(*piVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(*piVar1 + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + operator_delete(piVar1); + iVar3 = *(int *)(param_1 + 0xc) + -1; + *(int *)(param_1 + 0xc) = iVar3; + return CONCAT31((int3)((uint)iVar3 >> 8),1); +} + + + +// --- FUN_004051c0 at 0x004051C0 (size: 74) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_004051c0(undefined4 *param_1,uint param_2) + +{ + if (0x80 < param_2) { + operator_delete(param_1); + return; + } + FUN_00404d90(&DAT_008376c0); + *param_1 = *(undefined4 *)(&DAT_008376c8 + (param_2 - 1 >> 3) * 4); + *(undefined4 **)(&DAT_008376c8 + (param_2 - 1 >> 3) * 4) = param_1; + _DAT_008376c0 = 0; + return; +} + + + +// --- FUN_00405210 at 0x00405210 (size: 90) --- + +void __fastcall FUN_00405210(int param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + undefined *local_4; + + while (*(int *)(param_1 + 4) != 0) { + local_4 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00405120(&local_4); + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + } + return; +} + + + +// --- FUN_00405270 at 0x00405270 (size: 36) --- + +undefined4 * __thiscall FUN_00405270(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795074; + FUN_00405210(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004052a0 at 0x004052A0 (size: 247) --- + +void __thiscall +FUN_004052a0(int *param_1,void *param_2,undefined4 *param_3,undefined4 param_4,undefined4 *param_5, + char param_6) + +{ + int iVar1; + void *pvVar2; + void *pvVar3; + uint *puVar4; + uint uVar5; + size_t _Size; + undefined4 *_Dst; + uint local_4; + + uVar5 = (uint)param_5; + local_4 = param_1[1] - *param_1 >> 2; + puVar4 = (uint *)¶m_5; + if (param_5 <= local_4) { + puVar4 = &local_4; + } + local_4 = *puVar4 + local_4; + if (local_4 == 0) { + param_5 = (undefined4 *)0x0; + } + else if (local_4 * 4 < 0x81) { + param_5 = (undefined4 *)FUN_004050d0(local_4 * 4); + } + else { + param_5 = (undefined4 *)FUN_005df0f5(); + } + pvVar3 = (void *)*param_1; + _Dst = param_5; + if (param_2 != pvVar3) { + pvVar2 = memmove(param_5,pvVar3,(int)param_2 - (int)pvVar3); + _Dst = (undefined4 *)((int)pvVar2 + ((int)param_2 - (int)pvVar3)); + } + for (; uVar5 != 0; uVar5 = uVar5 - 1) { + *_Dst = *param_3; + _Dst = _Dst + 1; + } + if ((param_6 == '\0') && ((void *)param_1[1] != param_2)) { + _Size = param_1[1] - (int)param_2; + pvVar3 = memmove(_Dst,param_2,_Size); + _Dst = (undefined4 *)((int)pvVar3 + _Size); + } + iVar1 = *param_1; + if (iVar1 != 0) { + FUN_004051c0(iVar1,(param_1[2] - iVar1 >> 2) << 2); + } + param_1[1] = (int)_Dst; + *param_1 = (int)param_5; + param_1[2] = (int)(param_5 + local_4); + return; +} + + + +// --- FUN_004053a0 at 0x004053A0 (size: 433) --- + +uint __thiscall FUN_004053a0(undefined4 *param_1,int *param_2,int *param_3) + +{ + char cVar1; + char *pcVar2; + char *pcVar3; + LONG LVar4; + char *_Source; + char *pcVar5; + size_t _Count; + int *piVar6; + int iVar7; + char *local_18; + char *local_14; + char *local_10; + int local_c; + int *local_8; + int *local_4; + + piVar6 = (int *)0x0; + local_c = 0; + local_8 = (int *)0x0; + local_4 = (int *)0x0; + for (pcVar2 = strstr((char *)*param_1,(char *)*param_2); pcVar2 != (char *)0x0; + pcVar2 = strstr(pcVar2 + *(int *)((char *)*param_2 + -4) + -1,(char *)*param_2)) { + local_14 = pcVar2; + if (piVar6 == local_4) { + FUN_004052a0(piVar6,&local_14,¶m_3,1,1); + } + else { + if (piVar6 != (int *)0x0) { + *piVar6 = (int)pcVar2; + } + local_8 = piVar6 + 1; + } + piVar6 = local_8; + } + local_14 = (char *)((int)piVar6 - local_c >> 2); + if (local_14 == (char *)0x0) { + if (local_c != 0) { + FUN_004051c0(local_c,((int)local_4 - local_c >> 2) << 2); + } + return 0; + } + _Source = (char *)*param_1; + local_10 = _Source + -0x14; + FUN_00401280((*(int *)(*param_3 + -4) - *(int *)(*param_2 + -4)) * (int)local_14 + -1 + + *(int *)(_Source + -4)); + pcVar2 = (char *)*param_1; + local_18 = (char *)0x0; + pcVar3 = _Source + -0x14; + if (local_14 != (char *)0x0) { + do { + _Count = *(int *)(local_c + (int)local_18 * 4) - (int)_Source; + strncpy(pcVar2,_Source,_Count); + pcVar3 = (char *)*param_3; + pcVar5 = pcVar2 + _Count; + do { + cVar1 = *pcVar3; + pcVar3 = pcVar3 + 1; + *pcVar5 = cVar1; + pcVar5 = pcVar5 + 1; + } while (cVar1 != '\0'); + pcVar2 = pcVar2 + _Count + *(int *)(*param_3 + -4) + -1; + _Source = _Source + *(int *)(*param_2 + -4) + _Count + -1; + local_18 = local_18 + 1; + pcVar3 = local_10; + } while (local_18 < local_14); + } + iVar7 = (int)pcVar2 - (int)_Source; + do { + cVar1 = *_Source; + _Source[iVar7] = cVar1; + _Source = _Source + 1; + } while (cVar1 != '\0'); + LVar4 = InterlockedDecrement((LONG *)(pcVar3 + 4)); + if ((LVar4 == 0) && (pcVar3 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar3)(1); + } + if (local_c != 0) { + FUN_004051c0(local_c,((int)local_4 - local_c >> 2) << 2); + } + return (uint)local_14; +} + + + +// --- FUN_00405560 at 0x00405560 (size: 37) --- + +void FUN_00405560(void) + +{ + FUN_00405a60("kernel32.dll","MultiByteToWideChar",&PTR_FUN_00837394,DAT_009067c4, + _GodotFailMultiByteToWideChar_24); + /* WARNING: Could not recover jumptable at 0x0040557f. Too many branches */ + /* WARNING: Treating indirect jump as call */ + (*(code *)PTR_FUN_00837394)(); + return; +} + + + +// --- FUN_00405585 at 0x00405585 (size: 125) --- + +undefined2 FUN_00405585(byte *param_1,int param_2,int param_3,int param_4,int param_5) + +{ + byte bVar1; + byte *pbVar2; + int iVar3; + int iVar4; + byte *pbVar5; + bool bVar6; + int local_8; + + local_8 = 0; + param_2 = param_2 + -1; + if (-1 < param_2) { + do { + iVar4 = param_2 + local_8 >> 1; + pbVar2 = (byte *)(*(int *)(param_4 + iVar4 * 4) + param_3); + pbVar5 = param_1; + do { + bVar1 = *pbVar5; + bVar6 = bVar1 < *pbVar2; + if (bVar1 != *pbVar2) { +LAB_004055ce: + iVar3 = (1 - (uint)bVar6) - (uint)(bVar6 != 0); + goto LAB_004055d3; + } + if (bVar1 == 0) break; + bVar1 = pbVar5[1]; + bVar6 = bVar1 < pbVar2[1]; + if (bVar1 != pbVar2[1]) goto LAB_004055ce; + pbVar5 = pbVar5 + 2; + pbVar2 = pbVar2 + 2; + } while (bVar1 != 0); + iVar3 = 0; +LAB_004055d3: + if (iVar3 < 0) { + param_2 = iVar4 + -1; + } + else { + if (iVar3 < 1) break; + local_8 = iVar4 + 1; + } + } while (local_8 <= param_2); + if (local_8 <= param_2) { + return *(undefined2 *)(param_5 + iVar4 * 2); + } + } + return 0xffff; +} + + + +// --- FUN_00405602 at 0x00405602 (size: 58) --- + +int FUN_00405602(int param_1,ushort param_2,undefined4 *param_3) + +{ + int iVar1; + int iVar2; + uint uVar3; + + iVar1 = *(int *)(param_1 + 0x3c) + param_1; + if (((iVar1 == 0) || (uVar3 = (uint)param_2, *(uint *)(iVar1 + 0x74) <= uVar3)) || + (iVar2 = *(int *)(iVar1 + 0x78 + uVar3 * 8), iVar2 == 0)) { + *param_3 = 0; + iVar2 = 0; + } + else { + *param_3 = *(undefined4 *)(iVar1 + 0x7c + uVar3 * 8); + iVar2 = iVar2 + param_1; + } + return iVar2; +} + + + +// --- FUN_0040563c at 0x0040563C (size: 35) --- + +bool FUN_0040563c(PCNZCH param_1,PCNZCH param_2) + +{ + int iVar1; + + iVar1 = CompareStringA(0x409,1,param_1,-1,param_2,-1); + return iVar1 == 2; +} + + + +// --- FUN_0040565f at 0x0040565F (size: 63) --- + +char * FUN_0040565f(char *param_1,char *param_2,int param_3) + +{ + char cVar1; + uint uVar2; + uint uVar3; + char *pcVar4; + + pcVar4 = param_1; + if (param_3 != 0) { + do { + cVar1 = *param_2; + *pcVar4 = cVar1; + pcVar4 = pcVar4 + 1; + param_2 = param_2 + 1; + if (cVar1 == '\0') break; + param_3 = param_3 + -1; + } while (param_3 != 0); + if ((param_3 != 0) && (uVar2 = param_3 - 1, uVar2 != 0)) { + for (uVar3 = uVar2 >> 2; uVar3 != 0; uVar3 = uVar3 - 1) { + pcVar4[0] = '\0'; + pcVar4[1] = '\0'; + pcVar4[2] = '\0'; + pcVar4[3] = '\0'; + pcVar4 = pcVar4 + 4; + } + for (uVar2 = uVar2 & 3; uVar2 != 0; uVar2 = uVar2 - 1) { + *pcVar4 = '\0'; + pcVar4 = pcVar4 + 1; + } + } + } + return param_1; +} + + + +// --- _GetProcAddressInternal@8 at 0x0040569E (size: 100) --- + +/* Library Function - Single Match + _GetProcAddressInternal@8 + + Libraries: Visual Studio 2005 Release, Visual Studio 2008 Release, Visual Studio 2010 Release, + Visual Studio 2015 Release */ + +uint _GetProcAddressInternal_8(int param_1,int param_2) + +{ + int iVar1; + uint uVar2; + uint uVar3; + + iVar1 = param_1; + if (((param_1 != 0) && (param_2 != 0)) && (uVar2 = FUN_00405602(param_1,0,¶m_1), uVar2 != 0)) + { + uVar3 = FUN_00405585(param_2,*(undefined4 *)(uVar2 + 0x18),iVar1,*(int *)(uVar2 + 0x20) + iVar1, + *(int *)(uVar2 + 0x24) + iVar1); + if ((uVar3 & 0xffff) < *(uint *)(uVar2 + 0x14)) { + uVar3 = *(int *)(*(int *)(uVar2 + 0x1c) + (uVar3 & 0xffff) * 4 + iVar1) + iVar1; + if (uVar3 <= uVar2) { + return uVar3; + } + if (param_1 + uVar2 <= uVar3) { + return uVar3; + } + } + } + return 0; +} + + + +// --- FUN_00405702 at 0x00405702 (size: 155) --- + +void FUN_00405702(char *param_1,undefined1 *param_2,undefined1 *param_3) + +{ + char *pcVar1; + uint uVar2; + char cVar3; + char *pcVar4; + + pcVar1 = param_1; + do { + cVar3 = *pcVar1; + pcVar1 = pcVar1 + 1; + } while (cVar3 != '\0'); + if ((pcVar1 == param_1 + 1) || (param_1[1] != ':')) { + if (param_2 != (undefined1 *)0x0) { + *param_2 = 0; + } + } + else { + if (param_2 != (undefined1 *)0x0) { + FUN_0040565f(param_2,param_1,2); + param_2[2] = 0; + } + param_1 = param_1 + 2; + } + cVar3 = *param_1; + pcVar1 = (char *)0x0; + pcVar4 = param_1; + if (cVar3 != '\0') { + do { + if ((cVar3 == '/') || (cVar3 == '\\')) { + pcVar1 = pcVar4 + 1; + } + pcVar4 = pcVar4 + 1; + cVar3 = *pcVar4; + } while (cVar3 != '\0'); + if (pcVar1 != (char *)0x0) { + if (param_3 == (undefined1 *)0x0) { + return; + } + uVar2 = (int)pcVar1 - (int)param_1; + if (0xff < uVar2) { + uVar2 = 0xff; + } + FUN_0040565f(param_3,param_1,uVar2); + param_3[uVar2] = 0; + return; + } + } + if (param_3 != (undefined1 *)0x0) { + *param_3 = 0; + } + return; +} + + + +// --- FUN_0040579d at 0x0040579D (size: 707) --- + +/* WARNING: Type propagation algorithm not settling */ + +HMODULE FUN_0040579d(void) + +{ + char cVar1; + HKEY *ppHVar2; + UINT UVar3; + DWORD DVar4; + HMODULE pHVar5; + char *pcVar6; + HKEY *ppHVar7; + int iVar8; + LONG LVar9; + code *pcVar10; + code *pcVar11; + char *pcVar12; + uint uVar13; + uint uVar14; + char *pcVar15; + CHAR local_530 [264]; + CHAR local_428 [264]; + char local_320 [256]; + CHAR local_220 [263]; + char acStack_119 [265]; + undefined4 local_10; + HMODULE local_c; + HKEY local_8; + + if ((DAT_009067c0 == (code *)0x0) || + (local_c = (HMODULE)(*DAT_009067c0)(), local_c == (HMODULE)0x0)) { + local_c = LoadLibraryA(PTR_s_unicows_dll_008182a0); + if (local_c != (HMODULE)0x0) { + UVar3 = GetSystemDirectoryA(local_530,0x104); + if (UVar3 == 0) { + local_530[0] = '\0'; + } + UVar3 = GetWindowsDirectoryA(local_428,0x104); + if (UVar3 == 0) { + local_428[0] = '\0'; + } + DVar4 = GetModuleFileNameA(local_c,local_220,0x104); + if (DVar4 == 0) { + local_220[0] = '\0'; + } + DVar4 = 0x104; + pcVar6 = acStack_119 + 1; + pHVar5 = GetModuleHandleA((LPCSTR)0x0); + DVar4 = GetModuleFileNameA(pHVar5,pcVar6,DVar4); + if (DVar4 == 0) { + acStack_119[1] = 0; + } + FUN_00405702(acStack_119 + 1,&local_8,local_320); + ppHVar2 = &local_8; + do { + ppHVar7 = ppHVar2; + ppHVar2 = (HKEY *)((int)ppHVar7 + 1); + } while (*(char *)ppHVar7 != '\0'); + pcVar6 = local_320; + do { + cVar1 = *pcVar6; + pcVar6 = pcVar6 + 1; + } while (cVar1 != '\0'); + (pcVar6 + (int)(ppHVar7 + 0x84))[-(int)&stack0x00000000] = '\0'; + FUN_00405702(local_220,&local_8,local_320); + ppHVar2 = &local_8; + do { + ppHVar7 = ppHVar2; + ppHVar2 = (HKEY *)((int)ppHVar7 + 1); + } while (*(char *)ppHVar7 != '\0'); + pcVar6 = local_320; + do { + cVar1 = *pcVar6; + pcVar6 = pcVar6 + 1; + } while (cVar1 != '\0'); + (pcVar6 + (int)(ppHVar7 + 0x42))[-(int)&stack0x00000000] = '\0'; + iVar8 = FUN_0040563c(local_428,local_220); + if (((iVar8 == 0) && (iVar8 = FUN_0040563c(local_428,acStack_119 + 1), iVar8 != 0)) || + ((iVar8 = FUN_0040563c(local_530,local_220), iVar8 == 0 && + (iVar8 = FUN_0040563c(local_530,acStack_119 + 1), iVar8 != 0)))) { + FreeLibrary(local_c); + local_c = (HMODULE)0x0; + } + if (local_c != (HMODULE)0x0) { + return local_c; + } + } + local_8 = (HKEY)0x0; + pHVar5 = LoadLibraryA("advapi32.dll"); + LVar9 = InterlockedExchange(&DAT_008182c4,(LONG)pHVar5); + if (LVar9 != 0) { + FreeLibrary(pHVar5); + } + if (DAT_008182c4 != 0) { + pcVar10 = (code *)_GetProcAddressInternal_8(DAT_008182c4,"RegOpenKeyExA"); + pcVar11 = (code *)_GetProcAddressInternal_8(DAT_008182c4,"RegQueryValueExA"); + if (((pcVar10 != (code *)0x0) && (pcVar11 != (code *)0x0)) && + (iVar8 = (*pcVar10)(0x80000002,"SOFTWARE\\Microsoft\\Windows\\CurrentVersion",0,1,&local_8) + , iVar8 == 0)) { + local_10 = 0x104; + acStack_119[1] = 0; + iVar8 = (*pcVar11)(local_8,"CommonFilesDir",0,0,acStack_119 + 1,&local_10); + if (iVar8 == 0) { + pcVar6 = "\\Microsoft Shared\\MSLU\\"; + do { + pcVar12 = pcVar6; + pcVar6 = pcVar12 + 1; + } while (*pcVar12 != '\0'); + pcVar6 = acStack_119; + do { + pcVar15 = pcVar6 + 1; + pcVar6 = pcVar6 + 1; + } while (*pcVar15 != '\0'); + pcVar15 = "\\Microsoft Shared\\MSLU\\"; + for (uVar13 = (uint)(pcVar12 + -0x7951df) >> 2; uVar13 != 0; uVar13 = uVar13 - 1) { + *(undefined4 *)pcVar6 = *(undefined4 *)pcVar15; + pcVar15 = pcVar15 + 4; + pcVar6 = pcVar6 + 4; + } + for (uVar13 = (uint)(pcVar12 + -0x7951df) & 3; pcVar12 = PTR_s_unicows_dll_008182a0, + uVar13 != 0; uVar13 = uVar13 - 1) { + *pcVar6 = *pcVar15; + pcVar15 = pcVar15 + 1; + pcVar6 = pcVar6 + 1; + } + do { + cVar1 = *pcVar12; + pcVar12 = pcVar12 + 1; + } while (cVar1 != '\0'); + uVar13 = (int)pcVar12 - (int)PTR_s_unicows_dll_008182a0; + pcVar6 = acStack_119; + do { + pcVar12 = pcVar6 + 1; + pcVar6 = pcVar6 + 1; + } while (*pcVar12 != '\0'); + pcVar12 = PTR_s_unicows_dll_008182a0; + for (uVar14 = uVar13 >> 2; uVar14 != 0; uVar14 = uVar14 - 1) { + *(undefined4 *)pcVar6 = *(undefined4 *)pcVar12; + pcVar12 = pcVar12 + 4; + pcVar6 = pcVar6 + 4; + } + for (uVar13 = uVar13 & 3; uVar13 != 0; uVar13 = uVar13 - 1) { + *pcVar6 = *pcVar12; + pcVar12 = pcVar12 + 1; + pcVar6 = pcVar6 + 1; + } + local_c = LoadLibraryA(acStack_119 + 1); + } + RegCloseKey(local_8); + } + } + } + return local_c; +} + + + +// --- FUN_00405a60 at 0x00405A60 (size: 339) --- + +void FUN_00405a60(byte *param_1,undefined4 param_2,LONG *param_3,int param_4,LONG param_5) + +{ + LONG *Target; + byte bVar1; + DWORD DVar2; + byte *pbVar3; + int iVar4; + HMODULE pHVar5; + LONG LVar6; + byte *pbVar7; + int iVar8; + bool bVar9; + _MEMORY_BASIC_INFORMATION local_20; + + if (DAT_00837718 == 0) { + DVar2 = GetVersion(); + if (0x7fffffff < DVar2) { + DAT_00837718 = 2; + goto LAB_00405a9b; + } + DAT_00837718 = 1; +LAB_00405aaa: + iVar8 = 1; + pbVar7 = PTR_s_kernel32_dll_008182a8; + if (DAT_0083771c == (HANDLE)0x0) { + VirtualQuery(FUN_00405a60,&local_20,0x1c); + DAT_0083771c = local_20.AllocationBase; + pbVar7 = PTR_s_kernel32_dll_008182a8; + } + while (pbVar3 = param_1, pbVar7 != (byte *)0x0) { + do { + bVar1 = *pbVar3; + bVar9 = bVar1 < *pbVar7; + if (bVar1 != *pbVar7) { +LAB_00405afb: + iVar4 = (1 - (uint)bVar9) - (uint)(bVar9 != 0); + goto LAB_00405b00; + } + if (bVar1 == 0) break; + bVar1 = pbVar3[1]; + bVar9 = bVar1 < pbVar7[1]; + if (bVar1 != pbVar7[1]) goto LAB_00405afb; + pbVar7 = pbVar7 + 2; + pbVar3 = pbVar3 + 2; + } while (bVar1 != 0); + iVar4 = 0; +LAB_00405b00: + if (iVar4 == 0) { + Target = &DAT_008182a4 + iVar8 * 2; + if (*Target == 0) { + pHVar5 = LoadLibraryA((LPCSTR)param_1); + LVar6 = InterlockedExchange(Target,(LONG)pHVar5); + if (LVar6 != 0) { + FreeLibrary(pHVar5); + } + } + LVar6 = *Target; + goto LAB_00405ba0; + } + iVar4 = iVar8 * 2; + iVar8 = iVar8 + 1; + pbVar7 = (&PTR_s_kernel32_dll_008182a8)[iVar4]; + } + } + else { +LAB_00405a9b: + if (DAT_00837718 == 1) goto LAB_00405aaa; + if (param_4 == 0) { + LVar6 = DAT_008182a4; + if (DAT_008182a4 != 0) { +LAB_00405ba0: + param_4 = _GetProcAddressInternal_8(LVar6,param_2); + goto LAB_00405ba5; + } + pHVar5 = (HMODULE)FUN_0040579d(); + if ((pHVar5 != (HMODULE)0x0) && + (LVar6 = InterlockedExchange(&DAT_008182a4,(LONG)pHVar5), LVar6 != 0)) { + FreeLibrary(pHVar5); + } + LVar6 = DAT_008182a4; + if (DAT_008182a4 != 0) goto LAB_00405ba0; + } + else { +LAB_00405ba5: + if (param_4 != 0) goto LAB_00405b13; + } + } + param_4 = param_5; +LAB_00405b13: + InterlockedExchange(param_3,param_4); + FlushInstructionCache(DAT_0083771c,param_3,4); + return; +} + + + +// --- _GodotFailMultiByteToWideChar@24 at 0x00405C68 (size: 46) --- + +/* Library Function - Single Match + _GodotFailMultiByteToWideChar@24 + + Libraries: Visual Studio 2005 Release, Visual Studio 2008 Release, Visual Studio 2010 Release, + Visual Studio 2015 Release */ + +undefined4 _GodotFailMultiByteToWideChar_24(void) + +{ + HMODULE pHVar1; + code *UNRECOVERED_JUMPTABLE; + undefined4 uVar2; + char *pcVar3; + + pcVar3 = "MultiByteToWideChar"; + pHVar1 = GetModuleHandleA("kernel32.dll"); + UNRECOVERED_JUMPTABLE = (code *)_GetProcAddressInternal_8(pHVar1,pcVar3); + if (UNRECOVERED_JUMPTABLE != (code *)0x0) { + /* WARNING: Could not recover jumptable at 0x00405c86. Too many branches */ + /* WARNING: Treating indirect jump as call */ + uVar2 = (*UNRECOVERED_JUMPTABLE)(); + return uVar2; + } + SetLastError(0x7f); + return 0; +} + + + +// --- FID_conflict:_GodotFailWideCharToMultiByte@32 at 0x00405C96 (size: 46) --- + +/* Library Function - Multiple Matches With Different Base Names + _GodotFailExtTextOutW@32 + _GodotFailWideCharToMultiByte@32 + + Libraries: Visual Studio 2005 Release, Visual Studio 2008 Release, Visual Studio 2010 Release, + Visual Studio 2015 Release */ + +undefined4 FID_conflict__GodotFailWideCharToMultiByte_32(void) + +{ + HMODULE pHVar1; + code *UNRECOVERED_JUMPTABLE; + undefined4 uVar2; + char *pcVar3; + + pcVar3 = "WideCharToMultiByte"; + pHVar1 = GetModuleHandleA("kernel32.dll"); + UNRECOVERED_JUMPTABLE = (code *)_GetProcAddressInternal_8(pHVar1,pcVar3); + if (UNRECOVERED_JUMPTABLE != (code *)0x0) { + /* WARNING: Could not recover jumptable at 0x00405cb4. Too many branches */ + /* WARNING: Treating indirect jump as call */ + uVar2 = (*UNRECOVERED_JUMPTABLE)(); + return uVar2; + } + SetLastError(0x7f); + return 0; +} + + + +// --- FID_conflict:_GodotFailWideCharToMultiByte@32 at 0x00405D81 (size: 46) --- + +/* Library Function - Multiple Matches With Different Base Names + _GodotFailExtTextOutW@32 + _GodotFailWideCharToMultiByte@32 + + Libraries: Visual Studio 2005 Release, Visual Studio 2008 Release, Visual Studio 2010 Release, + Visual Studio 2015 Release */ + +undefined4 FID_conflict__GodotFailWideCharToMultiByte_32(void) + +{ + HMODULE pHVar1; + code *UNRECOVERED_JUMPTABLE; + undefined4 uVar2; + char *pcVar3; + + pcVar3 = "ExtTextOutW"; + pHVar1 = GetModuleHandleA("gdi32.dll"); + UNRECOVERED_JUMPTABLE = (code *)_GetProcAddressInternal_8(pHVar1,pcVar3); + if (UNRECOVERED_JUMPTABLE != (code *)0x0) { + /* WARNING: Could not recover jumptable at 0x00405d9f. Too many branches */ + /* WARNING: Treating indirect jump as call */ + uVar2 = (*UNRECOVERED_JUMPTABLE)(); + return uVar2; + } + SetLastError(0x7f); + return 0; +} + + + +// --- FUN_00405de0 at 0x00405DE0 (size: 119) --- + +undefined4 FUN_00405de0(LPTHREAD_START_ROUTINE param_1,undefined4 *param_2) + +{ + HANDLE pvVar1; + DWORD DVar2; + + pvVar1 = CreateEventA((LPSECURITY_ATTRIBUTES)0x0,1,0,(LPCSTR)0x0); + *param_2 = pvVar1; + pvVar1 = CreateThread((LPSECURITY_ATTRIBUTES)0x0,0,param_1,param_2,0,param_2 + 1); + if (pvVar1 != (HANDLE)0x0) { + DVar2 = WaitForSingleObject((HANDLE)*param_2,1000); + if (DVar2 == 0) { + WaitForSingleObject(pvVar1,0xffffffff); + CloseHandle(pvVar1); + CloseHandle((HANDLE)*param_2); + return 1; + } + CloseHandle(pvVar1); + } + CloseHandle((HANDLE)*param_2); + return 0; +} + + + +// --- FUN_00405e60 at 0x00405E60 (size: 31) --- + +void FUN_00405e60(uint param_1,char param_2) + +{ + if (param_2 != '\0') { + DAT_00818338 = DAT_00818338 | param_1; + return; + } + DAT_00818338 = DAT_00818338 & ~param_1; + return; +} + + + +// --- FUN_00405e80 at 0x00405E80 (size: 6) --- + +undefined4 FUN_00405e80(void) + +{ + return DAT_00818338; +} + + + +// --- FUN_00405e90 at 0x00405E90 (size: 22) --- + +bool FUN_00405e90(uint param_1) + +{ + return (DAT_00818338 & param_1) == param_1; +} + + + +// --- FUN_00405eb0 at 0x00405EB0 (size: 30) --- + +void FUN_00405eb0(void) + +{ + if (DAT_00837724 == '\0') { + FUN_0040e3a0(); + DAT_00837724 = '\x01'; + /* WARNING: Subroutine does not return */ + _exit(0); + } + return; +} + + + +// --- FUN_00405ed0 at 0x00405ED0 (size: 84) --- + +undefined4 FUN_00405ed0(undefined4 param_1) + +{ + uint uVar1; + undefined4 uVar2; + uint uVar3; + + uVar3 = DAT_00818338 & 0x4000; + DAT_00818338 = DAT_00818338 & 0xffffbfff; + FUN_0040e3a0(); + uVar1 = DAT_00818338; + DAT_00818338 = DAT_00818338 & 0xffffffb7; + if (uVar3 == 0x4000) { + DAT_00818338 = DAT_00818338 | 0x4000; + } + else { + DAT_00818338 = uVar1 & 0xffffbfb7; + } + if (DAT_00837728 != (code *)0x0) { + uVar2 = (*DAT_00837728)(param_1); + return uVar2; + } + return 0; +} + + + +// --- FUN_00405f30 at 0x00405F30 (size: 9) --- + +void __fastcall FUN_00405f30(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_007952b0; + return; +} + + + +// --- FUN_00405f40 at 0x00405F40 (size: 37) --- + +void __fastcall FUN_00405f40(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_007952b0; + if (DAT_00837728 != (LPTOP_LEVEL_EXCEPTION_FILTER)0x0) { + SetUnhandledExceptionFilter(DAT_00837728); + DAT_00837728 = (LPTOP_LEVEL_EXCEPTION_FILTER)0x0; + } + FUN_0040e880(); + return; +} + + + +// --- FUN_00405f70 at 0x00405F70 (size: 40) --- + +LONG __fastcall FUN_00405f70(undefined4 *param_1) + +{ + LONG LVar1; + + LVar1 = InterlockedDecrement(param_1 + 1); + if (LVar1 != 0) { + return param_1[1]; + } + if (param_1 != (undefined4 *)0x0) { + (**(code **)*param_1)(1); + } + return 0; +} + + + +// --- FUN_00405fa0 at 0x00405FA0 (size: 72) --- + +void FUN_00405fa0(char param_1,uint param_2) + +{ + uint uVar1; + + uVar1 = _control87(0,0); + _clearfp(); + if (param_1 == '\0') { + _control87(uVar1 | param_2,0x8001f); + return; + } + _control87(uVar1 & ~param_2,0x8001f); + return; +} + + + +// --- FUN_00405ff0 at 0x00405FF0 (size: 39) --- + +undefined4 FUN_00405ff0(undefined4 *param_1) + +{ + undefined4 uVar1; + + SetEvent((HANDLE)*param_1); + uVar1 = FUN_00405ed0(param_1[2],param_1 + 4); + param_1[3] = uVar1; + return 0; +} + + + +// --- FUN_00406020 at 0x00406020 (size: 119) --- + +undefined4 FUN_00406020(undefined4 param_1) + +{ + char cVar1; + undefined4 uVar2; + undefined1 local_20 [8]; + undefined4 local_18; + undefined4 local_14; + + DAT_0081833c = 0; + local_18 = param_1; + FUN_0040e7d0(param_1); + cVar1 = FUN_00405de0(FUN_00405ff0,local_20); + if (cVar1 != '\0') { + FUN_0040e7b0(); + return local_14; + } + if (DAT_00837728 != (code *)0x0) { + uVar2 = (*DAT_00837728)(param_1); + FUN_0040e7b0(); + return uVar2; + } + FUN_0040e7b0(); + return 0; +} + + + +// --- FUN_004060a0 at 0x004060A0 (size: 374) --- + +undefined4 FUN_004060a0(undefined4 *param_1) + +{ + int iVar1; + undefined4 uVar2; + HANDLE pvVar3; + LPVOID pvVar4; + bool bVar5; + DWORD DVar6; + SIZE_T SVar7; + undefined1 local_10 [16]; + + _clearfp(); + iVar1 = *(int *)*param_1; + if (iVar1 == -0x7ffffffd) { +LAB_004060e1: + if (DAT_00837728 != (code *)0x0) { + uVar2 = (*DAT_00837728)(param_1); + return uVar2; + } + return 0; + } + if ((iVar1 == -0x3fffffe9) && ((DAT_00818338._1_1_ & 0x40) == 0)) { + return 0xffffffff; + } + if (DAT_0083773c != '\0') { + FUN_0040e3a0(); + goto LAB_004060e1; + } + DAT_0083773c = '\x01'; + if (iVar1 != -0x3fffffe9) { + SVar7 = 0x400000; + DVar6 = 0; + pvVar3 = GetProcessHeap(); + pvVar4 = HeapAlloc(pvVar3,DVar6,SVar7); + bVar5 = pvVar4 != (LPVOID)0x0; + DVar6 = 0; + pvVar3 = GetProcessHeap(); + HeapFree(pvVar3,DVar6,pvVar4); + if (bVar5) goto LAB_004061a6; + } + if (DAT_00837734 != (LPVOID)0x0) { + VirtualFree(DAT_00837734,0,0x8000); + } + SVar7 = 0x400000; + DVar6 = 0; + DAT_00837734 = (LPVOID)0x0; + pvVar3 = GetProcessHeap(); + pvVar4 = HeapAlloc(pvVar3,DVar6,SVar7); + bVar5 = pvVar4 == (LPVOID)0x0; + DVar6 = 0; + pvVar3 = GetProcessHeap(); + HeapFree(pvVar3,DVar6,pvVar4); + if (bVar5) { + FUN_0040e3a0(); + if (DAT_00837728 != (code *)0x0) { + uVar2 = (*DAT_00837728)(param_1); + return uVar2; + } + return 0; + } +LAB_004061a6: + if ((*(int *)*param_1 == -0x3fffff03) && (DAT_0081833c != '\0')) { + uVar2 = FUN_00406020(param_1); + DAT_0083773c = '\0'; + return uVar2; + } + FUN_0040e7d0(param_1); + uVar2 = FUN_00405ed0(param_1,local_10); + DAT_0083773c = '\0'; + FUN_0040e7b0(); + return uVar2; +} + + + +// --- FUN_00406220 at 0x00406220 (size: 84) --- + +undefined4 FUN_00406220(void) + +{ + uint uVar1; + + if (((DAT_00818338._1_1_ & 2) != 0) && (DAT_00837728 == (LPTOP_LEVEL_EXCEPTION_FILTER)0x0)) { + DAT_00837728 = SetUnhandledExceptionFilter(FUN_004060a0); + } + if ((DAT_00818338._1_1_ & 4) != 0) { + uVar1 = _control87(0,0); + _clearfp(); + _control87(uVar1 & 0xfffffff7,0x8001f); + } + return 1; +} + + + +// --- FUN_004062a0 at 0x004062A0 (size: 91) --- + +void __thiscall FUN_004062a0(int *param_1,char *param_2,va_list param_3) + +{ + int iVar1; + size_t _Count; + char *_Dest; + + iVar1 = _vsnprintf((char *)*param_1,0x1000,param_2,param_3); + if (iVar1 < 0) { + _Count = _vscprintf(param_2,param_3); + _Dest = (char *)thunk_FUN_005df0f5(_Count + 1); + if (_Dest != (char *)0x0) { + *param_1 = (int)_Dest; + _vsnprintf(_Dest,_Count,param_2,param_3); + *(undefined1 *)(_Count + *param_1) = 0; + } + } + return; +} + + + +// --- FUN_00406300 at 0x00406300 (size: 129) --- + +undefined4 FUN_00406300(undefined4 param_1,undefined4 param_2,uint param_3) + +{ + uint uVar1; + undefined4 uVar2; + + DAT_00818338 = DAT_00818338 & ~param_3; + FUN_00405000(param_1); + FUN_00405000(param_2); + if ((DAT_00818338 & 0x2000) != 0) { + uVar1 = DAT_00818338 & 0x800; + DAT_00818338 = DAT_00818338 & 0xffffdfff; + FUN_0040fa40(CONCAT31((int3)(uVar1 >> 8),uVar1 != 0x800)); + if ((DAT_00818338 & 0x200) != 0) { + DAT_00837734 = VirtualAlloc((LPVOID)0x0,0x6400000,0x2000,4); + } + /* WARNING: Could not recover jumptable at 0x0040637c. Too many branches */ + /* WARNING: Treating indirect jump as call */ + uVar2 = (*(code *)**(undefined4 **)PTR_DAT_00818550)(); + return uVar2; + } + return 1; +} + + + +// --- FUN_00406390 at 0x00406390 (size: 17) --- + +bool FUN_00406390(uint *param_1,uint param_2) + +{ + return *param_1 < param_2; +} + + + +// --- FUN_004063b0 at 0x004063B0 (size: 64) --- + +undefined4 * __thiscall FUN_004063b0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007952dc; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004063f0 at 0x004063F0 (size: 71) --- + +void __thiscall FUN_004063f0(int param_1,int *param_2) + +{ + int *piVar1; + + piVar1 = *(int **)(param_1 + 100); + while( true ) { + if (piVar1 == (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + param_2[1] = 0; + param_2[2] = 0; + *param_2 = param_1; + return; + } + if (**(int **)(param_1 + 100) != 0) break; + piVar1 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar1; + } + piVar1 = *(int **)(param_1 + 100); + param_2[2] = *piVar1; + param_2[1] = (int)piVar1; + *param_2 = param_1; + return; +} + + + +// --- FUN_00406440 at 0x00406440 (size: 85) --- + +void __thiscall FUN_00406440(int param_1,int *param_2,uint *param_3) + +{ + undefined4 *puVar1; + uint *puVar2; + + puVar1 = (undefined4 *)(*(int *)(param_1 + 0x60) + (*param_3 % *(uint *)(param_1 + 0x68)) * 4); + for (puVar2 = (uint *)*puVar1; + (puVar2 != (uint *)0x0 && + ((((*puVar2 != *param_3 || (puVar2[1] != param_3[1])) || (puVar2[2] != param_3[2])) || + (puVar2[3] != param_3[3])))); puVar2 = (uint *)puVar2[4]) { + } + param_2[1] = (int)puVar1; + *param_2 = param_1; + param_2[2] = (int)puVar2; + return; +} + + + +// --- FUN_004064a0 at 0x004064A0 (size: 63) --- + +void FUN_004064a0(int param_1,int param_2,uint *param_3) + +{ + int iVar1; + int iVar2; + + iVar2 = param_2 - param_1 >> 2; + if (0 < iVar2) { + do { + iVar1 = iVar2 >> 1; + if (*(uint *)(param_1 + iVar1 * 4) < *param_3) { + param_1 = param_1 + 4 + iVar1 * 4; + iVar1 = iVar2 + (-1 - iVar1); + } + iVar2 = iVar1; + } while (0 < iVar1); + } + return; +} + + + +// --- FUN_004064e0 at 0x004064E0 (size: 27) --- + +void FUN_004064e0(int *param_1) + +{ + int iVar1; + + iVar1 = *(int *)(*param_1 + -4); + if (iVar1 != 1) { + FUN_00404ef0(*param_1,iVar1 + -1); + } + return; +} + + + +// --- FUN_00406500 at 0x00406500 (size: 104) --- + +undefined4 FUN_00406500(undefined4 param_1,undefined4 param_2) + +{ + undefined *puVar1; + undefined4 uVar2; + LONG LVar3; + + puVar1 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + uVar2 = FUN_00402390(param_2,&stack0x0000000c); + if (*(int *)(puVar1 + -4) != 1) { + FUN_00404ef0(puVar1,*(int *)(puVar1 + -4) + -1); + } + LVar3 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + return uVar2; +} + + + +// --- FUN_00406570 at 0x00406570 (size: 89) --- + +void FUN_00406570(undefined4 *param_1,undefined4 param_2,int *param_3) + +{ + undefined1 local_c [8]; + int local_4; + + *param_3 = 0; + FUN_00406440(local_c,param_2); + if (local_4 != 0) { + *param_3 = *(int *)(local_4 + 0x14); + } + if ((int *)*param_3 != (int *)0x0) { + (**(code **)(*(int *)*param_3 + 0x10))(); + *param_1 = 0; + return; + } + *param_1 = 0x80040154; + return; +} + + + +// --- FUN_004065d0 at 0x004065D0 (size: 127) --- + +void FUN_004065d0(int *param_1,undefined4 param_2,undefined4 param_3) + +{ + int *piVar1; + undefined1 local_c [4]; + undefined4 *puStack_8; + int local_4; + + FUN_00406440(local_c,param_2); + if ((local_4 != 0) && (*(int **)(local_4 + 0x14) != (int *)0x0)) { + param_2 = 0; + piVar1 = (int *)(**(code **)(**(int **)(local_4 + 0x14) + 0xc))(¶m_3,param_3,¶m_2); + if (-1 < *piVar1) { + *param_1 = local_4; + *puStack_8 = 0; + return; + } + *puStack_8 = 0x80004002; + return; + } + *param_1 = -0x7ffbfeac; + return; +} + + + +// --- FUN_00406650 at 0x00406650 (size: 139) --- + +void FUN_00406650(int *param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4,int *param_5 + ) + +{ + int iVar1; + undefined4 *puVar2; + int *piVar3; + int *piVar4; + undefined4 unaff_EBP; + int *unaff_ESI; + int local_4; + + puVar2 = param_5; + *param_5 = 0; + param_5 = (int *)0x0; + FUN_004065d0(&local_4,param_2,&DAT_007952cc,¶m_5); + piVar3 = param_5; + if (local_4 < 0) { + *param_1 = local_4; + return; + } + param_2 = 0; + piVar4 = (int *)(**(code **)(*param_5 + 0x18))(¶m_5,param_4,param_3,¶m_2); + iVar1 = *piVar4; + if (-1 < iVar1) { + *puVar2 = unaff_EBP; + } + (**(code **)(*piVar3 + 0x14))(); + *unaff_ESI = iVar1; + return; +} + + + +// --- FUN_004066e0 at 0x004066E0 (size: 151) --- + +undefined4 * __thiscall FUN_004066e0(undefined4 *param_1,uint param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + uint local_4; + + local_4 = param_2; + param_2 = param_2 & 0xffffff00; + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_007952dc; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_004064a0(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 * 4); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00406780 at 0x00406780 (size: 82) --- + +void __fastcall FUN_00406780(int param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + uint local_8; + undefined4 local_4; + + puVar1 = PTR_DAT_00818558; + local_4 = *(undefined4 *)(param_1 + 0x68); + local_8 = local_8 & 0xffffff00; + puVar2 = (undefined4 *)FUN_004064a0(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,local_8,0); + if ((puVar2 != (undefined4 *)puVar1) || (puVar2 = puVar2 + -1, puVar2 != (undefined4 *)puVar1)) { + puVar2 = puVar2 + 1; + } + FUN_004067e0(*puVar2); + return; +} + + + +// --- FUN_004067e0 at 0x004067E0 (size: 234) --- + +undefined4 __thiscall FUN_004067e0(int param_1,int param_2) + +{ + int iVar1; + uint *puVar2; + int *piVar3; + undefined4 *puVar4; + uint uVar5; + uint *puVar6; + + if (param_2 == *(int *)(param_1 + 0x68)) { + return 0; + } + iVar1 = *(int *)(param_1 + 0x6c); + puVar2 = (uint *)0x0; + do { + if (iVar1 == 0) { + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_0065ec90(param_2); + while (puVar2 != (uint *)0x0) { + puVar6 = (uint *)puVar2[4]; + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + FUN_00406780(); + } + uVar5 = *puVar2 % *(uint *)(param_1 + 0x68); + iVar1 = *(int *)(param_1 + 0x60); + puVar2[4] = *(uint *)(iVar1 + uVar5 * 4); + *(uint **)(iVar1 + uVar5 * 4) = puVar2; + uVar5 = iVar1 + uVar5 * 4; + if (uVar5 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar5; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + puVar2 = puVar6; + } + return 1; + } + piVar3 = *(int **)(param_1 + 100); + while (piVar3 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + puVar4 = *(undefined4 **)(param_1 + 100); + puVar6 = (uint *)*puVar4; + goto LAB_0040682e; + } + piVar3 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar3; + } + puVar4 = (undefined4 *)0x0; + puVar6 = (uint *)0x0; +LAB_0040682e: + FUN_004069d0(param_1,puVar4,puVar6); + puVar6[4] = (uint)puVar2; + iVar1 = *(int *)(param_1 + 0x6c); + puVar2 = puVar6; + } while( true ); +} + + + +// --- FUN_004068d0 at 0x004068D0 (size: 105) --- + +uint __thiscall FUN_004068d0(int param_1,uint *param_2) + +{ + int iVar1; + uint uVar2; + undefined1 local_c [8]; + int local_4; + + uVar2 = FUN_00406440(local_c,param_2); + if (local_4 != 0) { + return uVar2 & 0xffffff00; + } + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + FUN_00406780(); + } + uVar2 = *param_2 % *(uint *)(param_1 + 0x68); + iVar1 = *(int *)(param_1 + 0x60); + param_2[4] = *(uint *)(iVar1 + uVar2 * 4); + *(uint **)(iVar1 + uVar2 * 4) = param_2; + uVar2 = iVar1 + uVar2 * 4; + if (uVar2 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar2; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + return CONCAT31((int3)(uVar2 >> 8),1); +} + + + +// --- FUN_00406940 at 0x00406940 (size: 144) --- + +undefined4 FUN_00406940(undefined4 *param_1,undefined4 *param_2) + +{ + undefined4 *puVar1; + undefined1 local_c [8]; + int local_4; + + FUN_00406440(local_c,param_1); + if (local_4 != 0) { + *(undefined4 *)(local_4 + 0x14) = *param_2; + return 1; + } + puVar1 = (undefined4 *)FUN_005df0f5(0x18); + if (puVar1 != (undefined4 *)0x0) { + *puVar1 = *param_1; + puVar1[1] = param_1[1]; + puVar1[2] = param_1[2]; + puVar1[3] = param_1[3]; + puVar1[4] = 0; + puVar1[5] = *param_2; + FUN_004068d0(puVar1); + return 1; + } + FUN_004068d0(0); + return 1; +} + + + +// --- FUN_004069d0 at 0x004069D0 (size: 58) --- + +void __thiscall FUN_004069d0(int param_1,undefined4 param_2,int *param_3,int param_4) + +{ + int iVar1; + int iVar2; + + iVar2 = *param_3; + if (iVar2 != param_4) { + do { + iVar1 = iVar2; + iVar2 = *(int *)(iVar1 + 0x10); + } while (iVar2 != param_4); + if (iVar1 != 0) { + *(undefined4 *)(iVar1 + 0x10) = *(undefined4 *)(iVar2 + 0x10); + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + return; + } + } + *param_3 = *(int *)(iVar2 + 0x10); + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + return; +} + + + +// --- FUN_00406a10 at 0x00406A10 (size: 121) --- + +void __fastcall FUN_00406a10(int param_1) + +{ + int iVar1; + void *pvVar2; + void *pvVar3; + void *pvVar4; + int *piVar5; + + iVar1 = *(int *)(param_1 + 0x6c); + do { + if (iVar1 == 0) { + return; + } + piVar5 = *(int **)(param_1 + 100); + while (piVar5 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar5 = *(int **)(param_1 + 100); + pvVar4 = (void *)*piVar5; + goto LAB_00406a4f; + } + piVar5 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar5; + } + piVar5 = (int *)0x0; + pvVar4 = (void *)0x0; +LAB_00406a4f: + pvVar3 = (void *)*piVar5; + if (pvVar3 == pvVar4) { +LAB_00406a62: + *piVar5 = *(int *)((int)pvVar3 + 0x10); + } + else { + do { + pvVar2 = pvVar3; + pvVar3 = *(void **)((int)pvVar2 + 0x10); + } while (pvVar3 != pvVar4); + if (pvVar2 == (void *)0x0) goto LAB_00406a62; + *(undefined4 *)((int)pvVar2 + 0x10) = *(undefined4 *)((int)pvVar3 + 0x10); + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + if (pvVar4 != (void *)0x0) { + operator_delete(pvVar4); + } + iVar1 = *(int *)(param_1 + 0x6c); + } while( true ); +} + + + +// --- FUN_00406a90 at 0x00406A90 (size: 147) --- + +void FUN_00406a90(undefined4 *param_1,undefined4 param_2,int *param_3,undefined4 *param_4) + +{ + int *piVar1; + undefined4 *puVar2; + int *piVar3; + undefined1 local_c [8]; + int local_4; + + piVar1 = param_3; + if (param_3 != (int *)0x0) { + piVar3 = (int *)0x0; + FUN_00406440(local_c,param_2); + puVar2 = param_4; + if (local_4 != 0) { + piVar3 = *(int **)(local_4 + 0x14); + } + if (param_4 != (undefined4 *)0x0) { + if (piVar3 != (int *)0x0) { + (**(code **)(*piVar3 + 0x10))(); + } + *puVar2 = piVar3; + } + if (piVar3 != piVar1) { + if (piVar3 != (int *)0x0) { + (**(code **)(*piVar3 + 0x14))(); + } + (**(code **)(*piVar1 + 0x10))(); + FUN_00406940(param_2,¶m_3); + } + *param_1 = 0; + return; + } + *param_1 = 0x80004005; + return; +} + + + +// --- FUN_00406b30 at 0x00406B30 (size: 85) --- + +int FUN_00406b30(undefined4 param_1) + +{ + undefined4 local_c; + undefined4 local_8; + int local_4; + + FUN_00406440(&local_c,param_1); + if (local_4 != 0) { + FUN_004069d0(local_c,local_8,local_4); + return local_4; + } + return 0; +} + + + +// --- FUN_00406b90 at 0x00406B90 (size: 82) --- + +undefined4 * __thiscall FUN_00406b90(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007952e0; + FUN_00406a10(); + param_1[1] = &PTR_FUN_007952dc; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00406bf0 at 0x00406BF0 (size: 147) --- + +void __fastcall FUN_00406bf0(undefined4 *param_1) + +{ + int iVar1; + int *piVar2; + int iVar3; + int *piVar4; + undefined1 local_c [12]; + + piVar2 = (int *)FUN_004063f0(local_c); + iVar1 = *piVar2; + piVar4 = (int *)piVar2[1]; + iVar3 = piVar2[2]; + while (iVar3 != 0) { + do { + (**(code **)(**(int **)(iVar3 + 0x14) + 0x14))(); + iVar3 = *(int *)(iVar3 + 0x10); + } while (iVar3 != 0); + do { + piVar4 = piVar4 + 1; + if (piVar4 == (int *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) goto LAB_00406c46; + } while (*piVar4 == 0); + iVar3 = *piVar4; + } +LAB_00406c46: + *param_1 = &PTR_FUN_007952e0; + FUN_00406a10(); + param_1[1] = &PTR_FUN_007952dc; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + return; +} + + + +// --- FUN_00406c90 at 0x00406C90 (size: 119) --- + +void FUN_00406c90(undefined4 *param_1,undefined4 param_2,int *param_3,undefined4 *param_4) + +{ + void *pvVar1; + int *piVar2; + undefined1 local_c [8]; + int local_4; + + piVar2 = (int *)0x0; + FUN_00406440(local_c,param_2); + if (local_4 != 0) { + piVar2 = *(int **)(local_4 + 0x14); + } + if (param_4 != (undefined4 *)0x0) { + *param_4 = piVar2; + (**(code **)(*piVar2 + 0x10))(); + } + if ((param_3 == (int *)0x0) || (piVar2 == param_3)) { + pvVar1 = (void *)FUN_00406b30(param_2); + if (pvVar1 != (void *)0x0) { + operator_delete(pvVar1); + } + if (piVar2 != (int *)0x0) { + (**(code **)(*piVar2 + 0x14))(); + } + } + *param_1 = 0; + return; +} + + + +// --- FUN_00406d10 at 0x00406D10 (size: 78) --- + +undefined4 * FUN_00406d10(void) + +{ + undefined4 *puVar1; + + if (DAT_00837744 != '\0') { + return (undefined4 *)0x0; + } + if (DAT_00837740 == (undefined4 *)0x0) { + puVar1 = (undefined4 *)FUN_005df0f5(0x74); + if (puVar1 != (undefined4 *)0x0) { + *puVar1 = &PTR_FUN_007952e0; + FUN_004066e0(0); + *puVar1 = &PTR_FUN_007952e0; + DAT_00837740 = puVar1; + return puVar1; + } + DAT_00837740 = (undefined4 *)0x0; + } + return DAT_00837740; +} + + + +// --- FUN_00406d60 at 0x00406D60 (size: 13) --- + +void __fastcall FUN_00406d60(undefined4 *param_1) + +{ + *param_1 = 0; + param_1[1] = 0; + param_1[2] = 0; + return; +} + + + +// --- FUN_00406d70 at 0x00406D70 (size: 14) --- + +undefined4 __fastcall FUN_00406d70(int param_1) + +{ + int iVar1; + + iVar1 = *(int *)(param_1 + 8); + if (iVar1 != 0) { + return CONCAT31((int3)((uint)iVar1 >> 8),*(undefined1 *)(iVar1 + 0x11)); + } + return 1; +} + + + +// --- FUN_00406d80 at 0x00406D80 (size: 16) --- + +int __fastcall FUN_00406d80(int *param_1) + +{ + if (param_1[2] != 0) { + return *(int *)(param_1[2] + 8) + *param_1; + } + return 0; +} + + + +// --- FUN_00406d90 at 0x00406D90 (size: 22) --- + +undefined4 __fastcall FUN_00406d90(int param_1) + +{ + int iVar1; + + iVar1 = *(int *)(param_1 + 8); + if (iVar1 != 0) { + *(undefined1 *)(iVar1 + 0x10) = 0; + *(undefined1 *)(iVar1 + 0x11) = 0; + return *(undefined4 *)(iVar1 + 8); + } + return 0; +} + + + +// --- FUN_00406db0 at 0x00406DB0 (size: 4) --- + +undefined4 __fastcall FUN_00406db0(int param_1) + +{ + return *(undefined4 *)(param_1 + 4); +} + + + +// --- FUN_00406dc0 at 0x00406DC0 (size: 14) --- + +undefined4 __fastcall FUN_00406dc0(int param_1) + +{ + if (*(int *)(param_1 + 8) != 0) { + return *(undefined4 *)(*(int *)(param_1 + 8) + 4); + } + return 0; +} + + + +// --- FUN_00406dd0 at 0x00406DD0 (size: 73) --- + +void __fastcall FUN_00406dd0(LONG *param_1) + +{ + int iVar1; + uint uVar2; + + uVar2 = 0; + iVar1 = InterlockedExchange(param_1,1); + while (iVar1 != 0) { + iVar1 = *param_1; + while (iVar1 != 0) { + uVar2 = uVar2 + 1; + if (0xfffff < uVar2) { + Sleep(0); + uVar2 = 0; + } + iVar1 = *param_1; + } + iVar1 = InterlockedExchange(param_1,1); + } + return; +} + + + +// --- FUN_00406e20 at 0x00406E20 (size: 96) --- + +uint FUN_00406e20(uint param_1) + +{ + int iVar1; + uint uVar2; + uint uVar3; + + if (0x40000 < param_1) { + return (param_1 + 0x3ffff) - (param_1 + 0x3ffff & 0x3ffff); + } + if (param_1 < 0x10) { + return 0x10; + } + iVar1 = 0x1f; + if (param_1 != 0) { + for (; param_1 >> iVar1 == 0; iVar1 = iVar1 + -1) { + } + } + uVar3 = 1 << ((byte)iVar1 & 0x1f); + uVar2 = uVar3; + if (0x1800 < uVar3) { + uVar2 = uVar3 + 0xc00; + } + if (uVar2 < param_1) { + uVar2 = uVar2 + uVar3; + } + return uVar2; +} + + + +// --- FUN_00406e80 at 0x00406E80 (size: 219) --- + +void __fastcall FUN_00406e80(int param_1) + +{ + int iVar1; + undefined4 uVar2; + uint uVar3; + uint uVar4; + uint uVar5; + + if (*(char *)(param_1 + 0x10) != '\0') { + if (*(char *)(param_1 + 0x12) != '\0') { + if (((*(uint *)(param_1 + 0xc) != 0) && (*(uint *)(param_1 + 0xc) < 0x200000)) && + (DAT_00837798 != (LONG *)0x0)) { + FUN_00406dd0(); + uVar3 = 0; + uVar4 = DAT_0083775c; + uVar5 = DAT_0083779c; + if (DAT_0083779c < 8) { + (&DAT_00837758)[DAT_0083779c * 2] = 0; + DAT_0083779c = DAT_0083779c + 1; + } + else { + while (1 < uVar5) { + iVar1 = uVar5 * 8; + uVar5 = uVar5 - 1; + if (*(uint *)(&DAT_00837754 + iVar1) < uVar4) { + uVar3 = uVar5; + uVar4 = *(uint *)(&DAT_00837754 + iVar1); + } + } + uVar5 = 0xffffffff; + if (uVar4 < *(uint *)(param_1 + 0xc)) { + uVar5 = uVar3; + } + } + if (uVar5 < DAT_0083779c) { + uVar2 = *(undefined4 *)(param_1 + 8); + *(undefined4 *)(param_1 + 8) = (&DAT_00837758)[uVar5 * 2]; + (&DAT_00837758)[uVar5 * 2] = uVar2; + (&DAT_0083775c)[uVar5 * 2] = *(undefined4 *)(param_1 + 0xc); + } + InterlockedExchange(DAT_00837798,0); + } + } + operator_delete__(*(void **)(param_1 + 8)); + } + *(undefined4 *)(param_1 + 8) = 0; + *(undefined4 *)(param_1 + 0xc) = 0; + return; +} + + + +// --- FUN_00406f60 at 0x00406F60 (size: 43) --- + +undefined4 * __thiscall FUN_00406f60(undefined4 *param_1,undefined4 *param_2) + +{ + int iVar1; + + *param_1 = *param_2; + param_1[1] = param_2[1]; + iVar1 = param_2[2]; + param_1[2] = iVar1; + if (iVar1 != 0) { + InterlockedIncrement((LONG *)(iVar1 + 4)); + } + return param_1; +} + + + +// --- FUN_00406f90 at 0x00406F90 (size: 60) --- + +void __fastcall FUN_00406f90(undefined4 *param_1) + +{ + undefined4 *puVar1; + LONG LVar2; + + puVar1 = (undefined4 *)param_1[2]; + if (puVar1 != (undefined4 *)0x0) { + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + param_1[2] = 0; + } + *param_1 = 0; + param_1[1] = 0; + return; +} + + + +// --- FUN_00406fd0 at 0x00406FD0 (size: 42) --- + +undefined4 * __thiscall FUN_00406fd0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007952f8; + FUN_00406e80(); + *param_1 = &PTR_FUN_007952f4; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00407000 at 0x00407000 (size: 76) --- + +void FUN_00407000(void) + +{ + int iVar1; + + if (DAT_00837798 != (void *)0x0) { + operator_delete(DAT_00837798); + } + DAT_00837798 = (void *)0x0; + for (iVar1 = DAT_0083779c; iVar1 != 0; iVar1 = iVar1 + -1) { + operator_delete__((void *)(&DAT_00837750)[iVar1 * 2]); + } + DAT_0083779c = 0; + return; +} + + + +// --- FUN_00407060 at 0x00407060 (size: 101) --- + +undefined4 * __thiscall FUN_00407060(undefined4 *param_1,undefined4 param_2,undefined4 param_3) + +{ + undefined4 *puVar1; + + *param_1 = 0; + param_1[1] = param_3; + puVar1 = (undefined4 *)FUN_005df0f5(0x14); + if (puVar1 == (undefined4 *)0x0) { + puVar1 = (undefined4 *)0x0; + } + else { + puVar1[1] = 1; + *puVar1 = &PTR_FUN_007952f8; + puVar1[2] = 0; + puVar1[3] = 0; + *(undefined1 *)(puVar1 + 4) = 1; + *(undefined1 *)((int)puVar1 + 0x11) = 1; + *(undefined1 *)((int)puVar1 + 0x12) = 0; + } + param_1[2] = puVar1; + FUN_00406e80(); + puVar1[2] = param_2; + puVar1[3] = param_3; + *(undefined1 *)(puVar1 + 4) = 0; + *(undefined1 *)((int)puVar1 + 0x11) = 0; + return param_1; +} + + + +// --- FUN_004070d0 at 0x004070D0 (size: 104) --- + +undefined4 * __thiscall FUN_004070d0(undefined4 *param_1,undefined4 *param_2) + +{ + undefined4 *puVar1; + int iVar2; + LONG LVar3; + + if (param_2 != param_1) { + puVar1 = (undefined4 *)param_1[2]; + if (puVar1 != (undefined4 *)0x0) { + LVar3 = InterlockedDecrement(puVar1 + 1); + if ((LVar3 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + param_1[2] = 0; + } + *param_1 = 0; + param_1[1] = 0; + iVar2 = param_2[2]; + param_1[2] = iVar2; + if (iVar2 != 0) { + InterlockedIncrement((LONG *)(iVar2 + 4)); + } + *param_1 = *param_2; + param_1[1] = param_2[1]; + } + return param_1; +} + + + +// --- FUN_00407140 at 0x00407140 (size: 151) --- + +int * __thiscall FUN_00407140(int *param_1,int *param_2,int param_3,int param_4) + +{ + undefined4 *puVar1; + LONG LVar2; + + if (param_1[2] == 0) { + puVar1 = (undefined4 *)FUN_005df0f5(0x14); + if (puVar1 == (undefined4 *)0x0) { + puVar1 = (undefined4 *)0x0; + } + else { + puVar1[1] = 1; + *puVar1 = &PTR_FUN_007952f8; + puVar1[2] = 0; + puVar1[3] = 0; + *(undefined1 *)(puVar1 + 4) = 1; + *(undefined1 *)((int)puVar1 + 0x11) = 1; + *(undefined1 *)((int)puVar1 + 0x12) = 0; + } + param_1[2] = (int)puVar1; + } + puVar1 = (undefined4 *)param_1[2]; + if (puVar1 != (undefined4 *)0x0) { + InterlockedIncrement(puVar1 + 1); + } + *param_2 = *param_1 + param_3; + param_2[1] = param_4; + param_2[2] = (int)puVar1; + if (puVar1 != (undefined4 *)0x0) { + InterlockedIncrement(puVar1 + 1); + LVar2 = InterlockedDecrement(puVar1 + 1); + if (LVar2 == 0) { + (**(code **)*puVar1)(1); + } + } + return param_2; +} + + + +// --- FUN_004071e0 at 0x004071E0 (size: 106) --- + +void __fastcall FUN_004071e0(undefined4 *param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)param_1[2]; + if (puVar2 != (undefined4 *)0x0) { + LVar1 = InterlockedDecrement(puVar2 + 1); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + param_1[2] = 0; + } + *param_1 = 0; + param_1[1] = 0; + puVar2 = (undefined4 *)FUN_005df0f5(0x14); + if (puVar2 != (undefined4 *)0x0) { + puVar2[2] = 0; + puVar2[3] = 0; + *(undefined1 *)((int)puVar2 + 0x12) = 0; + puVar2[1] = 1; + *puVar2 = &PTR_FUN_007952f8; + *(undefined1 *)(puVar2 + 4) = 1; + *(undefined1 *)((int)puVar2 + 0x11) = 1; + param_1[2] = puVar2; + return; + } + param_1[2] = 0; + return; +} + + + +// --- FUN_00407250 at 0x00407250 (size: 308) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __thiscall FUN_00407250(int param_1,uint param_2) + +{ + int iVar1; + int iVar2; + uint uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + undefined4 *puVar7; + undefined4 *puVar8; + + if ((_DAT_008377a0 & 1) == 0) { + _DAT_008377a0 = _DAT_008377a0 | 1; + DAT_00837798 = (LONG *)FUN_005df0f5(0xc); + if (DAT_00837798 == (LONG *)0x0) { + DAT_00837798 = (LONG *)0x0; + _atexit((_func_4879 *)&LAB_00726b50); + } + else { + *DAT_00837798 = 0; + DAT_00837798[1] = 0; + DAT_00837798[2] = 0; + _atexit((_func_4879 *)&LAB_00726b50); + } + } + if (param_2 <= *(uint *)(param_1 + 0xc)) { + return; + } + puVar6 = (undefined4 *)0x0; + if (((*(char *)(param_1 + 0x12) != '\0') && (DAT_0083779c != 0)) && (DAT_00837798 != (LONG *)0x0)) + { + FUN_00406dd0(); + iVar2 = DAT_0083779c; + if (DAT_0083779c != 0) { + do { + if (iVar2 == 0) goto LAB_00407333; + iVar2 = iVar2 + -1; + } while ((uint)(&DAT_0083775c)[iVar2 * 2] < param_2); + param_2 = (&DAT_0083775c)[iVar2 * 2]; + puVar6 = (undefined4 *)(&DAT_00837758)[iVar2 * 2]; + iVar1 = DAT_0083779c * 2; + iVar5 = DAT_0083779c + -1; + DAT_0083779c = iVar5; + (&DAT_00837758)[iVar2 * 2] = (&DAT_00837750)[iVar1]; + (&DAT_0083775c)[iVar2 * 2] = (&DAT_0083775c)[iVar5 * 2]; + } +LAB_00407333: + InterlockedExchange(DAT_00837798,0); + if (puVar6 != (undefined4 *)0x0) goto LAB_0040734f; + } + puVar6 = (undefined4 *)thunk_FUN_005df0f5(param_2); +LAB_0040734f: + uVar4 = *(uint *)(param_1 + 0xc); + if (uVar4 != 0) { + puVar7 = *(undefined4 **)(param_1 + 8); + puVar8 = puVar6; + for (uVar3 = uVar4 >> 2; uVar3 != 0; uVar3 = uVar3 - 1) { + *puVar8 = *puVar7; + puVar7 = puVar7 + 1; + puVar8 = puVar8 + 1; + } + for (uVar4 = uVar4 & 3; uVar4 != 0; uVar4 = uVar4 - 1) { + *(undefined1 *)puVar8 = *(undefined1 *)puVar7; + puVar7 = (undefined4 *)((int)puVar7 + 1); + puVar8 = (undefined4 *)((int)puVar8 + 1); + } + FUN_00406e80(); + } + *(undefined4 **)(param_1 + 8) = puVar6; + *(uint *)(param_1 + 0xc) = param_2; + return; +} + + + +// --- FUN_00407390 at 0x00407390 (size: 28) --- + +undefined4 __thiscall FUN_00407390(int param_1,undefined4 param_2,int param_3) + +{ + FUN_00407140(param_2,param_3,*(int *)(param_1 + 4) - param_3); + return param_2; +} + + + +// --- FUN_004073b0 at 0x004073B0 (size: 49) --- + +void __thiscall FUN_004073b0(int param_1,undefined4 param_2,undefined4 param_3) + +{ + int iVar1; + + FUN_004071e0(); + iVar1 = *(int *)(param_1 + 8); + FUN_00406e80(); + *(undefined4 *)(iVar1 + 8) = param_2; + *(undefined4 *)(iVar1 + 0xc) = param_3; + *(undefined1 *)(iVar1 + 0x10) = 0; + *(undefined1 *)(iVar1 + 0x11) = 0; + *(undefined4 *)(param_1 + 4) = param_3; + return; +} + + + +// --- FUN_004073f0 at 0x004073F0 (size: 181) --- + +undefined4 * __thiscall FUN_004073f0(int *param_1,undefined4 *param_2) + +{ + int iVar1; + LONG LVar2; + uint uVar3; + uint uVar4; + undefined4 *puVar5; + undefined4 *puVar6; + undefined4 *puVar7; + + puVar7 = (undefined4 *)0x0; + iVar1 = 0; + puVar5 = (undefined4 *)0x0; + if (param_1[2] != 0) { + puVar5 = (undefined4 *)FUN_005df0f5(0x14); + if (puVar5 == (undefined4 *)0x0) { + puVar5 = (undefined4 *)0x0; + } + else { + puVar5[1] = 1; + *puVar5 = &PTR_FUN_007952f8; + puVar5[2] = 0; + puVar5[3] = 0; + *(undefined1 *)(puVar5 + 4) = 1; + *(undefined1 *)((int)puVar5 + 0x11) = 1; + *(undefined1 *)((int)puVar5 + 0x12) = 0; + } + FUN_00407250(param_1[1]); + if (param_1[2] == 0) { + puVar6 = (undefined4 *)0x0; + } + else { + puVar6 = (undefined4 *)(*(int *)(param_1[2] + 8) + *param_1); + } + if (puVar5 != (undefined4 *)0x0) { + puVar7 = (undefined4 *)puVar5[2]; + } + uVar4 = param_1[1]; + for (uVar3 = uVar4 >> 2; uVar3 != 0; uVar3 = uVar3 - 1) { + *puVar7 = *puVar6; + puVar6 = puVar6 + 1; + puVar7 = puVar7 + 1; + } + for (uVar4 = uVar4 & 3; uVar4 != 0; uVar4 = uVar4 - 1) { + *(undefined1 *)puVar7 = *(undefined1 *)puVar6; + puVar6 = (undefined4 *)((int)puVar6 + 1); + puVar7 = (undefined4 *)((int)puVar7 + 1); + } + iVar1 = param_1[1]; + } + *param_2 = 0; + param_2[1] = iVar1; + param_2[2] = puVar5; + if (puVar5 != (undefined4 *)0x0) { + InterlockedIncrement(puVar5 + 1); + LVar2 = InterlockedDecrement(puVar5 + 1); + if (LVar2 == 0) { + (**(code **)*puVar5)(1); + } + } + return param_2; +} + + + +// --- FUN_004074b0 at 0x004074B0 (size: 160) --- + +void __thiscall FUN_004074b0(int *param_1,uint param_2,byte param_3) + +{ + undefined4 *puVar1; + int iVar2; + + if ((param_3 & 8) != 0) { + *(undefined1 *)(param_1[2] + 0x12) = 1; + } + if ((uint)param_1[1] < param_2) { + if (param_1[2] == 0) { + puVar1 = (undefined4 *)FUN_005df0f5(0x14); + if (puVar1 == (undefined4 *)0x0) { + puVar1 = (undefined4 *)0x0; + } + else { + puVar1[1] = 1; + *puVar1 = &PTR_FUN_007952f8; + puVar1[2] = 0; + puVar1[3] = 0; + *(undefined1 *)(puVar1 + 4) = 1; + *(undefined1 *)((int)puVar1 + 0x11) = 1; + *(undefined1 *)((int)puVar1 + 0x12) = 0; + } + param_1[2] = (int)puVar1; + } + if ((param_3 & 1) == 0) { + iVar2 = *param_1 + param_2; + } + else { + iVar2 = FUN_00406e20(*param_1 + param_2); + } + FUN_00407250(iVar2); + param_1[1] = param_2; + } + if ((param_3 & 4) != 0) { + *(undefined1 *)(param_1[2] + 0x11) = 0; + } + if ((param_3 & 2) != 0) { + param_1[1] = param_2; + } + return; +} + + + +// --- FUN_00407550 at 0x00407550 (size: 87) --- + +void FUN_00407550(char *param_1,undefined4 param_2) + +{ + undefined *puVar1; + + if ((param_1 != (char *)0x0) && (*param_1 != '\0')) { + switch(param_2) { + default: + fputs(param_1,(FILE *)(_iob_exref + 0x20)); + return; + case 1: + puVar1 = &DAT_00795314; + break; + case 2: + case 3: + puVar1 = &DAT_0079530c; + } + FUN_004102a0("%s%s%s",puVar1,param_1,&DAT_00795304); + return; + } + return; +} + + + +// --- FUN_004075c0 at 0x004075C0 (size: 26) --- + +int __thiscall FUN_004075c0(int *param_1,uint param_2) + +{ + int iVar1; + + iVar1 = *param_1; + if (*(uint *)(iVar1 + -4) <= param_2) { + return iVar1 + -2 + *(uint *)(iVar1 + -4) * 2; + } + return iVar1 + param_2 * 2; +} + + + +// --- FUN_00407680 at 0x00407680 (size: 74) --- + +uint __fastcall FUN_00407680(undefined4 *param_1) + +{ + wint_t *pwVar1; + wint_t wVar2; + uint uVar3; + wint_t *pwVar4; + + pwVar4 = (wint_t *)*param_1; + uVar3 = 0; + wVar2 = *pwVar4; + while (wVar2 != 0) { + wVar2 = towlower(wVar2); + uVar3 = uVar3 * 0x10 + (uint)wVar2; + if ((uVar3 & 0xf0000000) != 0) { + uVar3 = ((uVar3 & 0xf0000000) >> 0x18 ^ uVar3) & 0xfffffff; + } + pwVar1 = pwVar4 + 1; + pwVar4 = pwVar4 + 1; + wVar2 = *pwVar1; + } + return uVar3; +} + + + +// --- FUN_004076d0 at 0x004076D0 (size: 64) --- + +undefined4 * __thiscall FUN_004076d0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795324; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00407710 at 0x00407710 (size: 64) --- + +undefined4 * __thiscall FUN_00407710(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795328; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00407750 at 0x00407750 (size: 151) --- + +undefined4 * __thiscall FUN_00407750(undefined4 *param_1,undefined4 *param_2) + +{ + int iVar1; + LONG LVar2; + + *param_1 = *param_2; + *(undefined1 *)(param_1 + 1) = *(undefined1 *)(param_2 + 1); + iVar1 = param_1[2]; + if (iVar1 != param_2[2]) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = param_2[2]; + param_1[2] = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + iVar1 = param_1[3]; + if (iVar1 != param_2[3]) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = param_2[3]; + param_1[3] = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + param_1[4] = param_2[4]; + param_1[5] = param_2[5]; + param_1[6] = param_2[6]; + return param_1; +} + + + +// --- FUN_004077f0 at 0x004077F0 (size: 85) --- + +uint FUN_004077f0(uint param_1) + +{ + int iVar1; + uint uVar2; + uint uVar3; + + if (param_1 < 9) { + return 8; + } + if (0x4000 < param_1) { + if ((param_1 & 0x3fff) != 0) { + param_1 = param_1 + (0x4000 - (param_1 & 0x3fff)); + } + return param_1; + } + iVar1 = 0x1f; + if (param_1 != 0) { + for (; param_1 >> iVar1 == 0; iVar1 = iVar1 + -1) { + } + } + uVar3 = 1 << ((byte)iVar1 & 0x1f); + uVar2 = uVar3 * 2; + if (param_1 <= uVar3) { + uVar2 = param_1; + } + return uVar2; +} + + + +// --- FUN_00407850 at 0x00407850 (size: 205) --- + +void __fastcall FUN_00407850(int *param_1) + +{ + int *piVar1; + undefined *puVar2; + undefined *puVar3; + uint uVar4; + LONG LVar5; + undefined4 *puVar6; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) != 0x80000000) { + if (*param_1 != 0) { + uVar4 = param_1[1] & 0x7fffffff; + puVar3 = PTR_DAT_00818340; + while (uVar4 = uVar4 - 1, PTR_DAT_00818340 = puVar3, -1 < (int)uVar4) { + InterlockedIncrement((LONG *)(puVar3 + -0x10)); + piVar1 = (int *)(*param_1 + uVar4 * 4); + puVar2 = (undefined *)*piVar1; + if (puVar2 != puVar3) { + LVar5 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + *piVar1 = (int)puVar3; + InterlockedIncrement((LONG *)(puVar3 + -0x10)); + } + puVar6 = (undefined4 *)(puVar3 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + puVar3 = PTR_DAT_00818340; + if ((LVar5 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + puVar3 = PTR_DAT_00818340; + } + } + } + return; + } + if (*param_1 != 0) { + FUN_00407920(3); + } + *param_1 = 0; + param_1[1] = 0; + return; +} + + + +// --- FUN_00407920 at 0x00407920 (size: 167) --- + +int * __thiscall FUN_00407920(int *param_1,byte param_2) + +{ + int *piVar1; + LONG LVar2; + undefined4 *puVar3; + int *piVar4; + int local_4; + + if ((param_2 & 2) == 0) { + puVar3 = (undefined4 *)(*param_1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(*param_1 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; + } + local_4 = param_1[-1]; + piVar4 = param_1 + local_4; + if (-1 < local_4 + -1) { + do { + piVar1 = piVar4 + -1; + piVar4 = piVar4 + -1; + puVar3 = (undefined4 *)(*piVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(*piVar1 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + local_4 = local_4 + -1; + } while (local_4 != 0); + } + if ((param_2 & 1) != 0) { + operator_delete__(param_1 + -1); + } + return param_1 + -1; +} + + + +// --- FUN_004079d0 at 0x004079D0 (size: 89) --- + +void __fastcall FUN_004079d0(int *param_1) + +{ + int iVar1; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + *param_1 = 0; + param_1[1] = 0; + return; + } + if (*param_1 != 0) { + iVar1 = (param_1[1] & 0x7fffffffU) - 1; + while (-1 < iVar1) { + iVar1 = iVar1 + -1; + *(undefined4 *)(*param_1 + 4 + iVar1 * 4) = 0; + } + } + return; +} + + + +// --- FUN_00407a40 at 0x00407A40 (size: 205) --- + +void __fastcall FUN_00407a40(int *param_1) + +{ + int *piVar1; + undefined *puVar2; + undefined *puVar3; + uint uVar4; + LONG LVar5; + undefined4 *puVar6; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) != 0x80000000) { + if (*param_1 != 0) { + uVar4 = param_1[1] & 0x7fffffff; + puVar3 = PTR_DAT_00818344; + while (uVar4 = uVar4 - 1, PTR_DAT_00818344 = puVar3, -1 < (int)uVar4) { + InterlockedIncrement((LONG *)(puVar3 + -0x10)); + piVar1 = (int *)(*param_1 + uVar4 * 4); + puVar2 = (undefined *)*piVar1; + if (puVar2 != puVar3) { + LVar5 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + *piVar1 = (int)puVar3; + InterlockedIncrement((LONG *)(puVar3 + -0x10)); + } + puVar6 = (undefined4 *)(puVar3 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + puVar3 = PTR_DAT_00818344; + if ((LVar5 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + puVar3 = PTR_DAT_00818344; + } + } + } + return; + } + if (*param_1 != 0) { + FUN_00407920(3); + } + *param_1 = 0; + param_1[1] = 0; + return; +} + + + +// --- FUN_00407b10 at 0x00407B10 (size: 54) --- + +undefined4 * __fastcall FUN_00407b10(undefined4 *param_1) + +{ + LONG *pLVar1; + + *param_1 = 0; + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[2] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[3] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + return param_1; +} + + + +// --- FUN_00407b50 at 0x00407B50 (size: 475) --- + +void __thiscall FUN_00407b50(int *param_1,int param_2,int param_3,int param_4) + +{ + int iVar1; + uint uVar2; + undefined1 *puVar3; + undefined4 uVar4; + LONG LVar5; + uint uVar6; + uint uVar7; + undefined4 *puVar8; + uint uStack_148; + int iStack_144; + undefined1 *puStack_140; + undefined4 uStack_13c; + char *_Format; + char cVar9; + undefined1 auStack_114 [7]; + undefined1 local_10d; + char local_108 [260]; + + if (*(int *)(param_1[2] + -4) == 1) { + local_10d = 0x20; + } + else { + puVar3 = (undefined1 *)param_1[2]; + if (*(int *)(puVar3 + -4) == 0) { + puVar3 = puVar3 + -1; + } + local_10d = *puVar3; + } + if (*(int *)(param_2 + -4) == 1) { + sprintf(local_108," "); + } + else { + sprintf(local_108,"%c%s"); + } + cVar9 = (char)((uint)local_108 >> 0x18); + (**(code **)(*param_1 + 0x28))(); + if ((*(int *)(param_2 + -4) == 1) || (*(int *)(param_3 + -4) == 1)) { + _Format = " "; + } + else { + _Format = ", "; + } + uStack_13c = 0x407c02; + sprintf(&stack0xfffffee8,_Format); + uStack_13c = 0x16; + puStack_140 = &stack0xfffffee8; + iStack_144 = 0x407c16; + uVar2 = (**(code **)(*param_1 + 0x28))(); + if (*(int *)(param_3 + -4) != 1) { + uStack_148 = (uint)cVar9; + iStack_144 = param_3; + sprintf(&stack0xfffffed8,"%c%c%s",uStack_148); + iStack_144 = 3; + uStack_148 = uVar2; + uVar2 = (**(code **)(*param_1 + 0x28))(&stack0xfffffed8,0x16); + } + puVar3 = &stack0xfffffed8; + if (uVar2 < 0x14) { + iVar1 = -uVar2; + uVar6 = iVar1 + 0x14; + puVar8 = (undefined4 *)&stack0xfffffed8; + for (uVar7 = uVar6 >> 2; uVar7 != 0; uVar7 = uVar7 - 1) { + *puVar8 = 0x20202020; + puVar8 = puVar8 + 1; + } + for (uVar7 = uVar6 & 3; uVar7 != 0; uVar7 = uVar7 - 1) { + *(undefined1 *)puVar8 = 0x20; + puVar8 = (undefined4 *)((int)puVar8 + 1); + } + uVar2 = uVar2 + uVar6; + puVar3 = auStack_114 + iVar1; + } + iStack_144 = 0; + *puVar3 = 0x3a; + puVar3[1] = 0x20; + puVar3[2] = 0; + uStack_148 = uVar2; + uVar4 = (**(code **)(*param_1 + 0x28))(&stack0xfffffed8,0x16); + (**(code **)(*param_1 + 0x28))(param_4,0x16,uVar4,4); + uStack_148 = CONCAT22(uStack_148._2_2_,10); + (**(code **)(*param_1 + 0x24))(&uStack_148,0); + LVar5 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(param_2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_2 + -0x14))(1); + } + LVar5 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(param_3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_3 + -0x14))(1); + } + LVar5 = InterlockedDecrement((LONG *)(param_4 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(param_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_4 + -0x14))(1); + } + return; +} + + + +// --- FUN_00407d30 at 0x00407D30 (size: 71) --- + +void __thiscall FUN_00407d30(int param_1,int *param_2) + +{ + int iVar1; + LONG LVar2; + + iVar1 = *(int *)(param_1 + 4); + if (iVar1 != *param_2) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *param_2; + *(int *)(param_1 + 4) = iVar1; + /* WARNING: Could not recover jumptable at 0x00407d6c. Too many branches */ + /* WARNING: Treating indirect jump as call */ + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + return; + } + return; +} + + + +// --- FUN_00407d80 at 0x00407D80 (size: 185) --- + +void * __thiscall FUN_00407d80(void *param_1,byte param_2) + +{ + int *piVar1; + LONG LVar2; + int iVar3; + undefined4 *puVar4; + int *piVar5; + + if ((param_2 & 2) == 0) { + FUN_00402280(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; + } + iVar3 = *(int *)((int)param_1 + -4); + if (-1 < iVar3 + -1) { + piVar5 = (int *)((int)param_1 + iVar3 * 0x1c + 8); + do { + piVar1 = piVar5 + -6; + piVar5 = piVar5 + -7; + puVar4 = (undefined4 *)(*piVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(*piVar1 + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + puVar4 = (undefined4 *)(*piVar5 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(*piVar5 + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + iVar3 = iVar3 + -1; + } while (iVar3 != 0); + } + if ((param_2 & 1) != 0) { + operator_delete__((void *)((int)param_1 + -4)); + } + return (void *)((int)param_1 + -4); +} + + + +// --- FUN_00407e40 at 0x00407E40 (size: 198) --- + +void __thiscall FUN_00407e40(uint *param_1,wchar_t *param_2) + +{ + uint uVar1; + undefined *puVar2; + size_t sVar3; + LONG LVar4; + + if ((param_2 == (wchar_t *)0x0) || (*param_2 == L'\0')) { + uVar1 = *param_1; + if ((undefined *)(-(uint)(uVar1 != 0x14) & uVar1) != PTR_DAT_00818340) { + LVar4 = InterlockedDecrement((LONG *)(uVar1 - 0x10)); + if ((LVar4 == 0) && ((undefined4 *)(uVar1 - 0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(uVar1 - 0x14))(1); + } + puVar2 = PTR_DAT_00818340; + *param_1 = (uint)PTR_DAT_00818340; + /* WARNING: Could not recover jumptable at 0x00407f00. Too many branches */ + /* WARNING: Treating indirect jump as call */ + InterlockedIncrement((LONG *)(puVar2 + -0x10)); + return; + } + } + else { + sVar3 = wcslen(param_2); + uVar1 = *param_1; + if ((*(int *)(uVar1 - 0x10) == 1) && (sVar3 < *(uint *)(uVar1 - 0xc))) { + *(undefined4 *)(uVar1 - 8) = 0xffffffff; + *(size_t *)(*param_1 - 4) = sVar3 + 1; + } + else { + LVar4 = InterlockedDecrement((LONG *)(uVar1 - 0x10)); + if ((LVar4 == 0) && ((undefined4 *)(uVar1 - 0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(uVar1 - 0x14))(1); + } + FUN_004022d0(sVar3); + } + wcsncpy((wchar_t *)*param_1,param_2,sVar3 + 1); + } + return; +} + + + +// --- FUN_00407f10 at 0x00407F10 (size: 193) --- + +undefined4 __thiscall FUN_00407f10(int *param_1,uint param_2) + +{ + uint *puVar1; + int iVar2; + uint *puVar3; + + if (param_2 < (uint)param_1[2]) { + return 0; + } + if ((param_1[1] & 0x7fffffffU) < param_2) { + if (param_2 != 0) { + puVar3 = (uint *)thunk_FUN_005df0f5(param_2 * 4 + 4); + if (puVar3 != (uint *)0x0) { + puVar1 = puVar3 + 1; + *puVar3 = param_2; + FUN_00401000(puVar1,4,param_2,FUN_00401a60); + if (puVar1 != (uint *)0x0) { + if (*param_1 != 0) { + iVar2 = param_1[2]; + while (iVar2 = iVar2 + -1, -1 < iVar2) { + FUN_00402070(*param_1 + iVar2 * 4); + } + if (((param_1[1] & 0x80000000U) == 0x80000000) && (*param_1 != 0)) { + FUN_00407920(3); + } + } + *param_1 = (int)puVar1; + param_1[1] = param_2 | 0x80000000; + return 1; + } + } + return 0; + } + FUN_00407850(); + } + return 1; +} + + + +// --- FUN_00407fe0 at 0x00407FE0 (size: 219) --- + +undefined1 __thiscall FUN_00407fe0(int *param_1,uint param_2,char param_3) + +{ + LONG *lpAddend; + int iVar1; + undefined *puVar2; + undefined *puVar3; + char cVar4; + uint uVar5; + LONG LVar6; + + if ((param_1[1] & 0x7fffffffU) < param_2) { + uVar5 = param_2; + if (param_3 == '\0') { + uVar5 = FUN_004077f0(param_2); + } + cVar4 = FUN_00407f10(uVar5); + if (cVar4 == '\0') { + return 0; + } + } + else { + _param_3 = param_2; + if (param_2 < (uint)param_1[2]) { + do { + puVar3 = PTR_DAT_00818340; + lpAddend = (LONG *)(PTR_DAT_00818340 + -0x10); + InterlockedIncrement(lpAddend); + iVar1 = *param_1; + puVar2 = *(undefined **)(iVar1 + _param_3 * 4); + if (puVar2 != puVar3) { + LVar6 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + *(undefined **)(iVar1 + _param_3 * 4) = puVar3; + InterlockedIncrement(lpAddend); + } + LVar6 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar3 + -0x14))(1); + } + _param_3 = _param_3 + 1; + } while (_param_3 < (uint)param_1[2]); + } + } + param_1[2] = param_2; + return 1; +} + + + +// --- FUN_004080c0 at 0x004080C0 (size: 91) --- + +void __fastcall FUN_004080c0(undefined4 *param_1) + +{ + undefined4 *puVar1; + LONG LVar2; + uint uVar3; + uint uVar4; + undefined4 *puVar5; + undefined4 *puVar6; + + puVar1 = (undefined4 *)*param_1; + if (puVar1[-4] == 1) { + puVar1[-2] = 0xffffffff; + return; + } + FUN_00401280(puVar1[-1] + -1); + uVar4 = ((undefined4 *)*param_1)[-1]; + puVar6 = (undefined4 *)*param_1; + puVar5 = puVar1; + for (uVar3 = uVar4 >> 2; uVar3 != 0; uVar3 = uVar3 - 1) { + *puVar6 = *puVar5; + puVar6 = puVar6 + 1; + puVar5 = puVar5 + 1; + } + for (uVar4 = uVar4 & 3; uVar4 != 0; uVar4 = uVar4 - 1) { + *(undefined1 *)puVar6 = *(undefined1 *)puVar5; + puVar5 = (undefined4 *)((int)puVar5 + 1); + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + LVar2 = InterlockedDecrement(puVar1 + -4); + if ((LVar2 == 0) && (puVar1 + -5 != (undefined4 *)0x0)) { + (**(code **)puVar1[-5])(1); + } + return; +} + + + +// --- FUN_00408120 at 0x00408120 (size: 245) --- + +void __fastcall FUN_00408120(int *param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + uint local_20; + undefined4 local_1c [2]; + undefined *local_14; + undefined *local_10; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) != 0x80000000) { + if ((*param_1 != 0) && (local_20 = param_1[1] & 0x7fffffff, -1 < (int)(local_20 - 1))) { + do { + local_14 = PTR_DAT_00818344; + local_1c[0] = 0; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + local_10 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00407750(local_1c); + puVar2 = (undefined4 *)(local_10 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_10 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_14 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_14 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_20 = local_20 - 1; + } while (local_20 != 0); + } + return; + } + if (*param_1 != 0) { + FUN_00407d80(3); + } + *param_1 = 0; + param_1[1] = 0; + return; +} + + + +// --- FUN_00408220 at 0x00408220 (size: 158) --- + +undefined4 __thiscall FUN_00408220(int *param_1,uint param_2) + +{ + int iVar1; + int iVar2; + + if (param_2 < (uint)param_1[2]) { + return 0; + } + if ((param_1[1] & 0x7fffffffU) < param_2) { + if (param_2 != 0) { + iVar1 = thunk_FUN_005df0f5(param_2 * 4); + if (iVar1 == 0) { + return 0; + } + if (*param_1 != 0) { + iVar2 = param_1[2] + -1; + while (-1 < iVar2) { + iVar2 = iVar2 + -1; + *(undefined4 *)(iVar1 + 4 + iVar2 * 4) = *(undefined4 *)(*param_1 + 4 + iVar2 * 4); + } + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + } + } + *param_1 = iVar1; + param_1[1] = param_2 | 0x80000000; + return 1; + } + FUN_004079d0(); + } + return 1; +} + + + +// --- FUN_004082c0 at 0x004082C0 (size: 193) --- + +undefined4 __thiscall FUN_004082c0(int *param_1,uint param_2) + +{ + uint *puVar1; + int iVar2; + uint *puVar3; + + if (param_2 < (uint)param_1[2]) { + return 0; + } + if ((param_1[1] & 0x7fffffffU) < param_2) { + if (param_2 != 0) { + puVar3 = (uint *)thunk_FUN_005df0f5(param_2 * 4 + 4); + if (puVar3 != (uint *)0x0) { + puVar1 = puVar3 + 1; + *puVar3 = param_2; + FUN_00401000(puVar1,4,param_2,FUN_00401a40); + if (puVar1 != (uint *)0x0) { + if (*param_1 != 0) { + iVar2 = param_1[2]; + while (iVar2 = iVar2 + -1, -1 < iVar2) { + FUN_00402070(*param_1 + iVar2 * 4); + } + if (((param_1[1] & 0x80000000U) == 0x80000000) && (*param_1 != 0)) { + FUN_00407920(3); + } + } + *param_1 = (int)puVar1; + param_1[1] = param_2 | 0x80000000; + return 1; + } + } + return 0; + } + FUN_00407a40(); + } + return 1; +} + + + +// --- FUN_00408390 at 0x00408390 (size: 93) --- + +void __fastcall FUN_00408390(undefined4 *param_1) + +{ + undefined4 *puVar1; + LONG LVar2; + uint uVar3; + uint uVar4; + undefined4 *puVar5; + undefined4 *puVar6; + + puVar1 = (undefined4 *)*param_1; + if (puVar1[-4] == 1) { + puVar1[-2] = 0xffffffff; + return; + } + FUN_004022d0(puVar1[-1] + -1); + uVar4 = ((undefined4 *)*param_1)[-1] * 2; + puVar6 = (undefined4 *)*param_1; + puVar5 = puVar1; + for (uVar3 = uVar4 >> 2; uVar3 != 0; uVar3 = uVar3 - 1) { + *puVar6 = *puVar5; + puVar6 = puVar6 + 1; + puVar5 = puVar5 + 1; + } + for (uVar4 = uVar4 & 3; uVar4 != 0; uVar4 = uVar4 - 1) { + *(undefined1 *)puVar6 = *(undefined1 *)puVar5; + puVar5 = (undefined4 *)((int)puVar5 + 1); + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + LVar2 = InterlockedDecrement(puVar1 + -4); + if ((LVar2 == 0) && (puVar1 + -5 != (undefined4 *)0x0)) { + (**(code **)puVar1[-5])(1); + } + return; +} + + + +// --- FUN_004083f0 at 0x004083F0 (size: 389) --- + +bool FUN_004083f0(uint *param_1,int *param_2) + +{ + long *plVar1; + uint uVar2; + long lVar3; + int iVar4; + bool bVar5; + bool bVar6; + + bVar6 = true; + bVar5 = true; + switch(*param_1 & 0xff) { + case 0x11: + if ((uint *)param_1[4] != (uint *)0x0) { + *(uint *)param_1[4] = param_1[5]; + return true; + } + break; + case 0x12: + case 0x13: + case 0x14: + case 0x15: + case 0x16: + case 0x17: + case 0x18: + case 0x19: + case 0x1a: + case 0x1b: + case 0x1c: + case 0x1d: + case 0x1e: + case 0x1f: + case 0x20: + case 0x21: + case 0x23: + case 0x24: + case 0x25: + case 0x26: + case 0x27: + case 0x28: + case 0x29: + case 0x2a: + case 0x2b: + case 0x2c: + case 0x2d: + case 0x2e: + case 0x2f: + case 0x30: + case 0x31: + case 0x33: + case 0x34: + case 0x35: + case 0x36: + case 0x37: + case 0x38: + case 0x39: + case 0x3a: + case 0x3b: + case 0x3c: + case 0x3d: + case 0x3e: + case 0x3f: + case 0x40: + case 0x41: + case 0x43: + case 0x44: + case 0x45: + case 0x46: + case 0x47: + case 0x48: + case 0x49: + case 0x4a: + case 0x4b: + case 0x4c: + case 0x4d: + case 0x4e: + case 0x4f: + case 0x50: + case 0x51: + case 0x53: + case 0x54: + case 0x55: + case 0x56: + case 0x57: + case 0x58: + case 0x59: + case 0x5a: + case 0x5b: + case 0x5c: + case 0x5d: + case 0x5e: + case 0x5f: + case 0x60: + case 0x61: + case 99: + case 100: + case 0x65: + case 0x66: + case 0x67: + case 0x68: + case 0x69: + case 0x6a: + case 0x6b: + case 0x6c: + case 0x6d: + case 0x6e: + case 0x6f: + case 0x70: + case 0x72: + case 0x73: + case 0x74: + case 0x75: + case 0x76: + case 0x77: + case 0x78: + case 0x79: + case 0x7a: + case 0x7b: + case 0x7c: + case 0x7d: + case 0x7e: + case 0x7f: + case 0x80: + case 0x81: + break; + case 0x22: + plVar1 = (long *)param_1[4]; + if (plVar1 != (long *)0x0) { + lVar3 = strtol((char *)*param_2,(char **)0x0,0); + *plVar1 = lVar3; + return true; + } + break; + case 0x32: + if (param_1[4] != 0) { + param_2 = (int *)*param_2; + InterlockedIncrement((LONG *)((int)param_2 + -0x10)); + FUN_00402070(¶m_2); + FUN_004011b0(); + return true; + } + break; + case 0x42: + if ((param_1[4] != 0) && (iVar4 = sscanf((char *)*param_2,"%f",param_1[4]), iVar4 != 1)) { + return false; + } + break; + case 0x52: + if ((param_1[4] != 0) && (iVar4 = sscanf((char *)*param_2,"%lf",param_1[4]), iVar4 != 1)) { + return false; + } + break; + case 0x62: + if ((param_1[4] != 0) && (iVar4 = sscanf((char *)*param_2,"%hu",param_1[4]), iVar4 != 1)) { + return false; + } + break; + case 0x71: + if (param_1[4] != 0) { + *(bool *)param_1[4] = param_1[5] != 0; + return true; + } + break; + case 0x82: + uVar2 = param_1[4]; + if (uVar2 != 0) { + iVar4 = sscanf((char *)*param_2,"%d",¶m_2); + *(bool *)uVar2 = param_2 != (int *)0x0; + bVar6 = iVar4 == 1; + } + break; + default: + goto switchD_00408413_default; + } + bVar5 = bVar6; +switchD_00408413_default: + return bVar5; +} + + + +// --- FUN_00408610 at 0x00408610 (size: 93) --- + +void __thiscall FUN_00408610(int param_1,int *param_2,undefined4 *param_3) + +{ + uint uVar1; + int iVar2; + undefined4 *puVar3; + uint uVar4; + int iVar5; + + uVar1 = *(uint *)(param_1 + 0x68); + uVar4 = FUN_00407680(); + uVar4 = uVar4 % uVar1; + iVar2 = *(int *)(param_1 + 0x60); + puVar3 = *(undefined4 **)(iVar2 + uVar4 * 4); + while ((puVar3 != (undefined4 *)0x0 && + (iVar5 = _wcsicmp((wchar_t *)*puVar3,(wchar_t *)*param_3), iVar5 != 0))) { + puVar3 = (undefined4 *)puVar3[1]; + } + param_2[2] = (int)puVar3; + *param_2 = param_1; + param_2[1] = iVar2 + uVar4 * 4; + return; +} + + + +// --- FUN_00408670 at 0x00408670 (size: 66) --- + +undefined4 * FUN_00408670(undefined4 *param_1,undefined4 param_2,char *param_3) + +{ + int iVar1; + + iVar1 = _vscprintf(param_3,&stack0x00000010); + FUN_00401280(iVar1); + _vsnprintf((char *)*param_1,iVar1 + 1,param_3,&stack0x00000010); + return param_1; +} + + + +// --- FUN_004086c0 at 0x004086C0 (size: 173) --- + +undefined4 * __thiscall FUN_004086c0(int *param_1,undefined4 *param_2,int *param_3) + +{ + undefined *_Dest; + LONG LVar1; + + _Dest = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + LVar1 = InterlockedDecrement((LONG *)(_Dest + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(_Dest + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(_Dest + -0x14))(1); + } + FUN_004022d0(*(int *)(*param_3 + -4) + -2 + *(int *)(*param_1 + -4)); + wcscpy((wchar_t *)_Dest,(wchar_t *)*param_1); + wcscpy((wchar_t *)(_Dest + *(int *)(*param_1 + -4) * 2 + -2),(wchar_t *)*param_3); + *param_2 = _Dest; + InterlockedIncrement((LONG *)(_Dest + -0x10)); + LVar1 = InterlockedDecrement((LONG *)(_Dest + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(_Dest + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(_Dest + -0x14))(1); + } + return param_2; +} + + + +// --- FUN_00408770 at 0x00408770 (size: 95) --- + +void __thiscall FUN_00408770(int *param_1,uint param_2,char param_3) + +{ + uint uVar1; + + uVar1 = *(uint *)(*param_1 + -4); + if ((param_2 < uVar1) && (*(char *)(*param_1 + param_2) != param_3)) { + uVar1 = uVar1 - 1; + if (param_2 == uVar1) { + FUN_00404ef0(¶m_3,1); + return; + } + FUN_004080c0(); + *(char *)(param_2 + *param_1) = param_3; + if ((param_3 == '\0') && (param_2 < uVar1)) { + *(uint *)(*param_1 + -4) = param_2 + 1; + } + } + return; +} + + + +// --- FUN_004087d0 at 0x004087D0 (size: 35) --- + +undefined4 __thiscall FUN_004087d0(undefined4 param_1,int *param_2) + +{ + int iVar1; + + iVar1 = *(int *)(*param_2 + -4); + if (iVar1 != 1) { + FUN_00404ef0(*param_2,iVar1 + -1); + } + return param_1; +} + + + +// --- FUN_00408800 at 0x00408800 (size: 35) --- + +undefined4 __thiscall FUN_00408800(undefined4 param_1,int *param_2) + +{ + int iVar1; + + iVar1 = *(int *)(*param_2 + -4); + if (iVar1 != 1) { + FUN_00402490(*param_2,iVar1 + -1); + } + return param_1; +} + + + +// --- FUN_00408830 at 0x00408830 (size: 224) --- + +undefined4 __thiscall FUN_00408830(int *param_1,uint param_2) + +{ + uint *puVar1; + uint uVar2; + uint *puVar3; + int iVar4; + + uVar2 = param_2; + if (param_2 < (uint)param_1[2]) { + return 0; + } + if ((param_1[1] & 0x7fffffffU) < param_2) { + if (param_2 != 0) { + puVar3 = (uint *)thunk_FUN_005df0f5(param_2 * 0x1c + 4); + if (puVar3 != (uint *)0x0) { + puVar1 = puVar3 + 1; + *puVar3 = param_2; + FUN_00401000(puVar1,0x1c,param_2,FUN_00407b10); + if (puVar1 != (uint *)0x0) { + if (*param_1 != 0) { + param_2 = param_1[2]; + if (-1 < (int)(param_2 + -1)) { + iVar4 = (param_2 + -1) * 0x1c; + do { + FUN_00407750(*param_1 + iVar4); + iVar4 = iVar4 + -0x1c; + param_2 = param_2 + -1; + } while (param_2 != 0); + } + if (((param_1[1] & 0x80000000U) == 0x80000000) && (*param_1 != 0)) { + FUN_00407d80(3); + } + } + *param_1 = (int)puVar1; + param_1[1] = uVar2 | 0x80000000; + return 1; + } + } + return 0; + } + FUN_00408120(); + } + return 1; +} + + + +// --- FUN_00408910 at 0x00408910 (size: 219) --- + +undefined1 __thiscall FUN_00408910(int *param_1,uint param_2,char param_3) + +{ + LONG *lpAddend; + int iVar1; + undefined *puVar2; + undefined *puVar3; + char cVar4; + uint uVar5; + LONG LVar6; + + if ((param_1[1] & 0x7fffffffU) < param_2) { + uVar5 = param_2; + if (param_3 == '\0') { + uVar5 = FUN_004077f0(param_2); + } + cVar4 = FUN_004082c0(uVar5); + if (cVar4 == '\0') { + return 0; + } + } + else { + _param_3 = param_2; + if (param_2 < (uint)param_1[2]) { + do { + puVar3 = PTR_DAT_00818344; + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + InterlockedIncrement(lpAddend); + iVar1 = *param_1; + puVar2 = *(undefined **)(iVar1 + _param_3 * 4); + if (puVar2 != puVar3) { + LVar6 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + *(undefined **)(iVar1 + _param_3 * 4) = puVar3; + InterlockedIncrement(lpAddend); + } + LVar6 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar3 + -0x14))(1); + } + _param_3 = _param_3 + 1; + } while (_param_3 < (uint)param_1[2]); + } + } + param_1[2] = param_2; + return 1; +} + + + +// --- FUN_004089f0 at 0x004089F0 (size: 100) --- + +void __thiscall FUN_004089f0(int *param_1,uint param_2,short param_3) + +{ + uint uVar1; + + uVar1 = *(uint *)(*param_1 + -4); + if ((param_2 < uVar1) && (*(short *)(*param_1 + param_2 * 2) != param_3)) { + uVar1 = uVar1 - 1; + if (param_2 == uVar1) { + FUN_00402490(¶m_3,1); + return; + } + FUN_00408390(); + *(short *)(*param_1 + param_2 * 2) = param_3; + if ((param_3 == 0) && (param_2 < uVar1)) { + *(uint *)(*param_1 + -4) = param_2 + 1; + } + } + return; +} + + + +// --- FUN_00408cb0 at 0x00408CB0 (size: 218) --- + +undefined4 __thiscall FUN_00408cb0(int param_1,undefined4 *param_2,int param_3) + +{ + int iVar1; + ushort *puVar2; + char *pcVar3; + undefined4 uVar4; + LONG LVar5; + ushort *puVar6; + undefined4 *puVar7; + undefined4 *puVar8; + + puVar2 = (ushort *)*param_2; + iVar1 = *(int *)(puVar2 + -2); + puVar6 = puVar2 + iVar1 + -1; + if (iVar1 != 0) { + puVar6 = puVar2; + } + if (*puVar6 == 0) { + return 0; + } + if (iVar1 == 0) { + puVar2 = puVar2 + -1; + } + pcVar3 = strchr(*(char **)(param_1 + 8),(uint)*puVar2); + if (pcVar3 == (char *)0x0) { + if ((char)param_3 != '\0') { + return 0; + } + if ((*(int *)(*(char **)(param_1 + 8) + -4) != 1) && + (pcVar3 = strchr(*(char **)(param_1 + 8),0x20), pcVar3 == (char *)0x0)) { + return 0; + } + puVar7 = ¶m_3; + puVar8 = param_2; + FUN_00402730(&DAT_00795358); + uVar4 = FUN_004086c0(puVar7,puVar8); + FUN_00402070(uVar4); + puVar7 = (undefined4 *)(param_3 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar5 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + LVar5 = InterlockedDecrement(param_2 + -4); + if ((LVar5 == 0) && (param_2 + -5 != (undefined4 *)0x0)) { + (**(code **)param_2[-5])(1); + } + } + return 1; +} + + + +// --- FUN_00408d90 at 0x00408D90 (size: 173) --- + +undefined4 __thiscall FUN_00408d90(int *param_1,uint param_2) + +{ + char *pcVar1; + int iVar2; + char cVar3; + LONG LVar4; + + pcVar1 = (char *)*param_1; + if ((*(int *)(pcVar1 + -0x10) == 1) && (param_2 + 1 <= *(uint *)(pcVar1 + -4))) { + param_2 = param_2 & 0xffffff00; + iVar2 = *(int *)(pcVar1 + -4); + if ((iVar2 != 0) && (*pcVar1 != '\0')) { + if (iVar2 == 1) { + FUN_00404ef0(¶m_2,1); + return 1; + } + FUN_004080c0(); + *(char *)*param_1 = (char)param_2; + if (((char)param_2 == '\0') && (iVar2 != 1)) { + *(undefined4 *)(*param_1 + -4) = 1; + } + } + return 1; + } + cVar3 = FUN_00401280(param_2); + if (cVar3 != '\0') { + LVar4 = InterlockedDecrement((LONG *)(pcVar1 + -0x10)); + if ((LVar4 == 0) && (pcVar1 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(pcVar1 + -0x14))(1); + } + *(undefined4 *)(*param_1 + -4) = 1; + return 1; + } + return 0; +} + + + +// --- FUN_00408e40 at 0x00408E40 (size: 120) --- + +undefined1 __thiscall FUN_00408e40(int *param_1,int *param_2) + +{ + int *piVar1; + int iVar2; + char cVar3; + undefined4 uVar4; + LONG LVar5; + + if ((param_1[1] & 0x7fffffffU) <= (uint)param_1[2]) { + uVar4 = FUN_004077f0((param_1[1] & 0x7fffffffU) + 1); + cVar3 = FUN_00407f10(uVar4); + if (cVar3 == '\0') { + return 0; + } + } + piVar1 = (int *)(*param_1 + param_1[2] * 4); + iVar2 = *piVar1; + if (iVar2 != *param_2) { + LVar5 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar2 = *param_2; + *piVar1 = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + } + param_1[2] = param_1[2] + 1; + return 1; +} + + + +// --- FUN_00408ec0 at 0x00408EC0 (size: 180) --- + +undefined4 __thiscall FUN_00408ec0(int *param_1,int param_2) + +{ + short *psVar1; + int iVar2; + char cVar3; + LONG LVar4; + + psVar1 = (short *)*param_1; + if ((*(int *)(psVar1 + -8) == 1) && (param_2 + 1U <= *(uint *)(psVar1 + -2))) { + param_2 = 0; + iVar2 = *(int *)(psVar1 + -2); + if ((iVar2 != 0) && (*psVar1 != 0)) { + if (iVar2 == 1) { + FUN_00402490(¶m_2,1); + return 1; + } + FUN_00408390(); + *(short *)*param_1 = (short)param_2; + if (((short)param_2 == 0) && (iVar2 != 1)) { + *(undefined4 *)(*param_1 + -4) = 1; + } + } + return 1; + } + cVar3 = FUN_004022d0(param_2); + if (cVar3 != '\0') { + LVar4 = InterlockedDecrement((LONG *)(psVar1 + -8)); + if ((LVar4 == 0) && (psVar1 + -10 != (short *)0x0)) { + (*(code *)**(undefined4 **)(psVar1 + -10))(1); + } + *(undefined4 *)(*param_1 + -4) = 1; + return 1; + } + return 0; +} + + + +// --- FUN_00408f80 at 0x00408F80 (size: 65) --- + +undefined4 __thiscall FUN_00408f80(int param_1,ushort param_2) + +{ + ushort *puVar1; + + puVar1 = *(ushort **)(*(int *)(param_1 + 0xe4) + ((uint)param_2 % *(uint *)(param_1 + 0xec)) * 4); + while( true ) { + if (puVar1 == (ushort *)0x0) { + return 0xffffffff; + } + if (*puVar1 == param_2) break; + puVar1 = *(ushort **)(puVar1 + 2); + } + if (puVar1 == (ushort *)0x0) { + return 0xffffffff; + } + return *(undefined4 *)(puVar1 + 4); +} + + + +// --- FUN_00408fd0 at 0x00408FD0 (size: 640) --- + +int * __thiscall FUN_00408fd0(int *param_1,int *param_2,ushort param_3) + +{ + LONG *lpAddend; + undefined *puVar1; + LONG LVar2; + int iVar3; + ushort *puVar4; + DWORD DVar5; + DWORD DVar6; + int *piVar7; + int iVar8; + int *unaff_EDI; + int *piVar9; + uint uVar10; + int iStack_4c; + undefined1 *puStack_48; + int *piStack_44; + + puVar1 = PTR_DAT_00818344; + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + InterlockedIncrement(lpAddend); + if (*(int *)(*param_1 + -4) == 1) { + *param_2 = (int)puVar1; + InterlockedIncrement(lpAddend); + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(); + } + return param_2; + } + piVar9 = (int *)(uint)param_3; + piVar7 = (int *)&DAT_007953a4; + if (piVar9 < (int *)0xcec9) { + if (piVar9 != (int *)0xcec8) { + switch(piVar9) { + case (int *)0xc42c: + case (int *)0xc42d: + case (int *)0xc42e: + case (int *)0xc431: + case (int *)0xc433: + case (int *)0xc435: + break; + default: + goto switchD_0040905f_caseD_c42f; + } + } + } + else if (piVar9 < (int *)0xdeb4) { + if ((piVar9 < (int *)0xdeaa) && (piVar9 != (int *)0xd698)) goto switchD_0040905f_caseD_c42f; + } + else if ((piVar9 < (int *)0xfde8) || ((int *)0xfde9 < piVar9)) goto switchD_0040905f_caseD_c42f; + piVar7 = (int *)0x0; +switchD_0040905f_caseD_c42f: + iVar3 = (*(code *)PTR_FUN_00837398)(); + if (iVar3 == 0) { + iVar3 = *(int *)(*piVar7 + -4) + -1; + piStack_44 = (int *)0x4090d4; + FUN_00408d90(); + if (0 < iVar3) { + uVar10 = 0; + do { + puVar1 = PTR_DAT_00818344; + iVar8 = *piVar7; + if (uVar10 < *(uint *)(iVar8 + -4)) { + puVar4 = (ushort *)(iVar8 + uVar10 * 2); + } + else { + puVar4 = (ushort *)(iVar8 + -2 + *(uint *)(iVar8 + -4) * 2); + } + if (*puVar4 < 0x80) { + piStack_44 = (int *)&stack0xffffffe8; + puStack_48 = (undefined1 *)0x409175; + FUN_00404ef0(); + } + else { + piStack_44 = (int *)0x409112; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + puStack_48 = &stack0xffffffe8; + piStack_44 = (int *)0x79539c; + iStack_4c = 0x409125; + FUN_00402710(); + if (*(int *)(puVar1 + -4) != 1) { + piStack_44 = (int *)puVar1; + puStack_48 = (undefined1 *)0x409142; + FUN_00404ef0(); + } + piStack_44 = (int *)0x40914f; + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + piStack_44 = (int *)0x40915f; + (*(code *)**(undefined4 **)(puVar1 + -0x14))(); + } + } + uVar10 = uVar10 + 1; + } while ((int)uVar10 < iVar3); + } + *unaff_EDI = 0; + piStack_44 = (int *)0x409194; + InterlockedIncrement((LONG *)0xfffffff0); + piStack_44 = (int *)0x4091a1; + LVar2 = InterlockedDecrement((LONG *)0xfffffff0); + piVar9 = unaff_EDI; + if (LVar2 == 0) { + piStack_44 = (int *)0x4091b9; + (*(code *)*puRamffffffec)(); + return unaff_EDI; + } + } + else { + piStack_44 = (int *)0x4091cf; + FUN_00401280(); + iVar8 = 0; + iStack_4c = 0; + puStack_48 = (undefined1 *)iVar3; + piStack_44 = piVar7; + iVar3 = (*(code *)PTR_FUN_00837398)(piVar9,0,*piVar7,*(undefined4 *)(*piVar7 + -4)); + if (iVar3 == 0) { + DVar5 = GetLastError(); + DVar6 = GetLastError(); + FUN_00402710(&iStack_4c,"Failed conversion to codepage %hu! GetLastError %d (0x%08x)\n",piVar9 + ,DVar6,DVar5); + iVar8 = iStack_4c; + iVar3 = iRamfffffffc; + } + iRamfffffffc = iVar3; + *piVar9 = iVar8; + InterlockedIncrement((LONG *)(iVar8 + -0x10)); + LVar2 = InterlockedDecrement((LONG *)(iVar8 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar8 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar8 + -0x14))(1); + } + } + return piVar9; +} + + + +// --- FUN_00409270 at 0x00409270 (size: 80) --- + +void __thiscall FUN_00409270(int param_1,undefined4 param_2) + +{ + char cVar1; + uint uVar2; + undefined4 uVar3; + + uVar2 = *(uint *)(param_1 + 4) & 0x7fffffff; + if (uVar2 <= *(uint *)(param_1 + 8)) { + uVar3 = FUN_004077f0(uVar2 + 1); + cVar1 = FUN_00408830(uVar3); + if (cVar1 == '\0') { + return; + } + } + FUN_00407750(param_2); + *(int *)(param_1 + 8) = *(int *)(param_1 + 8) + 1; + return; +} + + + +// --- FUN_004092c0 at 0x004092C0 (size: 100) --- + +undefined4 FUN_004092c0(int *param_1) + +{ + int iVar1; + LONG LVar2; + undefined4 uVar3; + undefined1 local_c [8]; + int local_4; + + iVar1 = *param_1; + uVar3 = 0xffffffff; + param_1 = (int *)iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + FUN_00408610(local_c,¶m_1); + if (local_4 != 0) { + uVar3 = *(undefined4 *)(local_4 + 8); + } + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + return uVar3; +} + + + +// --- FUN_00409330 at 0x00409330 (size: 374) --- + +/* WARNING: Removing unreachable block (ram,0x00409392) */ +/* WARNING: Removing unreachable block (ram,0x004093ae) */ +/* WARNING: Removing unreachable block (ram,0x004093b7) */ +/* WARNING: Removing unreachable block (ram,0x004093c9) */ +/* WARNING: Removing unreachable block (ram,0x0040939a) */ +/* WARNING: Removing unreachable block (ram,0x004093a3) */ +/* WARNING: Removing unreachable block (ram,0x00409493) */ + +void __thiscall FUN_00409330(int *param_1,int *param_2) + +{ + int *piVar1; + int iVar2; + int *piVar3; + char cVar4; + undefined4 extraout_ECX; + uint uVar5; + uint _NumOfElements; + undefined4 uVar6; + int iVar7; + int iVar8; + int local_28; + uint local_14; + undefined1 local_10; + undefined1 local_f; + + piVar3 = param_2; + local_14 = 0; + FUN_00408220(param_2[2]); + piVar1 = param_2 + 2; + param_2 = (int *)0x0; + _NumOfElements = 0; + if (*piVar1 != 0) { + local_28 = 0; + do { + iVar8 = *piVar3; + cVar4 = FUN_00408220(8); + if (cVar4 != '\0') { + *(int *)(local_14 * 4) = iVar8 + local_28; + local_14 = local_14 + 1; + } + param_2 = (int *)((int)param_2 + 1); + local_28 = local_28 + 0x1c; + _NumOfElements = local_14; + } while (param_2 < (uint)piVar3[2]); + } + uVar5 = 0; + qsort((void *)0x0,_NumOfElements,4,(_PtFuncCompare *)&LAB_004075e0); + if (_NumOfElements != 0) { + do { + local_10 = *(undefined1 *)(*(int *)(uVar5 * 4) + 4); + iVar8 = *(int *)(*(int *)(uVar5 * 4) + 0xc); + local_f = 0; + InterlockedIncrement((LONG *)(iVar8 + -0x10)); + iVar7 = *(int *)(*(int *)(uVar5 * 4) + 8); + InterlockedIncrement((LONG *)(iVar7 + -0x10)); + iVar2 = *param_1; + uVar6 = extraout_ECX; + FUN_00401340(&local_10); + (**(code **)(iVar2 + 0x2c))(uVar6,iVar7,iVar8); + uVar5 = uVar5 + 1; + } while (uVar5 < _NumOfElements); + } + return; +} + + + +// --- FUN_004094b0 at 0x004094B0 (size: 151) --- + +undefined4 * __thiscall FUN_004094b0(undefined4 *param_1,uint param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + uint local_4; + + local_4 = param_2; + param_2 = param_2 & 0xffffff00; + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00795324; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_004064a0(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 * 4); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00409550 at 0x00409550 (size: 151) --- + +undefined4 * __thiscall FUN_00409550(undefined4 *param_1,uint param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + uint local_4; + + local_4 = param_2; + param_2 = param_2 & 0xffffff00; + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00795328; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_004064a0(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 * 4); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_004095f0 at 0x004095F0 (size: 82) --- + +void __fastcall FUN_004095f0(int param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + uint local_8; + undefined4 local_4; + + puVar1 = PTR_DAT_00818558; + local_4 = *(undefined4 *)(param_1 + 0x68); + local_8 = local_8 & 0xffffff00; + puVar2 = (undefined4 *)FUN_004064a0(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,local_8,0); + if ((puVar2 != (undefined4 *)puVar1) || (puVar2 = puVar2 + -1, puVar2 != (undefined4 *)puVar1)) { + puVar2 = puVar2 + 1; + } + FUN_00409c10(*puVar2); + return; +} + + + +// --- FUN_00409650 at 0x00409650 (size: 82) --- + +void __fastcall FUN_00409650(int param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + uint local_8; + undefined4 local_4; + + puVar1 = PTR_DAT_00818558; + local_4 = *(undefined4 *)(param_1 + 0x68); + local_8 = local_8 & 0xffffff00; + puVar2 = (undefined4 *)FUN_004064a0(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,local_8,0); + if ((puVar2 != (undefined4 *)puVar1) || (puVar2 = puVar2 + -1, puVar2 != (undefined4 *)puVar1)) { + puVar2 = puVar2 + 1; + } + FUN_00409d20(*puVar2); + return; +} + + + +// --- FUN_004096b0 at 0x004096B0 (size: 207) --- + +bool FUN_004096b0(char *param_1,undefined4 param_2,int *param_3) + +{ + bool bVar1; + bool bVar2; + char cVar3; + char *pcVar4; + undefined4 uVar5; + char *pcVar6; + + if (param_1 == (char *)0x0) { + return false; + } + pcVar4 = param_1; + do { + cVar3 = *pcVar4; + pcVar4 = pcVar4 + 1; + } while (cVar3 != '\0'); + FUN_004074b0(pcVar4 + (1 - (int)(param_1 + 1)),1); + pcVar4 = (char *)FUN_00406d80(); + bVar1 = false; + param_1 = param_1 + -1; + bVar2 = false; + pcVar6 = pcVar4; + do { + cVar3 = param_1[1]; + param_1 = param_1 + 1; + if ((cVar3 == '\0') || ((cVar3 == ' ' && (!bVar2)))) { + if (bVar1) { + *pcVar6 = '\0'; + pcVar6 = pcVar6 + 1; + if ((uint)param_3[2] < (param_3[1] & 0x7fffffffU)) { +LAB_0040975f: + *(char **)(*param_3 + param_3[2] * 4) = pcVar4; + param_3[2] = param_3[2] + 1; + } + else { + uVar5 = FUN_004077f0((param_3[1] & 0x7fffffffU) + 1); + cVar3 = FUN_00408220(uVar5); + if (cVar3 != '\0') goto LAB_0040975f; + } + bVar1 = false; + } + } + else if (cVar3 == '\"') { + bVar2 = !bVar2; + } + else { + if (!bVar1) { + bVar1 = true; + pcVar4 = pcVar6; + } + *pcVar6 = cVar3; + pcVar6 = pcVar6 + 1; + } + if (*param_1 == '\0') { + return !bVar2; + } + } while( true ); +} + + + +// --- FUN_00409780 at 0x00409780 (size: 220) --- + +bool FUN_00409780(wchar_t *param_1,undefined4 param_2,int *param_3) + +{ + wchar_t wVar1; + bool bVar2; + bool bVar3; + char cVar4; + size_t sVar5; + wchar_t *pwVar6; + undefined4 uVar7; + wchar_t *pwVar8; + + if (param_1 == (wchar_t *)0x0) { + return false; + } + sVar5 = wcslen(param_1); + FUN_004074b0(sVar5 * 2 + 2,1); + pwVar6 = (wchar_t *)FUN_00406d80(); + bVar2 = false; + param_1 = param_1 + -1; + bVar3 = false; + pwVar8 = pwVar6; + do { + wVar1 = param_1[1]; + param_1 = param_1 + 1; + if ((wVar1 == L'\0') || ((wVar1 == L' ' && (!bVar3)))) { + if (bVar2) { + *pwVar8 = L'\0'; + pwVar8 = pwVar8 + 1; + if ((uint)param_3[2] < (param_3[1] & 0x7fffffffU)) { +LAB_00409837: + *(wchar_t **)(*param_3 + param_3[2] * 4) = pwVar6; + param_3[2] = param_3[2] + 1; + } + else { + uVar7 = FUN_004077f0((param_3[1] & 0x7fffffffU) + 1); + cVar4 = FUN_00408220(uVar7); + if (cVar4 != '\0') goto LAB_00409837; + } + bVar2 = false; + } + } + else if (wVar1 == L'\"') { + bVar3 = !bVar3; + } + else { + if (!bVar2) { + bVar2 = true; + pwVar6 = pwVar8; + } + *pwVar8 = wVar1; + pwVar8 = pwVar8 + 1; + } + if (*param_1 == L'\0') { + return !bVar3; + } + } while( true ); +} + + + +// --- FUN_00409860 at 0x00409860 (size: 144) --- + +undefined1 __thiscall FUN_00409860(int *param_1,uint *param_2,uint *param_3) + +{ + uint *puVar1; + int iVar2; + undefined1 uVar3; + undefined4 uVar4; + LONG LVar5; + + puVar1 = param_2; + uVar3 = 1; + if (((*param_2 & 0xff) == 0x32) || ((*param_2 & 0xff) != 0x3a)) { + iVar2 = *param_1; + uVar4 = FUN_00408fd0(¶m_2,0); + uVar3 = (**(code **)(iVar2 + 0x3c))(puVar1,uVar4); + puVar1 = param_2; + } + else { + if (param_2[4] == 0) { + return 1; + } + puVar1 = (uint *)*param_3; + param_3 = puVar1; + InterlockedIncrement((LONG *)(puVar1 + -4)); + FUN_00402070(¶m_3); + } + LVar5 = InterlockedDecrement((LONG *)(puVar1 + -4)); + if ((LVar5 == 0) && (puVar1 + -5 != (uint *)0x0)) { + (**(code **)puVar1[-5])(1); + } + return uVar3; +} + + + +// --- thunk_FUN_004096b0 at 0x004098F0 (size: 5) --- + +bool thunk_FUN_004096b0(char *param_1,undefined4 param_2,int *param_3) + +{ + bool bVar1; + bool bVar2; + char cVar3; + char *pcVar4; + undefined4 uVar5; + char *pcVar6; + + if (param_1 == (char *)0x0) { + return false; + } + pcVar4 = param_1; + do { + cVar3 = *pcVar4; + pcVar4 = pcVar4 + 1; + } while (cVar3 != '\0'); + FUN_004074b0(pcVar4 + (1 - (int)(param_1 + 1)),1); + pcVar4 = (char *)FUN_00406d80(); + bVar1 = false; + param_1 = param_1 + -1; + bVar2 = false; + pcVar6 = pcVar4; + do { + cVar3 = param_1[1]; + param_1 = param_1 + 1; + if ((cVar3 == '\0') || ((cVar3 == ' ' && (!bVar2)))) { + if (bVar1) { + *pcVar6 = '\0'; + pcVar6 = pcVar6 + 1; + if ((uint)param_3[2] < (param_3[1] & 0x7fffffffU)) { +LAB_0040975f: + *(char **)(*param_3 + param_3[2] * 4) = pcVar4; + param_3[2] = param_3[2] + 1; + } + else { + uVar5 = FUN_004077f0((param_3[1] & 0x7fffffffU) + 1); + cVar3 = FUN_00408220(uVar5); + if (cVar3 != '\0') goto LAB_0040975f; + } + bVar1 = false; + } + } + else if (cVar3 == '\"') { + bVar2 = !bVar2; + } + else { + if (!bVar1) { + bVar1 = true; + pcVar4 = pcVar6; + } + *pcVar6 = cVar3; + pcVar6 = pcVar6 + 1; + } + if (*param_1 == '\0') { + return !bVar2; + } + } while( true ); +} + + + +// --- FUN_00409900 at 0x00409900 (size: 245) --- + +undefined1 __thiscall FUN_00409900(int *param_1,int param_2,undefined4 param_3) + +{ + int iVar1; + void *pvVar2; + char cVar3; + undefined1 uVar4; + LONG LVar5; + void *unaff_EBX; + uint unaff_ESI; + int unaff_retaddr; + void *local_18; + undefined4 local_14; + undefined4 local_10; + undefined1 local_c [12]; + + iVar1 = param_2; + if (param_2 != 0) { + FUN_00406d60(); + local_18 = (void *)0x0; + local_14 = 0; + local_10 = 0; + cVar3 = FUN_004096b0(iVar1,local_c,&local_18); + pvVar2 = local_18; + if (cVar3 != '\0') { + uVar4 = (**(code **)(*param_1 + 0x10))(local_18,local_10,param_3); + if ((unaff_ESI & 0x80000000) == 0x80000000) { + operator_delete__(pvVar2); + } + FUN_00406f90(); + return uVar4; + } + FUN_00401340("Unmatched quote"); + (**(code **)(*param_1 + 0x20))(¶m_2); + LVar5 = InterlockedDecrement((LONG *)(unaff_retaddr + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(unaff_retaddr + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(unaff_retaddr + -0x14))(1); + } + if (((uint)local_18 & 0x80000000) == 0x80000000) { + operator_delete__(unaff_EBX); + } + FUN_00406f90(); + } + return 0; +} + + + +// --- FUN_00409a00 at 0x00409A00 (size: 245) --- + +undefined1 __thiscall FUN_00409a00(int *param_1,int param_2,undefined4 param_3) + +{ + int iVar1; + void *pvVar2; + char cVar3; + undefined1 uVar4; + LONG LVar5; + void *unaff_EBX; + uint unaff_ESI; + int unaff_retaddr; + void *local_18; + undefined4 local_14; + undefined4 local_10; + undefined1 local_c [12]; + + iVar1 = param_2; + if (param_2 != 0) { + FUN_00406d60(); + local_18 = (void *)0x0; + local_14 = 0; + local_10 = 0; + cVar3 = FUN_00409780(iVar1,local_c,&local_18); + pvVar2 = local_18; + if (cVar3 != '\0') { + uVar4 = (**(code **)(*param_1 + 0xc))(local_18,local_10,param_3); + if ((unaff_ESI & 0x80000000) == 0x80000000) { + operator_delete__(pvVar2); + } + FUN_00406f90(); + return uVar4; + } + FUN_00401340("Unmatched quote"); + (**(code **)(*param_1 + 0x20))(¶m_2); + LVar5 = InterlockedDecrement((LONG *)(unaff_retaddr + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(unaff_retaddr + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(unaff_retaddr + -0x14))(1); + } + if (((uint)local_18 & 0x80000000) == 0x80000000) { + operator_delete__(unaff_EBX); + } + FUN_00406f90(); + } + return 0; +} + + + +// --- FUN_00409b00 at 0x00409B00 (size: 186) --- + +undefined1 __thiscall FUN_00409b00(int *param_1,int param_2,int param_3,undefined4 param_4) + +{ + undefined1 uVar1; + undefined4 uVar2; + LONG LVar3; + int unaff_EBX; + int iVar4; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + iVar4 = 0; + local_c = 0; + local_8 = 0; + local_4 = 0; + FUN_00407f10(param_3); + if (0 < param_3) { + do { + uVar2 = FUN_00404a40(0,*(undefined4 *)(param_2 + iVar4 * 4)); + FUN_00408e40(uVar2); + LVar3 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(param_2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_2 + -0x14))(1); + } + iVar4 = iVar4 + 1; + } while (iVar4 < param_3); + } + uVar1 = (**(code **)(*param_1 + 4))(&local_c,param_4); + if ((((uint)param_1 & 0x80000000) == 0x80000000) && (unaff_EBX != 0)) { + FUN_00407920(3); + } + return uVar1; +} + + + +// --- FUN_00409bc0 at 0x00409BC0 (size: 78) --- + +void __thiscall FUN_00409bc0(int param_1,int param_2) + +{ + uint uVar1; + int iVar2; + uint uVar3; + + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + FUN_004095f0(); + } + uVar1 = *(uint *)(param_1 + 0x68); + uVar3 = FUN_00407680(); + uVar3 = uVar3 % uVar1; + iVar2 = *(int *)(param_1 + 0x60); + *(undefined4 *)(param_2 + 4) = *(undefined4 *)(iVar2 + uVar3 * 4); + *(int *)(iVar2 + uVar3 * 4) = param_2; + uVar1 = iVar2 + uVar3 * 4; + if (uVar1 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar1; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + return; +} + + + +// --- FUN_00409c10 at 0x00409C10 (size: 254) --- + +undefined4 __thiscall FUN_00409c10(int param_1,int param_2) + +{ + uint uVar1; + int iVar2; + int iVar3; + uint uVar4; + int *piVar5; + int iVar6; + int iVar7; + + if (param_2 == *(int *)(param_1 + 0x68)) { + return 0; + } + iVar6 = 0; + if (*(int *)(param_1 + 0x6c) != 0) { + iVar7 = 0; + do { + piVar5 = *(int **)(param_1 + 100); + while (piVar5 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar5 = *(int **)(param_1 + 100); + iVar6 = *piVar5; + goto LAB_00409c5e; + } + piVar5 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar5; + } + piVar5 = (int *)0x0; + iVar6 = 0; +LAB_00409c5e: + iVar3 = *piVar5; + if (iVar3 == iVar6) { +LAB_00409c71: + *piVar5 = *(int *)(iVar3 + 4); + } + else { + do { + iVar2 = iVar3; + iVar3 = *(int *)(iVar2 + 4); + } while (iVar3 != iVar6); + if (iVar2 == 0) goto LAB_00409c71; + *(undefined4 *)(iVar2 + 4) = *(undefined4 *)(iVar3 + 4); + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + *(int *)(iVar6 + 4) = iVar7; + iVar7 = iVar6; + } while (*(int *)(param_1 + 0x6c) != 0); + } + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_0065ec90(param_2); + while (iVar6 != 0) { + iVar7 = *(int *)(iVar6 + 4); + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + FUN_004095f0(); + } + uVar1 = *(uint *)(param_1 + 0x68); + uVar4 = FUN_00407680(); + uVar4 = uVar4 % uVar1; + iVar3 = *(int *)(param_1 + 0x60); + *(undefined4 *)(iVar6 + 4) = *(undefined4 *)(iVar3 + uVar4 * 4); + *(int *)(iVar3 + uVar4 * 4) = iVar6; + uVar1 = iVar3 + uVar4 * 4; + if (uVar1 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar1; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + iVar6 = iVar7; + } + return 1; +} + + + +// --- FUN_00409d20 at 0x00409D20 (size: 248) --- + +undefined4 __thiscall FUN_00409d20(int param_1,int param_2) + +{ + int iVar1; + ushort *puVar2; + int *piVar3; + ushort *puVar4; + ushort *puVar5; + ushort *puVar6; + uint uVar7; + undefined4 *puVar8; + + if (param_2 == *(int *)(param_1 + 0x68)) { + return 0; + } + iVar1 = *(int *)(param_1 + 0x6c); + puVar2 = (ushort *)0x0; + do { + if (iVar1 == 0) { + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_0065ec90(param_2); + while (puVar2 != (ushort *)0x0) { + puVar6 = *(ushort **)(puVar2 + 2); + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + FUN_00409650(); + } + uVar7 = (uint)*puVar2 % *(uint *)(param_1 + 0x68); + iVar1 = *(int *)(param_1 + 0x60); + *(undefined4 *)(puVar2 + 2) = *(undefined4 *)(iVar1 + uVar7 * 4); + *(ushort **)(iVar1 + uVar7 * 4) = puVar2; + uVar7 = iVar1 + uVar7 * 4; + if (uVar7 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar7; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + puVar2 = puVar6; + } + return 1; + } + piVar3 = *(int **)(param_1 + 100); + while (piVar3 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + puVar8 = *(undefined4 **)(param_1 + 100); + puVar6 = (ushort *)*puVar8; + goto LAB_00409d6f; + } + piVar3 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar3; + } + puVar8 = (undefined4 *)0x0; + puVar6 = (ushort *)0x0; +LAB_00409d6f: + puVar5 = (ushort *)*puVar8; + if (puVar5 == puVar6) { +LAB_00409d83: + *puVar8 = *(undefined4 *)(puVar5 + 2); + } + else { + do { + puVar4 = puVar5; + puVar5 = *(ushort **)(puVar4 + 2); + } while (puVar5 != puVar6); + if (puVar4 == (ushort *)0x0) goto LAB_00409d83; + *(undefined4 *)(puVar4 + 2) = *(undefined4 *)(puVar5 + 2); + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + *(ushort **)(puVar6 + 2) = puVar2; + iVar1 = *(int *)(param_1 + 0x6c); + puVar2 = puVar6; + } while( true ); +} + + + +// --- FUN_00409e20 at 0x00409E20 (size: 165) --- + +void __fastcall FUN_00409e20(int param_1) + +{ + int iVar1; + int *piVar2; + int *piVar3; + LONG LVar4; + int *piVar5; + int *piVar6; + undefined4 *puVar7; + + iVar1 = *(int *)(param_1 + 0x6c); + do { + if (iVar1 == 0) { + return; + } + piVar5 = *(int **)(param_1 + 100); + while (piVar5 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar5 = *(int **)(param_1 + 100); + piVar6 = (int *)*piVar5; + goto LAB_00409e63; + } + piVar5 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar5; + } + piVar5 = (int *)0x0; + piVar6 = (int *)0x0; +LAB_00409e63: + piVar3 = (int *)*piVar5; + if (piVar3 == piVar6) { +LAB_00409e7d: + *piVar5 = piVar3[1]; + } + else { + do { + piVar2 = piVar3; + piVar3 = (int *)piVar2[1]; + } while (piVar3 != piVar6); + if (piVar2 == (int *)0x0) goto LAB_00409e7d; + piVar2[1] = piVar3[1]; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + if (piVar6 != (int *)0x0) { + puVar7 = (undefined4 *)(*piVar6 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*piVar6 + -0x10)); + if ((LVar4 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + operator_delete(piVar6); + } + iVar1 = *(int *)(param_1 + 0x6c); + } while( true ); +} + + + +// --- FUN_00409ed0 at 0x00409ED0 (size: 119) --- + +uint __thiscall FUN_00409ed0(int param_1,ushort *param_2) + +{ + ushort *puVar1; + int iVar2; + uint uVar3; + + puVar1 = *(ushort **) + (*(uint *)(param_1 + 0x60) + ((uint)*param_2 % *(uint *)(param_1 + 0x68)) * 4); + do { + if (puVar1 == (ushort *)0x0) { +LAB_00409efc: + if ((int)(*(uint *)(param_1 + 0x68) * 2) < *(int *)(param_1 + 0x6c) + 1) { + FUN_00409650(); + } + uVar3 = (uint)*param_2 % *(uint *)(param_1 + 0x68); + iVar2 = *(int *)(param_1 + 0x60); + *(undefined4 *)(param_2 + 2) = *(undefined4 *)(iVar2 + uVar3 * 4); + *(ushort **)(iVar2 + uVar3 * 4) = param_2; + uVar3 = iVar2 + uVar3 * 4; + if (uVar3 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar3; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + return CONCAT31((int3)(uVar3 >> 8),1); + } + if (*puVar1 == *param_2) { + if (puVar1 != (ushort *)0x0) { + return *(uint *)(param_1 + 0x60) & 0xffffff00; + } + goto LAB_00409efc; + } + puVar1 = *(ushort **)(puVar1 + 2); + } while( true ); +} + + + +// --- FUN_00409f50 at 0x00409F50 (size: 121) --- + +void __fastcall FUN_00409f50(int param_1) + +{ + int iVar1; + void *pvVar2; + void *pvVar3; + void *pvVar4; + int *piVar5; + + iVar1 = *(int *)(param_1 + 0x6c); + do { + if (iVar1 == 0) { + return; + } + piVar5 = *(int **)(param_1 + 100); + while (piVar5 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar5 = *(int **)(param_1 + 100); + pvVar4 = (void *)*piVar5; + goto LAB_00409f8f; + } + piVar5 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar5; + } + piVar5 = (int *)0x0; + pvVar4 = (void *)0x0; +LAB_00409f8f: + pvVar3 = (void *)*piVar5; + if (pvVar3 == pvVar4) { +LAB_00409fa2: + *piVar5 = *(int *)((int)pvVar3 + 4); + } + else { + do { + pvVar2 = pvVar3; + pvVar3 = *(void **)((int)pvVar2 + 4); + } while (pvVar3 != pvVar4); + if (pvVar2 == (void *)0x0) goto LAB_00409fa2; + *(undefined4 *)((int)pvVar2 + 4) = *(undefined4 *)((int)pvVar3 + 4); + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + if (pvVar4 != (void *)0x0) { + operator_delete(pvVar4); + } + iVar1 = *(int *)(param_1 + 0x6c); + } while( true ); +} + + + +// --- FUN_00409fd0 at 0x00409FD0 (size: 156) --- + +undefined4 FUN_00409fd0(int *param_1,int *param_2) + +{ + int iVar1; + int *piVar2; + LONG LVar3; + undefined4 *puVar4; + undefined1 local_c [8]; + int local_4; + + piVar2 = (int *)FUN_005df0f5(0xc); + if (piVar2 == (int *)0x0) { + piVar2 = (int *)0x0; + } + else { + iVar1 = *param_1; + *piVar2 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + piVar2[1] = 0; + piVar2[2] = *param_2; + } + FUN_00408610(local_c,piVar2); + if (local_4 == 0) { + FUN_00409bc0(piVar2); + return 1; + } + if (piVar2 != (int *)0x0) { + puVar4 = (undefined4 *)(*piVar2 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(*piVar2 + -0x10)); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + operator_delete(piVar2); + } + return 0; +} + + + +// --- FUN_0040a070 at 0x0040A070 (size: 90) --- + +undefined4 FUN_0040a070(undefined2 *param_1,undefined4 *param_2) + +{ + char cVar1; + undefined2 *puVar2; + + puVar2 = (undefined2 *)FUN_005df0f5(0xc); + if (puVar2 == (undefined2 *)0x0) { + puVar2 = (undefined2 *)0x0; + } + else { + *puVar2 = *param_1; + *(undefined4 *)(puVar2 + 2) = 0; + *(undefined4 *)(puVar2 + 4) = *param_2; + } + cVar1 = FUN_00409ed0(puVar2); + if (cVar1 == '\0') { + if (puVar2 != (undefined2 *)0x0) { + operator_delete(puVar2); + } + return 0; + } + return 1; +} + + + +// --- FUN_0040a0d0 at 0x0040A0D0 (size: 288) --- + +undefined4 __thiscall FUN_0040a0d0(int param_1,int param_2) + +{ + int *piVar1; + LONG *lpAddend; + int iVar2; + int iVar3; + int iVar4; + undefined2 extraout_var; + LONG LVar5; + undefined4 *puVar6; + int local_8; + int local_4; + + iVar2 = param_2; + piVar1 = (int *)(param_2 + 8); + FUN_00403350(¶m_2,0); + iVar4 = FUN_00408f80((short)*(char *)(iVar2 + 4)); + if (iVar4 < 0) { + iVar4 = FUN_004092c0(¶m_2); + if (iVar4 < 0) { + iVar4 = *(int *)(param_1 + 8); + FUN_00409270(iVar2); + if (*(char *)(iVar2 + 4) != '\0') { + local_4 = CONCAT22(extraout_var,(short)*(char *)(iVar2 + 4)); + local_8 = iVar4; + FUN_0040a070(&local_4,&local_8); + } + iVar3 = param_2; + if ((*(int *)(*piVar1 + -4) != 1) || (*(char *)(iVar2 + 4) == '\0')) { + lpAddend = (LONG *)(param_2 + -0x10); + local_4 = param_2; + param_2 = iVar4; + InterlockedIncrement(lpAddend); + FUN_00409fd0(&local_4,¶m_2); + LVar5 = InterlockedDecrement((LONG *)(iVar3 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(iVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar3 + -0x14))(1); + } + } + LVar5 = InterlockedDecrement((LONG *)(iVar3 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(iVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar3 + -0x14))(1); + } + return 1; + } + } + puVar6 = (undefined4 *)(param_2 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar5 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + return 0; +} + + + +// --- FUN_0040a1f0 at 0x0040A1F0 (size: 82) --- + +undefined4 * __thiscall FUN_0040a1f0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007953b8; + FUN_00409e20(); + param_1[1] = &PTR_FUN_00795324; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0040a250 at 0x0040A250 (size: 82) --- + +undefined4 * __thiscall FUN_0040a250(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007953bc; + FUN_00409f50(); + param_1[1] = &PTR_FUN_00795328; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0040a2b0 at 0x0040A2B0 (size: 84) --- + +undefined4 * __fastcall FUN_0040a2b0(undefined4 *param_1) + +{ + *param_1 = 0; + param_1[1] = 0; + param_1[2] = 0; + param_1[3] = &PTR_FUN_007953b8; + FUN_004094b0(0); + param_1[3] = &PTR_FUN_007953b8; + param_1[0x20] = &PTR_FUN_007953bc; + FUN_00409550(0); + param_1[0x20] = &PTR_FUN_007953bc; + return param_1; +} + + + +// --- FUN_0040a310 at 0x0040A310 (size: 153) --- + +void __fastcall FUN_0040a310(int *param_1) + +{ + param_1[0x20] = (int)&PTR_FUN_007953bc; + FUN_00409f50(); + param_1[0x21] = (int)&PTR_FUN_00795328; + if ((int *)param_1[0x39] != param_1 + 0x22) { + operator_delete__((int *)param_1[0x39]); + } + param_1[0x39] = 0; + param_1[0x3a] = 0; + param_1[0x3b] = 0; + param_1[0x3c] = 0; + param_1[3] = (int)&PTR_FUN_007953b8; + FUN_00409e20(); + param_1[4] = (int)&PTR_FUN_00795324; + if ((int *)param_1[0x1c] != param_1 + 5) { + operator_delete__((int *)param_1[0x1c]); + } + param_1[0x1c] = 0; + param_1[0x1d] = 0; + param_1[0x1e] = 0; + param_1[0x1f] = 0; + if (((param_1[1] & 0x80000000U) == 0x80000000) && (*param_1 != 0)) { + FUN_00407d80(3); + } + return; +} + + + +// --- FUN_0040a8d0 at 0x0040A8D0 (size: 4) --- + +undefined4 __fastcall FUN_0040a8d0(int param_1) + +{ + return *(undefined4 *)(param_1 + 0x18); +} + + + +// --- FUN_0040a8e0 at 0x0040A8E0 (size: 10) --- + +void __thiscall FUN_0040a8e0(int param_1,undefined4 param_2) + +{ + *(undefined4 *)(param_1 + 0x18) = param_2; + return; +} + + + +// --- FUN_0040a8f0 at 0x0040A8F0 (size: 16) --- + +int __fastcall FUN_0040a8f0(int param_1) + +{ + int iVar1; + + iVar1 = FUN_00406db0(); + return iVar1 - *(int *)(param_1 + 0x18); +} + + + +// --- FUN_0040a900 at 0x0040A900 (size: 26) --- + +undefined4 __thiscall FUN_0040a900(int param_1,undefined4 param_2) + +{ + FUN_00407140(param_2,0,*(undefined4 *)(param_1 + 0x18)); + return param_2; +} + + + +// --- FUN_0040a920 at 0x0040A920 (size: 24) --- + +undefined4 __thiscall FUN_0040a920(int param_1,undefined4 param_2) + +{ + FUN_00407390(param_2,*(undefined4 *)(param_1 + 0x18)); + return param_2; +} + + + +// --- FUN_0040a960 at 0x0040A960 (size: 19) --- + +undefined4 __fastcall FUN_0040a960(int param_1) + +{ + undefined4 uVar1; + + if (*(int *)(param_1 + 0x20) == 0) { + return 0; + } + /* WARNING: Could not recover jumptable at 0x0040a970. Too many branches */ + /* WARNING: Treating indirect jump as call */ + uVar1 = (**(code **)(**(int **)(param_1 + 0x20) + 0x18))(); + return uVar1; +} + + + +// --- FUN_0040a980 at 0x0040A980 (size: 68) --- + +uint FUN_0040a980(char *param_1) + +{ + uint uVar1; + char cVar2; + + cVar2 = *param_1; + uVar1 = 0; + if (cVar2 != '\0') { + do { + uVar1 = uVar1 * 0x10 + (int)cVar2; + if ((uVar1 & 0xf0000000) != 0) { + uVar1 = ((uVar1 & 0xf0000000) >> 0x18 ^ uVar1) & 0xfffffff; + } + cVar2 = param_1[1]; + param_1 = param_1 + 1; + } while (cVar2 != '\0'); + if (uVar1 == 0xffffffff) { + uVar1 = 0xfffffffe; + } + } + return uVar1; +} + + + +// --- FUN_0040a9f0 at 0x0040A9F0 (size: 21) --- + +undefined4 __fastcall FUN_0040a9f0(int param_1) + +{ + uint uVar1; + + uVar1 = *(uint *)(param_1 + 4) & 0x8000; + return CONCAT31((int3)(uVar1 >> 8),uVar1 == 0x8000); +} + + + +// --- FUN_0040aa10 at 0x0040AA10 (size: 21) --- + +void __thiscall FUN_0040aa10(int param_1,char param_2) + +{ + if (param_2 != '\0') { + *(byte *)(param_1 + 5) = *(byte *)(param_1 + 5) | 0x80; + return; + } + *(byte *)(param_1 + 5) = *(byte *)(param_1 + 5) & 0x7f; + return; +} + + + +// --- FUN_0040aa30 at 0x0040AA30 (size: 21) --- + +void __thiscall FUN_0040aa30(int param_1,char param_2) + +{ + if (param_2 != '\0') { + *(uint *)(param_1 + 4) = *(uint *)(param_1 + 4) | 2; + return; + } + *(uint *)(param_1 + 4) = *(uint *)(param_1 + 4) & 0xfffffffd; + return; +} + + + +// --- FUN_0040aa50 at 0x0040AA50 (size: 12) --- + +void __fastcall FUN_0040aa50(int param_1) + +{ + *(uint *)(param_1 + 4) = *(uint *)(param_1 + 4) | 4; + *(undefined4 *)(param_1 + 8) = 0x80004005; + return; +} + + + +// --- FUN_0040aa60 at 0x0040AA60 (size: 15) --- + +undefined4 __fastcall FUN_0040aa60(int param_1) + +{ + uint uVar1; + + uVar1 = *(uint *)(param_1 + 4) & 0xffffff02; + return CONCAT31((int3)(uVar1 >> 8),(char)uVar1 == '\x02'); +} + + + +// --- FUN_0040aa70 at 0x0040AA70 (size: 85) --- + +undefined4 __thiscall FUN_0040aa70(int param_1,undefined4 param_2,undefined4 param_3) + +{ + char cVar1; + + if ((~(byte)(*(uint *)(param_1 + 4) >> 2) & 1) != 0) { + if (*(int **)(param_1 + 0x20) == (int *)0x0) { + *(undefined4 *)(param_1 + 8) = 0x80004005; + *(uint *)(param_1 + 4) = *(uint *)(param_1 + 4) | 4; + return 0; + } + cVar1 = (**(code **)(**(int **)(param_1 + 0x20) + 0x1c))(param_2,param_3); + if (cVar1 != '\0') { + return 1; + } + *(uint *)(param_1 + 4) = *(uint *)(param_1 + 4) | 4; + *(undefined4 *)(param_1 + 8) = 0x80004005; + } + return 0; +} + + + +// --- FUN_0040aad0 at 0x0040AAD0 (size: 84) --- + +undefined4 * __thiscall FUN_0040aad0(int param_1,undefined4 *param_2) + +{ + if ((~(byte)(*(uint *)(param_1 + 4) >> 2) & 1) == 0) { + *param_2 = DAT_008377a8; + return param_2; + } + if (*(int **)(param_1 + 0x20) == (int *)0x0) { + *(uint *)(param_1 + 4) = *(uint *)(param_1 + 4) | 4; + *(undefined4 *)(param_1 + 8) = 0x80004005; + *param_2 = DAT_008377a8; + return param_2; + } + (**(code **)(**(int **)(param_1 + 0x20) + 0x24))(param_2); + return param_2; +} + + + +// --- FUN_0040ab30 at 0x0040AB30 (size: 89) --- + +undefined4 * __thiscall FUN_0040ab30(int param_1,undefined4 *param_2,undefined4 param_3) + +{ + if ((~(byte)(*(uint *)(param_1 + 4) >> 2) & 1) == 0) { + *param_2 = DAT_008377a8; + return param_2; + } + if (*(int **)(param_1 + 0x20) == (int *)0x0) { + *(uint *)(param_1 + 4) = *(uint *)(param_1 + 4) | 4; + *(undefined4 *)(param_1 + 8) = 0x80004005; + *param_2 = DAT_008377a8; + return param_2; + } + (**(code **)(**(int **)(param_1 + 0x20) + 0x20))(param_2,param_3); + return param_2; +} + + + +// --- FUN_0040ab90 at 0x0040AB90 (size: 19) --- + +uint __fastcall FUN_0040ab90(int param_1) + +{ + uint in_EAX; + uint uVar1; + + if (*(int *)(param_1 + 0x20) == 0) { + return in_EAX & 0xffffff00; + } + /* WARNING: Could not recover jumptable at 0x0040aba0. Too many branches */ + /* WARNING: Treating indirect jump as call */ + uVar1 = (**(code **)(**(int **)(param_1 + 0x20) + 0x2c))(); + return uVar1; +} + + + +// --- FUN_0040abb0 at 0x0040ABB0 (size: 64) --- + +undefined4 * __thiscall FUN_0040abb0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079542c; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0040abf0 at 0x0040ABF0 (size: 55) --- + +undefined4 FUN_0040abf0(int param_1) + +{ + if ((~(byte)(*(uint *)(param_1 + 4) >> 2) & 1) != 0) { + FUN_0040aad0(¶m_1); + FUN_0040aa70(0x436f7265,2); + return 1; + } + return 0; +} + + + +// --- FUN_0040ac70 at 0x0040AC70 (size: 113) --- + +int __thiscall FUN_0040ac70(int param_1,int param_2,int param_3) + +{ + char cVar1; + int iVar2; + uint uVar3; + + if ((*(uint *)(param_1 + 4) >> 2 & 1) != 0) { + return 0; + } + if ((*(byte *)(param_1 + 4) & 1) != 0) { + cVar1 = FUN_00406d70(); + if (cVar1 != '\0') { + FUN_004074b0(param_3 + param_2,1); + goto LAB_0040acaf; + } + } + uVar3 = FUN_00406db0(); + if (uVar3 < (uint)(param_3 + param_2)) { + *(uint *)(param_1 + 4) = *(uint *)(param_1 + 4) | 4; + *(undefined4 *)(param_1 + 8) = 0x80004005; + return 0; + } +LAB_0040acaf: + iVar2 = FUN_00406d80(); + return iVar2 + param_2; +} + + + +// --- FUN_0040acf0 at 0x0040ACF0 (size: 30) --- + +void __thiscall FUN_0040acf0(int param_1,int param_2) + +{ + int iVar1; + + iVar1 = FUN_0040ac70(*(undefined4 *)(param_1 + 0x18),param_2); + if (iVar1 != 0) { + *(int *)(param_1 + 0x18) = *(int *)(param_1 + 0x18) + param_2; + } + return; +} + + + +// --- FUN_0040ad10 at 0x0040AD10 (size: 128) --- + +void __thiscall FUN_0040ad10(int param_1,uint param_2) + +{ + int iVar1; + int iVar2; + undefined4 *puVar3; + uint uVar4; + uint uVar5; + + if ((*(byte *)(param_1 + 4) & 2) != 0) { + if ((param_2 & 3) == 0) { + uVar5 = 4; + } + else { + if ((param_2 & 3) != 2) { + return; + } + uVar5 = 2; + } + iVar1 = *(int *)(param_1 + 0x18); + iVar2 = FUN_00406d80(); + uVar4 = (uint)(iVar2 + iVar1) % uVar5; + if (uVar4 != 0) { + uVar5 = uVar5 - uVar4; + puVar3 = (undefined4 *)FUN_0040ac70(iVar1,uVar5); + if (puVar3 == (undefined4 *)0x0) { + *(uint *)(param_1 + 4) = *(uint *)(param_1 + 4) | 4; + *(undefined4 *)(param_1 + 8) = 0x80004005; + return; + } + *(int *)(param_1 + 0x18) = *(int *)(param_1 + 0x18) + uVar5; + if ((*(byte *)(param_1 + 4) & 1) != 0) { + for (uVar4 = uVar5 >> 2; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar3 = 0; + puVar3 = puVar3 + 1; + } + for (uVar5 = uVar5 & 3; uVar5 != 0; uVar5 = uVar5 - 1) { + *(undefined1 *)puVar3 = 0; + puVar3 = (undefined4 *)((int)puVar3 + 1); + } + } + } + } + return; +} + + + +// --- FUN_0040ad90 at 0x0040AD90 (size: 151) --- + +undefined4 * __thiscall FUN_0040ad90(undefined4 *param_1,uint param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + uint local_4; + + local_4 = param_2; + param_2 = param_2 & 0xffffff00; + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_0079542c; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_004064a0(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 * 4); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_0040ae30 at 0x0040AE30 (size: 127) --- + +undefined4 * __fastcall FUN_0040ae30(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_00795434; + param_1[2] = 1; + param_1[1] = &PTR_LAB_00793b6c; + FUN_0040ad90(0); + param_1[0x1f] = 0; + param_1[0x20] = 0; + param_1[0x21] = DAT_008377a8; + param_1[0x22] = 0; + param_1[0x23] = 0; + param_1[0x24] = 0; + param_1[0x25] = &PTR_LAB_00795430; + param_1[0x28] = 0; + param_1[0x26] = param_1 + 0x29; + param_1[0x27] = 8; + param_1[0x39] = 1; + return param_1; +} + + + +// --- FUN_0040aec0 at 0x0040AEC0 (size: 43) --- + +int __fastcall FUN_0040aec0(void *param_1) + +{ + int iVar1; + + iVar1 = FUN_00401ea0(); + if ((iVar1 == 0) && (param_1 != (void *)0x0)) { + FUN_004110c0(); + operator_delete(param_1); + } + return iVar1; +} + + + +// --- FUN_0040af20 at 0x0040AF20 (size: 143) --- + +void __fastcall FUN_0040af20(int param_1) + +{ + int iVar1; + int iVar2; + int *piVar3; + void *pvVar4; + void *pvVar5; + void *pvVar6; + int *piVar7; + + iVar1 = *(int *)(param_1 + 0x1c); + if (iVar1 != 0) { + iVar2 = *(int *)(iVar1 + 0x70); + while (iVar2 != 0) { + piVar7 = *(int **)(iVar1 + 0x68); + while (piVar7 != (int *)(*(int *)(iVar1 + 100) + *(int *)(iVar1 + 0x6c) * 4)) { + if (**(int **)(iVar1 + 0x68) != 0) { + piVar7 = *(int **)(iVar1 + 0x68); + pvVar6 = (void *)*piVar7; + goto LAB_0040af64; + } + piVar7 = *(int **)(iVar1 + 0x68) + 1; + *(int **)(iVar1 + 0x68) = piVar7; + } + piVar7 = (int *)0x0; + pvVar6 = (void *)0x0; +LAB_0040af64: + iVar1 = *(int *)(param_1 + 0x1c); + pvVar5 = (void *)*piVar7; + piVar3 = *(int **)((int)pvVar6 + 8); + if (pvVar5 == pvVar6) { +LAB_0040af80: + *piVar7 = *(int *)((int)pvVar5 + 4); + } + else { + do { + pvVar4 = pvVar5; + pvVar5 = *(void **)((int)pvVar4 + 4); + } while (pvVar5 != pvVar6); + if (pvVar4 == (void *)0x0) goto LAB_0040af80; + *(undefined4 *)((int)pvVar4 + 4) = *(undefined4 *)((int)pvVar5 + 4); + } + piVar7 = (int *)(iVar1 + 0x70); + *piVar7 = *piVar7 + -1; + operator_delete(pvVar6); + (**(code **)(*piVar3 + 0x14))(); + iVar1 = *(int *)(param_1 + 0x1c); + iVar2 = *(int *)(iVar1 + 0x70); + } + } + return; +} + + + +// --- FUN_0040afb0 at 0x0040AFB0 (size: 99) --- + +void __thiscall FUN_0040afb0(int *param_1,undefined4 *param_2,undefined4 param_3) + +{ + int iVar1; + + iVar1 = FUN_00406dc0(); + if (iVar1 == 1) { + iVar1 = FUN_00406db0(); + if (iVar1 == 0) goto LAB_0040afe9; + } + FUN_0040af20(); + FUN_00406f90(); + FUN_004070d0(param_3); +LAB_0040afe9: + param_1[1] = param_1[1] & 0xfffffffbU | 1; + param_1[6] = 0; + param_1[2] = 0; + (**(code **)(*param_1 + 0xc))(); + (**(code **)*param_2)(param_1); + return; +} + + + +// --- FUN_0040b020 at 0x0040B020 (size: 64) --- + +void __thiscall FUN_0040b020(int *param_1,undefined4 *param_2,undefined4 param_3) + +{ + FUN_0040af20(); + FUN_00406f90(); + FUN_004070d0(param_3); + param_1[1] = param_1[1] & 0xfffffffa; + param_1[6] = 0; + param_1[2] = 0; + (**(code **)(*param_1 + 0xc))(); + (**(code **)*param_2)(param_1); + return; +} + + + +// --- FUN_0040b060 at 0x0040B060 (size: 73) --- + +void __fastcall FUN_0040b060(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_00793b3c; + FUN_0040af20(); + FUN_00406f90(); + if ((undefined4 *)param_1[7] != (undefined4 *)0x0) { + (*(code *)**(undefined4 **)param_1[7])(1); + } + param_1[7] = 0; + if ((int *)param_1[8] != (int *)0x0) { + (**(code **)(*(int *)param_1[8] + 0x14))(); + param_1[8] = 0; + } + FUN_00406f90(); + return; +} + + + +// --- FUN_0040b0b0 at 0x0040B0B0 (size: 49) --- + +void FUN_0040b0b0(undefined1 *param_1,int param_2) + +{ + undefined1 *puVar1; + + FUN_0040ad10(1); + puVar1 = (undefined1 *)FUN_0040acf0(1); + if (puVar1 != (undefined1 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *puVar1 = *param_1; + return; + } + *param_1 = *puVar1; + } + return; +} + + + +// --- FUN_0040b0f0 at 0x0040B0F0 (size: 83) --- + +undefined4 __thiscall FUN_0040b0f0(undefined4 *param_1,uint param_2) + +{ + int iVar1; + uint uVar2; + undefined4 uVar3; + + if ((int)param_2 < 0) { + FUN_0040b0f0(param_2); + if ((uint)param_1[1] < param_2) { + param_1[1] = 0; + } + else { + param_1[1] = param_1[1] - param_2; + } + } + iVar1 = param_1[1]; + uVar2 = (**(code **)*param_1)(); + if (uVar2 < iVar1 + param_2) { + uVar3 = (**(code **)*param_1)(); + param_1[1] = uVar3; + return 0; + } + param_1[1] = iVar1 + param_2; + return 1; +} + + + +// --- FUN_0040b150 at 0x0040B150 (size: 83) --- + +undefined4 __thiscall FUN_0040b150(undefined4 *param_1,uint param_2) + +{ + int iVar1; + uint uVar2; + undefined4 uVar3; + + if ((int)param_2 < 0) { + FUN_0040b150(param_2); + if ((uint)param_1[1] < param_2) { + param_1[1] = 0; + } + else { + param_1[1] = param_1[1] - param_2; + } + } + iVar1 = param_1[1]; + uVar2 = (**(code **)*param_1)(); + if (uVar2 < iVar1 + param_2) { + uVar3 = (**(code **)*param_1)(); + param_1[1] = uVar3; + return 0; + } + param_1[1] = iVar1 + param_2; + return 1; +} + + + +// --- FUN_0040b1b0 at 0x0040B1B0 (size: 39) --- + +undefined4 __thiscall FUN_0040b1b0(undefined4 *param_1,uint param_2) + +{ + uint uVar1; + undefined4 uVar2; + + uVar1 = (**(code **)*param_1)(); + if (uVar1 < param_2) { + uVar2 = (**(code **)*param_1)(); + param_1[2] = uVar2; + return 0; + } + param_1[2] = param_2; + return 1; +} + + + +// --- FUN_0040b1e0 at 0x0040B1E0 (size: 57) --- + +ushort * FUN_0040b1e0(ushort *param_1,uint param_2,uint param_3) + +{ + ushort uVar1; + bool bVar2; + + uVar1 = *param_1; + bVar2 = false; + while( true ) { + if (uVar1 == 0) { + return (ushort *)0x0; + } + if ((uVar1 == param_2) && (!bVar2)) break; + bVar2 = uVar1 == param_3; + uVar1 = param_1[1]; + param_1 = param_1 + 1; + } + return param_1; +} + + + +// --- FUN_0040b220 at 0x0040B220 (size: 65) --- + +void __fastcall FUN_0040b220(int *param_1) + +{ + undefined *puVar1; + LONG LVar2; + LONG *lpAddend; + + puVar1 = (undefined *)*param_1; + if (puVar1 != PTR_DAT_00818340) { + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818340 + -0x10); + *param_1 = (int)PTR_DAT_00818340; + InterlockedIncrement(lpAddend); + } + return; +} + + + +// --- FUN_0040b270 at 0x0040B270 (size: 171) --- + +uint FUN_0040b270(int *param_1,char *param_2,char param_3) + +{ + char cVar1; + int iVar2; + uint uVar3; + uint uVar4; + char *pcVar5; + char *pcVar6; + + if (param_3 == '\0') { + iVar2 = *param_1; + uVar3 = *(uint *)(iVar2 + -4); + uVar4 = 0; + if (uVar3 != 1 && -1 < (int)(uVar3 - 1)) { + cVar1 = *param_2; + pcVar6 = param_2; + do { + while (cVar1 != '\0') { + pcVar5 = (char *)(iVar2 + -1 + uVar3); + if (uVar4 < uVar3) { + pcVar5 = (char *)(iVar2 + uVar4); + } + if (*pcVar5 == cVar1) { + return uVar4; + } + cVar1 = pcVar6[1]; + pcVar6 = pcVar6 + 1; + } + uVar4 = uVar4 + 1; + cVar1 = *param_2; + pcVar6 = param_2; + } while ((int)uVar4 < (int)(uVar3 - 1)); + } + } + else { + iVar2 = *param_1; + uVar4 = *(uint *)(iVar2 + -4); + uVar3 = uVar4 - 1; + if (0 < (int)uVar3) { + do { + uVar3 = uVar3 - 1; + cVar1 = *param_2; + pcVar6 = param_2; + while (cVar1 != '\0') { + pcVar5 = (char *)(iVar2 + -1 + uVar4); + if (uVar3 < uVar4) { + pcVar5 = (char *)(iVar2 + uVar3); + } + if (*pcVar5 == cVar1) { + return uVar3; + } + pcVar5 = pcVar6 + 1; + pcVar6 = pcVar6 + 1; + cVar1 = *pcVar5; + } + if ((int)uVar3 < 1) { + return 0xffffffff; + } + } while( true ); + } + } + return 0xffffffff; +} + + + +// --- FUN_0040b320 at 0x0040B320 (size: 29) --- + +bool FUN_0040b320(undefined4 *param_1,int param_2) + +{ + int iVar1; + + iVar1 = _access((char *)*param_1,param_2); + return iVar1 == 0; +} + + + +// --- FUN_0040b340 at 0x0040B340 (size: 23) --- + +void FUN_0040b340(void) + +{ + FUN_0040b1e0(); + return; +} + + + +// --- FUN_0040b360 at 0x0040B360 (size: 29) --- + +undefined4 __thiscall FUN_0040b360(int param_1,uint param_2) + +{ + int iVar1; + undefined3 uVar2; + + iVar1 = **(int **)(param_1 + 0xc); + uVar2 = (undefined3)((uint)iVar1 >> 8); + if (*(uint *)(iVar1 + -4) <= param_2) { + return CONCAT31(uVar2,*(undefined1 *)((*(uint *)(iVar1 + -4) - 1) + iVar1)); + } + return CONCAT31(uVar2,*(undefined1 *)(iVar1 + param_2)); +} + + + +// --- FUN_0040b3d0 at 0x0040B3D0 (size: 31) --- + +undefined4 __thiscall FUN_0040b3d0(int param_1,uint param_2) + +{ + int iVar1; + undefined2 uVar2; + + iVar1 = **(int **)(param_1 + 0xc); + uVar2 = (undefined2)((uint)iVar1 >> 0x10); + if (*(uint *)(iVar1 + -4) <= param_2) { + return CONCAT22(uVar2,*(undefined2 *)(iVar1 + -2 + *(uint *)(iVar1 + -4) * 2)); + } + return CONCAT22(uVar2,*(undefined2 *)(iVar1 + param_2 * 2)); +} + + + +// --- FUN_0040b3f0 at 0x0040B3F0 (size: 12) --- + +int __fastcall FUN_0040b3f0(int param_1) + +{ + return *(int *)(**(int **)(param_1 + 0xc) + -4) + -1; +} + + + +// --- FUN_0040b400 at 0x0040B400 (size: 383) --- + +bool FUN_0040b400(undefined4 param_1,int *param_2) + +{ + uint uVar1; + char cVar2; + char cVar3; + uint uVar4; + int iVar5; + uint uVar6; + int iVar7; + int *unaff_retaddr; + + cVar2 = (**(code **)(*param_2 + 8))(param_2[1]); + do { + if (cVar2 == '\0') { + cVar2 = (**(code **)(*unaff_retaddr + 8))(unaff_retaddr[1]); + return cVar2 == '\0'; + } + cVar2 = (**(code **)(*param_2 + 8))(param_2[1]); + if (cVar2 == '*') { + uVar6 = unaff_retaddr[1]; + uVar1 = param_2[1]; + uVar4 = (**(code **)*param_2)(); + if (uVar4 < uVar1 + 1) { + iVar5 = (**(code **)*param_2)(); + param_2[1] = iVar5; + } + else { + param_2[1] = uVar1 + 1; + } + cVar2 = FUN_0040b400(unaff_retaddr,param_2); + if (cVar2 != '\0') { + return true; + } + uVar4 = (**(code **)*unaff_retaddr)(); + if (uVar4 < uVar6) { + iVar5 = (**(code **)*unaff_retaddr)(); + unaff_retaddr[1] = iVar5; + } + else { + unaff_retaddr[1] = uVar6; + } + uVar6 = (**(code **)*param_2)(); + if (uVar6 < uVar1) { + iVar5 = (**(code **)*param_2)(); + param_2[1] = iVar5; + } + else { + param_2[1] = uVar1; + } + iVar5 = unaff_retaddr[1]; + uVar6 = (**(code **)*unaff_retaddr)(); + if (uVar6 < iVar5 + 1U) { + iVar5 = (**(code **)*unaff_retaddr)(); + unaff_retaddr[1] = iVar5; + return false; + } + unaff_retaddr[1] = iVar5 + 1U; + } + else { + cVar2 = (**(code **)(*param_2 + 8))(param_2[1]); + if (cVar2 != '?') { + cVar2 = (**(code **)(*unaff_retaddr + 8))(unaff_retaddr[1]); + cVar3 = (**(code **)(*param_2 + 8))(param_2[1]); + iVar5 = tolower((int)cVar3); + iVar7 = tolower((int)cVar2); + if (iVar5 != iVar7) { + return false; + } + } + iVar5 = unaff_retaddr[1]; + uVar6 = (**(code **)*unaff_retaddr)(); + if (uVar6 < iVar5 + 1U) { + iVar5 = (**(code **)*unaff_retaddr)(); + unaff_retaddr[1] = iVar5; + } + else { + unaff_retaddr[1] = iVar5 + 1U; + } + iVar5 = param_2[1]; + uVar6 = (**(code **)*param_2)(); + if (uVar6 < iVar5 + 1U) { + iVar5 = (**(code **)*param_2)(); + param_2[1] = iVar5; + } + else { + param_2[1] = iVar5 + 1U; + } + } + cVar2 = (**(code **)(*param_2 + 8))(param_2[1]); + } while( true ); +} + + + +// --- FUN_0040b580 at 0x0040B580 (size: 152) --- + +undefined4 __thiscall FUN_0040b580(int *param_1,char param_2,char param_3) + +{ + char cVar1; + int iVar2; + uint uVar3; + char unaff_retaddr; + + if (param_3 == '\0') { + cVar1 = (**(code **)(*param_1 + 8))(param_1[1]); + while( true ) { + if (cVar1 == unaff_retaddr) { + return 1; + } + iVar2 = param_1[1]; + uVar3 = (**(code **)*param_1)(); + if (uVar3 < iVar2 + 1U) { + iVar2 = (**(code **)*param_1)(); + param_1[1] = iVar2; + } + else { + param_1[1] = iVar2 + 1U; + } + cVar1 = (**(code **)(*param_1 + 8))(param_1[1]); + if (cVar1 == '\0') break; + cVar1 = (**(code **)(*param_1 + 8))(param_1[1]); + } + } + else { + while (param_1[1] != 0) { + iVar2 = param_1[1] + -1; + param_1[1] = iVar2; + cVar1 = (**(code **)(*param_1 + 8))(iVar2); + if (cVar1 == param_2) { + return 1; + } + } + param_1[1] = 0; + } + return 0; +} + + + +// --- FUN_0040b620 at 0x0040B620 (size: 158) --- + +undefined4 __thiscall FUN_0040b620(int *param_1,short param_2,char param_3) + +{ + short sVar1; + int iVar2; + uint uVar3; + short unaff_retaddr; + + if (param_3 == '\0') { + sVar1 = (**(code **)(*param_1 + 8))(param_1[1]); + while( true ) { + if (sVar1 == unaff_retaddr) { + return 1; + } + iVar2 = param_1[1]; + uVar3 = (**(code **)*param_1)(); + if (uVar3 < iVar2 + 1U) { + iVar2 = (**(code **)*param_1)(); + param_1[1] = iVar2; + } + else { + param_1[1] = iVar2 + 1U; + } + sVar1 = (**(code **)(*param_1 + 8))(param_1[1]); + if (sVar1 == 0) break; + sVar1 = (**(code **)(*param_1 + 8))(param_1[1]); + } + } + else { + while (param_1[1] != 0) { + iVar2 = param_1[1] + -1; + param_1[1] = iVar2; + sVar1 = (**(code **)(*param_1 + 8))(iVar2); + if (sVar1 == param_2) { + return 1; + } + } + param_1[1] = 0; + } + return 0; +} + + + +// --- FUN_0040b6c0 at 0x0040B6C0 (size: 81) --- + +undefined4 FUN_0040b6c0(int *param_1) + +{ + char cVar1; + int iVar2; + char cVar3; + undefined *puVar4; + + iVar2 = (**(code **)*param_1)(); + param_1[1] = iVar2; + param_1[2] = iVar2; + while( true ) { + if (param_1[1] == 0) { + param_1[1] = 0; + return 0; + } + iVar2 = param_1[1] + -1; + param_1[1] = iVar2; + cVar1 = (**(code **)(*param_1 + 8))(iVar2); + if (cVar1 == '.') break; + puVar4 = &DAT_00795474; + cVar3 = '\\'; + do { + if (cVar3 == cVar1) { + return 0; + } + cVar3 = puVar4[1]; + puVar4 = puVar4 + 1; + } while (cVar3 != '\0'); + } + return 1; +} + + + +// --- FUN_0040b720 at 0x0040B720 (size: 109) --- + +undefined4 __thiscall FUN_0040b720(int param_1,int *param_2) + +{ + int iVar1; + int *piVar2; + + piVar2 = (int *)FUN_005df0f5(0xc); + if (piVar2 == (int *)0x0) { + return 0; + } + iVar1 = *param_2; + *piVar2 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + piVar2[1] = 0; + piVar2[2] = 0; + if (*(int *)(param_1 + 4) == 0) { + *(int *)(param_1 + 0xc) = *(int *)(param_1 + 0xc) + 1; + *(int **)(param_1 + 4) = piVar2; + *(int **)(param_1 + 8) = piVar2; + return 1; + } + iVar1 = *(int *)(param_1 + 8); + *(int **)(iVar1 + 4) = piVar2; + piVar2[2] = iVar1; + *(int *)(param_1 + 0xc) = *(int *)(param_1 + 0xc) + 1; + *(int **)(param_1 + 8) = piVar2; + return 1; +} + + + +// --- FUN_0040b790 at 0x0040B790 (size: 218) --- + +undefined4 __thiscall FUN_0040b790(int *param_1,undefined4 param_2,char param_3) + +{ + char cVar1; + int iVar2; + undefined4 uVar3; + uint uVar4; + undefined4 uVar5; + + if (param_3 == '\0') { + iVar2 = param_1[1]; + uVar3 = (**(code **)(*param_1 + 8))(iVar2,0); + cVar1 = FUN_0040b580(uVar3,iVar2); + while( true ) { + if (cVar1 != '\0') { + return 1; + } + iVar2 = param_1[1]; + uVar4 = (**(code **)*param_1)(); + if (uVar4 < iVar2 + 1U) { + iVar2 = (**(code **)*param_1)(); + param_1[1] = iVar2; + } + else { + param_1[1] = iVar2 + 1U; + } + iVar2 = param_1[1]; + cVar1 = (**(code **)(*param_1 + 8))(iVar2); + if (cVar1 == '\0') break; + uVar3 = (**(code **)(*param_1 + 8))(param_1[1],0); + cVar1 = FUN_0040b580(uVar3,iVar2); + } + } + else { + while (param_1[1] != 0) { + iVar2 = param_1[1] + -1; + uVar5 = 0; + param_1[1] = iVar2; + uVar3 = (**(code **)(*param_1 + 8))(iVar2,0); + cVar1 = FUN_0040b580(uVar3,uVar5); + if (cVar1 != '\0') { + return 1; + } + } + param_1[1] = 0; + } + return 0; +} + + + +// --- FUN_0040b870 at 0x0040B870 (size: 120) --- + +int * __thiscall FUN_0040b870(int *param_1,char param_2) + +{ + undefined4 *puVar1; + LONG *lpAddend; + + if (param_2 == '\0') { + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + return param_1; + } + puVar1 = (undefined4 *)thunk_FUN_005df0f5(0x24); + if (puVar1 != (undefined4 *)0x0) { + puVar1[1] = 1; + *puVar1 = &PTR_LAB_007cae34; + puVar1[4] = 1; + puVar1[2] = 1; + puVar1[3] = 0xffffffff; + *(undefined1 *)(puVar1 + 5) = 0; + *param_1 = (int)(puVar1 + 5); + puVar1[4] = 2; + *(undefined4 *)(*param_1 + -0xc) = 0x10; + } + *(char *)*param_1 = param_2; + *(undefined1 *)(*param_1 + 1) = 0; + return param_1; +} + + + +// --- FUN_0040b8f0 at 0x0040B8F0 (size: 42) --- + +void FUN_0040b8f0(wchar_t *param_1) + +{ + size_t sVar1; + + if ((param_1 != (wchar_t *)0x0) && (*param_1 != L'\0')) { + sVar1 = wcslen(param_1); + FUN_00402490(param_1,sVar1); + } + return; +} + + + +// --- FUN_0040b920 at 0x0040B920 (size: 127) --- + +undefined4 __fastcall FUN_0040b920(int *param_1) + +{ + uint uVar1; + undefined *puVar2; + undefined4 uVar3; + LONG LVar4; + LONG *lpAddend; + int iVar5; + int *unaff_retaddr; + + uVar1 = param_1[2]; + if (uVar1 < (uint)param_1[1]) { + iVar5 = param_1[1] - uVar1; + uVar3 = (**(code **)(*param_1 + 4))(uVar1); + } + else { + iVar5 = uVar1 - param_1[1]; + uVar3 = (**(code **)(*param_1 + 4))(param_1[1]); + } + puVar2 = (undefined *)*unaff_retaddr; + if (puVar2 != PTR_DAT_00818340) { + LVar4 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818340 + -0x10); + *unaff_retaddr = (int)PTR_DAT_00818340; + InterlockedIncrement(lpAddend); + } + if (iVar5 != 0) { + FUN_00402490(uVar3,iVar5); + } + return 1; +} + + + +// --- FUN_0040b9a0 at 0x0040B9A0 (size: 93) --- + +undefined4 * FUN_0040b9a0(undefined4 *param_1) + +{ + undefined *puVar1; + LONG LVar2; + undefined4 *puVar3; + undefined *local_4; + + local_4 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + FUN_0040b920(&local_4); + puVar1 = local_4; + *param_1 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + puVar3 = (undefined4 *)(puVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + return param_1; +} + + + +// --- FUN_0040ba00 at 0x0040BA00 (size: 148) --- + +undefined4 __fastcall FUN_0040ba00(int param_1) + +{ + int iVar1; + int *piVar2; + undefined *puVar3; + LONG LVar4; + LONG *lpAddend; + + iVar1 = **(int **)(param_1 + 0xc); + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + piVar2 = *(int **)(param_1 + 0xc); + puVar3 = (undefined *)*piVar2; + if (puVar3 != PTR_DAT_00818340) { + LVar4 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(puVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar3 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818340 + -0x10); + *piVar2 = (int)PTR_DAT_00818340; + InterlockedIncrement(lpAddend); + } + if (*(int *)(param_1 + 4) != 0) { + FUN_00402490(iVar1,*(int *)(param_1 + 4)); + } + if (*(uint *)(param_1 + 4) < *(uint *)(param_1 + 8)) { + *(uint *)(param_1 + 8) = *(uint *)(param_1 + 4); + } + LVar4 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + return 1; +} + + + +// --- FUN_0040baa0 at 0x0040BAA0 (size: 288) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 FUN_0040baa0(undefined4 param_1,char *param_2) + +{ + char *pcVar1; + undefined4 uVar2; + int iVar3; + ulong uVar4; + undefined1 *puVar5; + char *pcVar6; + char local_10; + char local_f; + undefined1 local_e; + + if ((_DAT_008377d0 & 1) == 0) { + _DAT_008377d0 = _DAT_008377d0 | 1; + _DAT_008377ac = &PTR_FUN_00793b3c; + _DAT_008377b0 = 0; + _DAT_008377b4 = 0; + FUN_00406d60(); + _DAT_008377c4 = 0; + _DAT_008377c8 = 0; + _DAT_008377cc = 0; + _DAT_008377ac = &PTR_FUN_00793b50; + _atexit((_func_4879 *)&LAB_00726b70); + } + uVar2 = FUN_00406d60(); + FUN_0040afb0(&PTR_PTR_008183b8,uVar2); + FUN_00406f90(); + pcVar6 = *(char **)param_2; + pcVar1 = pcVar6 + *(int *)(pcVar6 + -4) + -1; + local_e = 0; + while (pcVar6 < pcVar1) { + iVar3 = isspace((int)*pcVar6); + if (iVar3 == 0) { + local_10 = *pcVar6; + local_f = pcVar6[1]; + pcVar6 = pcVar6 + 2; + uVar4 = strtoul(&local_10,¶m_2,0x10); + FUN_0040ad10(1); + puVar5 = (undefined1 *)FUN_0040acf0(1); + if ((puVar5 != (undefined1 *)0x0) && ((_DAT_008377b0 & 1) != 0)) { + *puVar5 = (char)uVar4; + } + } + else { + pcVar6 = pcVar6 + 1; + } + } + FUN_0040a900(param_1); + return param_1; +} + + + +// --- FUN_0040bbc0 at 0x0040BBC0 (size: 192) --- + +undefined4 * __thiscall FUN_0040bbc0(int *param_1,undefined4 *param_2,int *param_3) + +{ + char cVar1; + undefined *puVar2; + LONG LVar3; + char *pcVar4; + char *pcVar5; + + puVar2 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + LVar3 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + FUN_00401280(*(int *)(*param_3 + -4) + -2 + *(int *)(*param_1 + -4)); + pcVar4 = (char *)*param_1; + pcVar5 = puVar2; + do { + cVar1 = *pcVar4; + *pcVar5 = cVar1; + pcVar4 = pcVar4 + 1; + pcVar5 = pcVar5 + 1; + } while (cVar1 != '\0'); + pcVar5 = (char *)*param_3; + pcVar4 = puVar2 + *(int *)(*param_1 + -4) + -1; + do { + cVar1 = *pcVar5; + *pcVar4 = cVar1; + pcVar5 = pcVar5 + 1; + pcVar4 = pcVar4 + 1; + } while (cVar1 != '\0'); + *param_2 = puVar2; + InterlockedIncrement((LONG *)(puVar2 + -0x10)); + LVar3 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + return param_2; +} + + + +// --- FUN_0040bc80 at 0x0040BC80 (size: 368) --- + +undefined4 FUN_0040bc80(undefined4 param_1,int param_2) + +{ + int iVar1; + undefined *puVar2; + char cVar3; + short sVar4; + undefined4 *puVar5; + uint uVar6; + undefined **ppuVar7; + LONG LVar8; + uint uVar9; + undefined4 *puVar10; + undefined **ppuVar11; + + puVar10 = (undefined4 *)0x0; + ppuVar11 = &PTR_FUN_0079549c; + sVar4 = (*(code *)PTR_FUN_007954a4)(0,&PTR_FUN_0079549c,0,0,param_1); + if (sVar4 != 0) { + while( true ) { + puVar2 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + FUN_0040b620(param_1,0); + cVar3 = FUN_0040b920(&stack0x00000000); + if (cVar3 == '\0') break; + puVar5 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar5 != (undefined4 *)0x0) { + *puVar5 = puVar2; + InterlockedIncrement((LONG *)(puVar2 + -0x10)); + puVar5[1] = 0; + puVar5[2] = 0; + if (*(int *)(param_2 + 4) == 0) { + *(undefined4 **)(param_2 + 4) = puVar5; + } + else { + iVar1 = *(int *)(param_2 + 8); + *(undefined4 **)(iVar1 + 4) = puVar5; + puVar5[2] = iVar1; + } + *(int *)(param_2 + 0xc) = *(int *)(param_2 + 0xc) + 1; + *(undefined4 **)(param_2 + 8) = puVar5; + } + uVar9 = (int)ppuVar11 + 1; + uVar6 = (*(code *)*puVar10)(); + if (uVar6 < uVar9) { + (*(code *)*puVar10)(); + } + ppuVar11 = (undefined **)((int)ppuVar11 + 1); + ppuVar7 = (undefined **)(*(code *)*puVar10)(); + if (ppuVar7 < ppuVar11) { + ppuVar11 = (undefined **)(*(code *)*puVar10)(); + } + LVar8 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar8 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + sVar4 = (*(code *)puVar10[2])(ppuVar11); + if (sVar4 == 0) { + return 1; + } + } + LVar8 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar8 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + } + return 1; +} + + + +// --- FUN_0040bdf0 at 0x0040BDF0 (size: 317) --- + +undefined4 __thiscall FUN_0040bdf0(int param_1,int *param_2) + +{ + uint uVar1; + int iVar2; + int *piVar3; + undefined *puVar4; + LONG LVar5; + size_t sVar6; + int iVar7; + short *psVar8; + LONG *lpAddend; + uint uVar9; + wchar_t *_Str; + uint local_4; + + uVar1 = *(uint *)(param_1 + 4); + local_4 = *(uint *)(param_1 + 8); + uVar9 = uVar1; + if (uVar1 < local_4) { + uVar9 = local_4; + local_4 = uVar1; + } + iVar2 = **(int **)(param_1 + 0xc); + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + piVar3 = *(int **)(param_1 + 0xc); + puVar4 = (undefined *)*piVar3; + if (puVar4 != PTR_DAT_00818340) { + LVar5 = InterlockedDecrement((LONG *)(puVar4 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(puVar4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar4 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818340 + -0x10); + *piVar3 = (int)PTR_DAT_00818340; + InterlockedIncrement(lpAddend); + } + if (local_4 != 0) { + FUN_00402490(iVar2,local_4); + } + iVar7 = *(int *)(*param_2 + -4); + if (iVar7 != 1) { + FUN_00402490(*param_2,iVar7 + -1); + } + uVar1 = *(uint *)(iVar2 + -4); + psVar8 = (short *)(iVar2 + -2 + uVar1 * 2); + if (uVar9 < uVar1) { + psVar8 = (short *)(iVar2 + uVar9 * 2); + } + if (*psVar8 != 0) { + _Str = (wchar_t *)(iVar2 + -2 + uVar1 * 2); + if (uVar9 < uVar1) { + _Str = (wchar_t *)(iVar2 + uVar9 * 2); + } + if ((_Str != (wchar_t *)0x0) && (*_Str != L'\0')) { + sVar6 = wcslen(_Str); + FUN_00402490(_Str,sVar6); + } + } + iVar7 = *(int *)(*param_2 + -4) + -1; + if (*(uint *)(param_1 + 4) == uVar9) { + *(uint *)(param_1 + 4) = (*(uint *)(param_1 + 4) - (uVar9 - local_4)) + iVar7; + } + else { + *(int *)(param_1 + 8) = *(int *)(param_1 + 8) + (iVar7 - (uVar9 - local_4)); + } + LVar5 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + return 1; +} + + + +// --- FUN_0040bf30 at 0x0040BF30 (size: 127) --- + +undefined4 __fastcall FUN_0040bf30(int *param_1) + +{ + uint uVar1; + undefined *puVar2; + undefined4 uVar3; + LONG LVar4; + LONG *lpAddend; + int iVar5; + int *unaff_retaddr; + + uVar1 = param_1[2]; + if (uVar1 < (uint)param_1[1]) { + iVar5 = param_1[1] - uVar1; + uVar3 = (**(code **)(*param_1 + 4))(uVar1); + } + else { + iVar5 = uVar1 - param_1[1]; + uVar3 = (**(code **)(*param_1 + 4))(param_1[1]); + } + puVar2 = (undefined *)*unaff_retaddr; + if (puVar2 != PTR_DAT_00818344) { + LVar4 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *unaff_retaddr = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + if (iVar5 != 0) { + FUN_00404ef0(uVar3,iVar5); + } + return 1; +} + + + +// --- FUN_0040bfb0 at 0x0040BFB0 (size: 93) --- + +undefined4 * FUN_0040bfb0(undefined4 *param_1) + +{ + undefined *puVar1; + LONG LVar2; + undefined4 *puVar3; + undefined *local_4; + + local_4 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_0040bf30(&local_4); + puVar1 = local_4; + *param_1 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + puVar3 = (undefined4 *)(puVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + return param_1; +} + + + +// --- FUN_0040c010 at 0x0040C010 (size: 148) --- + +undefined4 __fastcall FUN_0040c010(int param_1) + +{ + int iVar1; + int *piVar2; + undefined *puVar3; + LONG LVar4; + LONG *lpAddend; + + iVar1 = **(int **)(param_1 + 0xc); + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + piVar2 = *(int **)(param_1 + 0xc); + puVar3 = (undefined *)*piVar2; + if (puVar3 != PTR_DAT_00818344) { + LVar4 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(puVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar3 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *piVar2 = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + if (*(int *)(param_1 + 4) != 0) { + FUN_00404ef0(iVar1,*(int *)(param_1 + 4)); + } + if (*(uint *)(param_1 + 4) < *(uint *)(param_1 + 8)) { + *(uint *)(param_1 + 8) = *(uint *)(param_1 + 4); + } + LVar4 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + return 1; +} + + + +// --- FUN_0040c0b0 at 0x0040C0B0 (size: 208) --- + +undefined4 __fastcall FUN_0040c0b0(int param_1) + +{ + char cVar1; + int iVar2; + int *piVar3; + undefined *puVar4; + uint uVar5; + LONG LVar6; + char *pcVar7; + char *pcVar8; + LONG *lpAddend; + + if (*(int *)(param_1 + 4) != 0) { + iVar2 = **(int **)(param_1 + 0xc); + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + piVar3 = *(int **)(param_1 + 0xc); + puVar4 = (undefined *)*piVar3; + if (puVar4 != PTR_DAT_00818344) { + LVar6 = InterlockedDecrement((LONG *)(puVar4 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar4 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *piVar3 = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + uVar5 = *(uint *)(iVar2 + -4) - 1; + if (*(uint *)(param_1 + 4) < *(uint *)(iVar2 + -4)) { + uVar5 = *(uint *)(param_1 + 4); + } + pcVar8 = (char *)(uVar5 + iVar2); + if ((pcVar8 != (char *)0x0) && (*pcVar8 != '\0')) { + pcVar7 = pcVar8; + do { + cVar1 = *pcVar7; + pcVar7 = pcVar7 + 1; + } while (cVar1 != '\0'); + FUN_00404ef0(pcVar8,(int)pcVar7 - (int)(pcVar8 + 1)); + } + if (*(uint *)(param_1 + 8) < *(uint *)(param_1 + 4)) { + *(undefined4 *)(param_1 + 8) = 0; + } + else { + *(uint *)(param_1 + 8) = *(uint *)(param_1 + 8) - *(uint *)(param_1 + 4); + } + *(undefined4 *)(param_1 + 4) = 0; + LVar6 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + } + return 1; +} + + + +// --- FUN_0040c180 at 0x0040C180 (size: 148) --- + +undefined4 __thiscall FUN_0040c180(int param_1,int *param_2) + +{ + int *piVar1; + int iVar2; + LONG LVar3; + undefined4 *puVar4; + + piVar1 = *(int **)(param_1 + 4); + if (piVar1 == (int *)0x0) { + return 0; + } + iVar2 = piVar1[1]; + *(int *)(param_1 + 4) = iVar2; + if (iVar2 == 0) { + *(undefined4 *)(param_1 + 8) = 0; + } + else { + *(undefined4 *)(iVar2 + 8) = 0; + } + iVar2 = *param_2; + if (iVar2 != *piVar1) { + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar2 = *piVar1; + *param_2 = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + } + puVar4 = (undefined4 *)(*piVar1 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(*piVar1 + -0x10)); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + operator_delete(piVar1); + *(int *)(param_1 + 0xc) = *(int *)(param_1 + 0xc) + -1; + return 1; +} + + + +// --- thunk_FUN_0040bc80 at 0x0040C220 (size: 5) --- + +undefined4 thunk_FUN_0040bc80(undefined4 param_1,int param_2) + +{ + int iVar1; + undefined *puVar2; + char cVar3; + short sVar4; + undefined4 *puVar5; + uint uVar6; + undefined **ppuVar7; + LONG LVar8; + uint uVar9; + undefined4 *puVar10; + undefined **ppuVar11; + + puVar10 = (undefined4 *)0x0; + ppuVar11 = &PTR_FUN_0079549c; + sVar4 = (*(code *)PTR_FUN_007954a4)(0,&PTR_FUN_0079549c,0,0,param_1); + if (sVar4 != 0) { + while( true ) { + puVar2 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + FUN_0040b620(param_1,0); + cVar3 = FUN_0040b920(&stack0x00000000); + if (cVar3 == '\0') break; + puVar5 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar5 != (undefined4 *)0x0) { + *puVar5 = puVar2; + InterlockedIncrement((LONG *)(puVar2 + -0x10)); + puVar5[1] = 0; + puVar5[2] = 0; + if (*(int *)(param_2 + 4) == 0) { + *(undefined4 **)(param_2 + 4) = puVar5; + } + else { + iVar1 = *(int *)(param_2 + 8); + *(undefined4 **)(iVar1 + 4) = puVar5; + puVar5[2] = iVar1; + } + *(int *)(param_2 + 0xc) = *(int *)(param_2 + 0xc) + 1; + *(undefined4 **)(param_2 + 8) = puVar5; + } + uVar9 = (int)ppuVar11 + 1; + uVar6 = (*(code *)*puVar10)(); + if (uVar6 < uVar9) { + (*(code *)*puVar10)(); + } + ppuVar11 = (undefined **)((int)ppuVar11 + 1); + ppuVar7 = (undefined **)(*(code *)*puVar10)(); + if (ppuVar7 < ppuVar11) { + ppuVar11 = (undefined **)(*(code *)*puVar10)(); + } + LVar8 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar8 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + sVar4 = (*(code *)puVar10[2])(ppuVar11); + if (sVar4 == 0) { + return 1; + } + } + LVar8 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar8 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + } + return 1; +} + + + +// --- FUN_0040c230 at 0x0040C230 (size: 59) --- + +undefined4 FUN_0040c230(undefined4 param_1) + +{ + CHAR local_104 [260]; + + local_104[0] = '\0'; + GetModuleFileNameA((HMODULE)0x0,local_104,0x104); + FUN_00401340(local_104); + return param_1; +} + + + +// --- FUN_0040c270 at 0x0040C270 (size: 88) --- + +/* WARNING: Function: __chkstk replaced with injection: alloca_probe */ +/* WARNING: Unable to track spacebase fully for stack */ + +undefined4 FUN_0040c270(undefined4 *param_1) + +{ + undefined4 uVar1; + int iVar2; + uint uVar3; + uint uVar4; + undefined1 *puVar5; + undefined4 auStack_2c [2]; + undefined1 auStack_24 [4]; + uint uStack_20; + undefined4 uStack_1c; + undefined4 uStack_18; + undefined4 uStack_14; + + uStack_1c = *param_1; + uStack_14 = 0; + uStack_18 = 0; + uStack_20 = 0x40c286; + uVar3 = (*(code *)PTR_FUN_00837384)(); + if (uVar3 != 0) { + uStack_20 = 0x40c29a; + iVar2 = -(uVar3 * 2 + 5 & 0xfffffffc); + uVar1 = *param_1; + *(uint *)((int)&uStack_20 + iVar2) = uVar3; + *(int *)(auStack_24 + iVar2) = (int)&uStack_1c + iVar2; + *(undefined4 *)((int)auStack_2c + iVar2 + 4) = uVar1; + puVar5 = (undefined1 *)((int)auStack_2c + iVar2); + *(undefined4 *)((int)auStack_2c + iVar2) = 0x40c2a7; + uVar4 = (*(code *)PTR_FUN_00837384)(); + if (uVar4 < uVar3) { + *(int *)((int)puVar5 + -4) = (int)&uStack_1c + iVar2; + *(undefined4 *)(puVar5 + -8) = 0x40c2be; + FUN_00407e40(); + return 1; + } + } + return 0; +} + + + +// --- FUN_0040c2d0 at 0x0040C2D0 (size: 367) --- + +undefined4 FUN_0040c2d0(undefined4 param_1,int param_2) + +{ + int iVar1; + undefined *puVar2; + char cVar3; + undefined4 *puVar4; + uint uVar5; + undefined **ppuVar6; + LONG LVar7; + uint uVar8; + undefined4 *puVar9; + undefined **ppuVar10; + + puVar9 = (undefined4 *)0x0; + ppuVar10 = &PTR_FUN_0079548c; + cVar3 = (*(code *)PTR_FUN_00795494)(0,&PTR_FUN_0079548c,0,0,param_1); + if (cVar3 != '\0') { + while( true ) { + puVar2 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_0040b580(param_1,0); + cVar3 = FUN_0040bf30(&stack0x00000000); + if (cVar3 == '\0') break; + puVar4 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar4 != (undefined4 *)0x0) { + *puVar4 = puVar2; + InterlockedIncrement((LONG *)(puVar2 + -0x10)); + puVar4[1] = 0; + puVar4[2] = 0; + if (*(int *)(param_2 + 4) == 0) { + *(undefined4 **)(param_2 + 4) = puVar4; + } + else { + iVar1 = *(int *)(param_2 + 8); + *(undefined4 **)(iVar1 + 4) = puVar4; + puVar4[2] = iVar1; + } + *(int *)(param_2 + 0xc) = *(int *)(param_2 + 0xc) + 1; + *(undefined4 **)(param_2 + 8) = puVar4; + } + uVar8 = (int)ppuVar10 + 1; + uVar5 = (*(code *)*puVar9)(); + if (uVar5 < uVar8) { + (*(code *)*puVar9)(); + } + ppuVar10 = (undefined **)((int)ppuVar10 + 1); + ppuVar6 = (undefined **)(*(code *)*puVar9)(); + if (ppuVar6 < ppuVar10) { + ppuVar10 = (undefined **)(*(code *)*puVar9)(); + } + LVar7 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar7 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + cVar3 = (*(code *)puVar9[2])(ppuVar10); + if (cVar3 == '\0') { + return 1; + } + } + LVar7 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar7 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + } + return 1; +} + + + +// --- FUN_0040c440 at 0x0040C440 (size: 120) --- + +undefined1 __thiscall FUN_0040c440(int *param_1,int *param_2) + +{ + int *piVar1; + int iVar2; + char cVar3; + undefined4 uVar4; + LONG LVar5; + + if ((param_1[1] & 0x7fffffffU) <= (uint)param_1[2]) { + uVar4 = FUN_004077f0((param_1[1] & 0x7fffffffU) + 1); + cVar3 = FUN_004082c0(uVar4); + if (cVar3 == '\0') { + return 0; + } + } + piVar1 = (int *)(*param_1 + param_1[2] * 4); + iVar2 = *piVar1; + if (iVar2 != *param_2) { + LVar5 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar2 = *param_2; + *piVar1 = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + } + param_1[2] = param_1[2] + 1; + return 1; +} + + + +// --- FUN_0040c4c0 at 0x0040C4C0 (size: 390) --- + +undefined4 __thiscall FUN_0040c4c0(int *param_1,int param_2) + +{ + uint uVar1; + int iVar2; + undefined4 uVar3; + LONG LVar4; + int iVar5; + uint uVar6; + undefined4 *puVar7; + bool bVar8; + uint uStack_8; + int iStack_4; + + iVar2 = (**(code **)(*param_1 + 0xc))(); + if (iVar2 != 0) { + uVar1 = param_1[1]; + uStack_8 = param_1[2]; + bVar8 = uStack_8 < uVar1; + uVar6 = uVar1; + if ((uVar1 < uStack_8) || (uVar6 = uStack_8, uStack_8 = uVar1, bVar8)) { + uVar3 = FUN_00404f80(&iStack_4,0,uVar6 - 1); + FUN_00402070(uVar3); + LVar4 = InterlockedDecrement((LONG *)(iStack_4 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(iStack_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iStack_4 + -0x14))(1); + } + uVar3 = FUN_00404f80(¶m_2,uVar6,uStack_8 - 1); + FUN_00402070(uVar3); + puVar7 = (undefined4 *)(param_2 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar4 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + uVar3 = (**(code **)*param_1)(); + uVar3 = FUN_00404f80(¶m_2,uStack_8,uVar3); + FUN_00402070(uVar3); + iVar2 = param_2; + iVar5 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + } + else { + uVar3 = FUN_00404f80(&iStack_4,0,uVar1 - 1); + FUN_00402070(uVar3); + LVar4 = InterlockedDecrement((LONG *)(iStack_4 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(iStack_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iStack_4 + -0x14))(1); + } + FUN_00404cd0(); + uVar3 = (**(code **)*param_1)(); + uVar3 = FUN_00404f80(¶m_2,param_1[1],uVar3); + FUN_00402070(uVar3); + iVar2 = param_2; + iVar5 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + } + if ((iVar5 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + return 1; + } + return 0; +} + + + +// --- FUN_0040c650 at 0x0040C650 (size: 194) --- + +undefined4 FUN_0040c650(int *param_1,int *param_2) + +{ + uint uVar1; + uint uVar2; + int iVar3; + int *piVar4; + int *piVar5; + char cVar6; + undefined *puVar7; + char *pcVar8; + undefined **local_10; + undefined4 local_c; + undefined4 local_8; + int *local_4; + + piVar4 = param_1; + local_10 = &PTR_FUN_0079548c; + local_4 = param_1; + local_c = 0; + local_8 = 0; + cVar6 = FUN_0040b6c0(&local_10); + if (cVar6 != '\0') { + FUN_0040c010(); + } + piVar5 = param_2; + uVar2 = *(uint *)(*piVar4 + -4); + uVar1 = uVar2 - 2; + if (uVar2 <= uVar1) { + uVar1 = uVar2 - 1; + } + cVar6 = '\\'; + puVar7 = &DAT_00795474; + do { + if (cVar6 == *(char *)(uVar1 + *piVar4)) { + return 0; + } + cVar6 = puVar7[1]; + puVar7 = puVar7 + 1; + } while (cVar6 != '\0'); + pcVar8 = (char *)*param_2; + if (*(int *)(pcVar8 + -4) != 1) { + if (*(int *)(pcVar8 + -4) == 0) { + pcVar8 = pcVar8 + -1; + } + if (*pcVar8 != '.') { + param_1 = (int *)CONCAT31(param_1._1_3_,0x2e); + FUN_00404ef0(¶m_1,1); + } + } + iVar3 = *(int *)(*piVar5 + -4); + if (iVar3 != 1) { + FUN_00404ef0(*piVar5,iVar3 + -1); + } + return 1; +} + + + +// --- FUN_0040c720 at 0x0040C720 (size: 82) --- + +undefined4 FUN_0040c720(undefined4 param_1) + +{ + int iVar1; + + iVar1 = FUN_0040b270(param_1,&DAT_00795474,1,&PTR_FUN_0079548c,0,0,param_1); + if (-1 < iVar1) { + FUN_0040b0f0(iVar1 + 1); + FUN_0040c0b0(); + } + return 1; +} + + + +// --- FUN_0040c780 at 0x0040C780 (size: 177) --- + +undefined4 FUN_0040c780(int *param_1,undefined4 param_2) + +{ + undefined *puVar1; + int iVar2; + LONG LVar3; + LONG *lpAddend; + + iVar2 = FUN_0040b270(param_2,&DAT_00795474,1,&PTR_FUN_0079548c,0,0,param_2); + if (-1 < iVar2) { + FUN_0040b0f0(iVar2 + 1); + FUN_0040bf30(param_1); + return 1; + } + puVar1 = (undefined *)*param_1; + if (puVar1 != PTR_DAT_00818344) { + LVar3 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + return 1; +} + + + +// --- FUN_0040c840 at 0x0040C840 (size: 94) --- + +undefined4 * FUN_0040c840(undefined4 *param_1,undefined4 param_2) + +{ + char cVar1; + LONG *lpAddend; + undefined **local_10; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + local_4 = param_2; + local_10 = &PTR_FUN_0079548c; + local_c = 0; + local_8 = 0; + cVar1 = FUN_0040b6c0(&local_10); + if (cVar1 != '\0') { + FUN_0040bfb0(param_1); + return param_1; + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + return param_1; +} + + + +// --- FUN_0040c8a0 at 0x0040C8A0 (size: 253) --- + +undefined4 __thiscall FUN_0040c8a0(int param_1,int *param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + undefined *puVar4; + int iVar5; + LONG LVar6; + char *pcVar7; + LONG *lpAddend; + char *pcVar8; + + if (*(int *)(*param_2 + -4) != 1) { + iVar2 = **(int **)(param_1 + 0xc); + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + piVar3 = *(int **)(param_1 + 0xc); + puVar4 = (undefined *)*piVar3; + if (puVar4 != PTR_DAT_00818344) { + LVar6 = InterlockedDecrement((LONG *)(puVar4 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar4 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *piVar3 = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + if (*(int *)(param_1 + 4) != 0) { + FUN_00404ef0(iVar2,*(int *)(param_1 + 4)); + } + iVar5 = *(int *)(*param_2 + -4); + if (iVar5 != 1) { + FUN_00404ef0(*param_2,iVar5 + -1); + } + pcVar8 = (char *)(*(int *)(param_1 + 4) + iVar2); + if ((pcVar8 != (char *)0x0) && (*pcVar8 != '\0')) { + pcVar7 = pcVar8; + do { + cVar1 = *pcVar7; + pcVar7 = pcVar7 + 1; + } while (cVar1 != '\0'); + FUN_00404ef0(pcVar8,(int)pcVar7 - (int)(pcVar8 + 1)); + } + if (*(uint *)(param_1 + 4) <= *(uint *)(param_1 + 8)) { + *(uint *)(param_1 + 8) = *(int *)(*param_2 + -4) + -1 + *(uint *)(param_1 + 8); + } + *(uint *)(param_1 + 4) = *(int *)(*param_2 + -4) + -1 + *(uint *)(param_1 + 4); + LVar6 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + } + return 1; +} + + + +// --- FUN_0040c9a0 at 0x0040C9A0 (size: 314) --- + +undefined4 __thiscall FUN_0040c9a0(int param_1,int *param_2) + +{ + char cVar1; + uint uVar2; + int iVar3; + int *piVar4; + undefined *puVar5; + uint uVar6; + LONG LVar7; + char *pcVar8; + int iVar9; + char *pcVar10; + LONG *lpAddend; + uint uVar11; + uint local_4; + + uVar2 = *(uint *)(param_1 + 4); + local_4 = *(uint *)(param_1 + 8); + uVar11 = uVar2; + if (uVar2 < local_4) { + uVar11 = local_4; + local_4 = uVar2; + } + iVar3 = **(int **)(param_1 + 0xc); + InterlockedIncrement((LONG *)(iVar3 + -0x10)); + piVar4 = *(int **)(param_1 + 0xc); + puVar5 = (undefined *)*piVar4; + if (puVar5 != PTR_DAT_00818344) { + LVar7 = InterlockedDecrement((LONG *)(puVar5 + -0x10)); + if ((LVar7 == 0) && ((undefined4 *)(puVar5 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar5 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *piVar4 = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + if (local_4 != 0) { + FUN_00404ef0(iVar3,local_4); + } + iVar9 = *(int *)(*param_2 + -4); + if (iVar9 != 1) { + FUN_00404ef0(*param_2,iVar9 + -1); + } + uVar2 = *(uint *)(iVar3 + -4); + uVar6 = uVar2 - 1; + if (uVar11 < uVar2) { + uVar6 = uVar11; + } + if (*(char *)(uVar6 + iVar3) != '\0') { + uVar6 = uVar2 - 1; + if (uVar11 < uVar2) { + uVar6 = uVar11; + } + pcVar10 = (char *)(uVar6 + iVar3); + if ((pcVar10 != (char *)0x0) && (*pcVar10 != '\0')) { + pcVar8 = pcVar10; + do { + cVar1 = *pcVar8; + pcVar8 = pcVar8 + 1; + } while (cVar1 != '\0'); + FUN_00404ef0(pcVar10,(int)pcVar8 - (int)(pcVar10 + 1)); + } + } + iVar9 = *(int *)(*param_2 + -4) + -1; + if (*(uint *)(param_1 + 4) == uVar11) { + *(uint *)(param_1 + 4) = (*(uint *)(param_1 + 4) - (uVar11 - local_4)) + iVar9; + } + else { + *(int *)(param_1 + 8) = *(int *)(param_1 + 8) + (iVar9 - (uVar11 - local_4)); + } + LVar7 = InterlockedDecrement((LONG *)(iVar3 + -0x10)); + if ((LVar7 == 0) && ((undefined4 *)(iVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar3 + -0x14))(1); + } + return 1; +} + + + +// --- thunk_FUN_0040c2d0 at 0x0040CAE0 (size: 5) --- + +undefined4 thunk_FUN_0040c2d0(undefined4 param_1,int param_2) + +{ + int iVar1; + undefined *puVar2; + char cVar3; + undefined4 *puVar4; + uint uVar5; + undefined **ppuVar6; + LONG LVar7; + uint uVar8; + undefined4 *puVar9; + undefined **ppuVar10; + + puVar9 = (undefined4 *)0x0; + ppuVar10 = &PTR_FUN_0079548c; + cVar3 = (*(code *)PTR_FUN_00795494)(0,&PTR_FUN_0079548c,0,0,param_1); + if (cVar3 != '\0') { + while( true ) { + puVar2 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_0040b580(param_1,0); + cVar3 = FUN_0040bf30(&stack0x00000000); + if (cVar3 == '\0') break; + puVar4 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar4 != (undefined4 *)0x0) { + *puVar4 = puVar2; + InterlockedIncrement((LONG *)(puVar2 + -0x10)); + puVar4[1] = 0; + puVar4[2] = 0; + if (*(int *)(param_2 + 4) == 0) { + *(undefined4 **)(param_2 + 4) = puVar4; + } + else { + iVar1 = *(int *)(param_2 + 8); + *(undefined4 **)(iVar1 + 4) = puVar4; + puVar4[2] = iVar1; + } + *(int *)(param_2 + 0xc) = *(int *)(param_2 + 0xc) + 1; + *(undefined4 **)(param_2 + 8) = puVar4; + } + uVar8 = (int)ppuVar10 + 1; + uVar5 = (*(code *)*puVar9)(); + if (uVar5 < uVar8) { + (*(code *)*puVar9)(); + } + ppuVar10 = (undefined **)((int)ppuVar10 + 1); + ppuVar6 = (undefined **)(*(code *)*puVar9)(); + if (ppuVar6 < ppuVar10) { + ppuVar10 = (undefined **)(*(code *)*puVar9)(); + } + LVar7 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar7 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + cVar3 = (*(code *)puVar9[2])(ppuVar10); + if (cVar3 == '\0') { + return 1; + } + } + LVar7 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar7 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + } + return 1; +} + + + +// --- FUN_0040caf0 at 0x0040CAF0 (size: 125) --- + +undefined4 FUN_0040caf0(undefined *param_1,int param_2) + +{ + uint uVar1; + uint uVar2; + undefined *puVar3; + int iVar4; + LONG LVar5; + int iVar6; + + iVar6 = param_2; + uVar2 = (uint)param_1; + puVar3 = PTR_DAT_00818344; + uVar1 = (int)param_1 + param_2; + param_1 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + for (; uVar2 < uVar1; uVar2 = uVar2 + 1 + iVar4) { + iVar4 = FUN_00402710(¶m_1,&DAT_007954d8,iVar6,uVar2); + iVar6 = iVar6 - iVar4; + FUN_0040c440(¶m_1); + puVar3 = param_1; + } + LVar5 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(puVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar3 + -0x14))(1); + } + return 1; +} + + + +// --- FUN_0040cb70 at 0x0040CB70 (size: 261) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_0040cb70(int *param_1,int *param_2) + +{ + uint uVar1; + int iVar2; + int iVar3; + int *piVar4; + int *piVar5; + LONG LVar6; + char *pcVar7; + + piVar4 = param_2; + if (*(int *)(*param_2 + -4) != 1) { + if ((_DAT_008377d8 & 1) == 0) { + _DAT_008377d8 = _DAT_008377d8 | 1; + piVar5 = (int *)FUN_00401340(&DAT_00795470); + DAT_008377d4 = *piVar5; + InterlockedIncrement((LONG *)(DAT_008377d4 + -0x10)); + piVar5 = param_2 + -5; + LVar6 = InterlockedDecrement(param_2 + -4); + if ((LVar6 == 0) && (piVar5 != (int *)0x0)) { + (**(code **)*piVar5)(1); + } + _atexit((_func_4879 *)&LAB_00726be0); + } + iVar2 = *param_1; + if (*(int *)(iVar2 + -4) == 1) { + FUN_00405000(&DAT_007954e0); + } + else { + uVar1 = *(uint *)(iVar2 + -4) - 2; + if (*(uint *)(iVar2 + -4) <= uVar1) { + uVar1 = *(int *)(iVar2 + -4) - 1; + } + pcVar7 = strchr((char *)DAT_008377d4,(int)*(char *)(uVar1 + iVar2)); + if (pcVar7 == (char *)0x0) { + pcVar7 = (char *)*piVar4; + if (*(int *)(pcVar7 + -4) == 0) { + pcVar7 = pcVar7 + -1; + } + pcVar7 = strchr((char *)DAT_008377d4,(int)*pcVar7); + if (pcVar7 == (char *)0x0) { + param_2 = (int *)CONCAT31(param_2._1_3_,0x2f); + FUN_00404ef0(¶m_2,1); + } + } + } + iVar2 = *piVar4; + iVar3 = *(int *)(iVar2 + -4); + if (iVar3 != 1) { + FUN_00404ef0(iVar2,iVar3 + -1); + } + } + return; +} + + + +// --- FUN_0040cc80 at 0x0040CC80 (size: 262) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_0040cc80(int *param_1,int *param_2) + +{ + uint uVar1; + int iVar2; + int iVar3; + int *piVar4; + LONG LVar5; + wchar_t *pwVar6; + int *piVar7; + undefined4 *puVar8; + undefined4 uVar9; + + piVar4 = param_2; + if (*(int *)(*param_2 + -4) != 1) { + if ((_DAT_008377e0 & 1) == 0) { + _DAT_008377e0 = _DAT_008377e0 | 1; + uVar9 = 0; + puVar8 = &DAT_008377dc; + FUN_00401340(&DAT_00795470); + FUN_00403350(puVar8,uVar9); + piVar7 = param_2 + -5; + LVar5 = InterlockedDecrement(param_2 + -4); + if ((LVar5 == 0) && (piVar7 != (int *)0x0)) { + (**(code **)*piVar7)(1); + } + _atexit((_func_4879 *)&LAB_00726c10); + } + iVar2 = *param_1; + if (*(int *)(iVar2 + -4) == 1) { + FUN_00407e40(&DAT_007954e4); + } + else { + uVar1 = *(uint *)(iVar2 + -4) - 2; + if (uVar1 < *(uint *)(iVar2 + -4)) { + pwVar6 = (wchar_t *)(iVar2 + uVar1 * 2); + } + else { + pwVar6 = (wchar_t *)(iVar2 + -2 + *(int *)(iVar2 + -4) * 2); + } + pwVar6 = wcschr(DAT_008377dc,*pwVar6); + if (pwVar6 == (wchar_t *)0x0) { + pwVar6 = (wchar_t *)*piVar4; + if (*(int *)(pwVar6 + -2) == 0) { + pwVar6 = pwVar6 + -1; + } + pwVar6 = wcschr(DAT_008377dc,*pwVar6); + if (pwVar6 == (wchar_t *)0x0) { + param_2 = (int *)0x2f; + FUN_00402490(¶m_2,1); + } + } + } + iVar2 = *piVar4; + iVar3 = *(int *)(iVar2 + -4); + if (iVar3 != 1) { + FUN_00402490(iVar2,iVar3 + -1); + } + } + return; +} + + + +// --- thunk_FUN_0040c650 at 0x0040CD90 (size: 5) --- + +undefined4 thunk_FUN_0040c650(int *param_1,int *param_2) + +{ + uint uVar1; + uint uVar2; + int iVar3; + int *piVar4; + int *piVar5; + char cVar6; + undefined *puVar7; + char *pcVar8; + undefined **ppuStack_10; + undefined4 uStack_c; + undefined4 uStack_8; + int *piStack_4; + + piVar4 = param_1; + ppuStack_10 = &PTR_FUN_0079548c; + piStack_4 = param_1; + uStack_c = 0; + uStack_8 = 0; + cVar6 = FUN_0040b6c0(&ppuStack_10); + if (cVar6 != '\0') { + FUN_0040c010(); + } + piVar5 = param_2; + uVar2 = *(uint *)(*piVar4 + -4); + uVar1 = uVar2 - 2; + if (uVar2 <= uVar1) { + uVar1 = uVar2 - 1; + } + cVar6 = '\\'; + puVar7 = &DAT_00795474; + do { + if (cVar6 == *(char *)(uVar1 + *piVar4)) { + return 0; + } + cVar6 = puVar7[1]; + puVar7 = puVar7 + 1; + } while (cVar6 != '\0'); + pcVar8 = (char *)*param_2; + if (*(int *)(pcVar8 + -4) != 1) { + if (*(int *)(pcVar8 + -4) == 0) { + pcVar8 = pcVar8 + -1; + } + if (*pcVar8 != '.') { + param_1 = (int *)CONCAT31(param_1._1_3_,0x2e); + FUN_00404ef0(¶m_1,1); + } + } + iVar3 = *(int *)(*piVar5 + -4); + if (iVar3 != 1) { + FUN_00404ef0(*piVar5,iVar3 + -1); + } + return 1; +} + + + +// --- FUN_0040cda0 at 0x0040CDA0 (size: 59) --- + +undefined4 FUN_0040cda0(undefined4 param_1) + +{ + char cVar1; + undefined **local_10; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + local_4 = param_1; + local_10 = &PTR_FUN_0079548c; + local_c = 0; + local_8 = 0; + cVar1 = FUN_0040b6c0(&local_10); + if (cVar1 != '\0') { + FUN_0040c010(); + } + return 1; +} + + + +// --- thunk_FUN_0040c720 at 0x0040CDE0 (size: 5) --- + +undefined4 thunk_FUN_0040c720(undefined4 param_1) + +{ + int iVar1; + + iVar1 = FUN_0040b270(param_1,&DAT_00795474,1,&PTR_FUN_0079548c,0,0,param_1); + if (-1 < iVar1) { + FUN_0040b0f0(iVar1 + 1); + FUN_0040c0b0(); + } + return 1; +} + + + +// --- thunk_FUN_0040c780 at 0x0040CDF0 (size: 5) --- + +undefined4 thunk_FUN_0040c780(int *param_1,undefined4 param_2) + +{ + undefined *puVar1; + int iVar2; + LONG LVar3; + LONG *lpAddend; + + iVar2 = FUN_0040b270(param_2,&DAT_00795474,1,&PTR_FUN_0079548c,0,0,param_2); + if (-1 < iVar2) { + FUN_0040b0f0(iVar2 + 1); + FUN_0040bf30(param_1); + return 1; + } + puVar1 = (undefined *)*param_1; + if (puVar1 != PTR_DAT_00818344) { + LVar3 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + return 1; +} + + + +// --- FUN_0040ce00 at 0x0040CE00 (size: 23) --- + +undefined4 FUN_0040ce00(undefined4 param_1,undefined4 param_2) + +{ + FUN_0040c840(param_1,param_2); + return param_1; +} + + + +// --- FUN_0040ce20 at 0x0040CE20 (size: 508) --- + +undefined4 * FUN_0040ce20(undefined4 *param_1) + +{ + byte bVar1; + char cVar2; + byte *pbVar3; + int iVar4; + char *pcVar5; + LONG LVar6; + byte *pbVar7; + char *pcVar8; + char *pcVar9; + char local_24 [4]; + char *local_20; + byte *local_1c; + byte *local_18; + char local_14 [16]; + char local_4; + + local_14._4_4_ = s_0123456789ABCDEF_007954ec._4_4_; + local_14._0_4_ = s_0123456789ABCDEF_007954ec._0_4_; + local_4 = s_0123456789ABCDEF_007954ec[0x10]; + local_14._8_4_ = s_0123456789ABCDEF_007954ec._8_4_; + local_14._12_4_ = s_0123456789ABCDEF_007954ec._12_4_; + pbVar3 = (byte *)FUN_00406d80(); + iVar4 = FUN_00406db0(); + local_20 = PTR_DAT_00818344; + pbVar7 = pbVar3 + iVar4; + local_18 = pbVar7; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + iVar4 = FUN_00406db0(); + FUN_00408d90(iVar4 * 2); + pcVar9 = local_20; + local_1c = pbVar3; + if (pbVar3 < pbVar7) { + do { + bVar1 = *pbVar3; + local_24[0] = local_14[bVar1 >> 4]; + pcVar8 = pcVar9; + local_1c = pbVar3; + if (local_24[0] != '\0') { + iVar4 = *(int *)(pcVar9 + -4); + if ((*(int *)(pcVar9 + -0x10) == 1) && (iVar4 + 1U <= *(uint *)(pcVar9 + -0xc))) { + *(uint *)(pcVar9 + -4) = iVar4 + 1U; + pcVar9[-0xffffffff00000008] = -1; + pcVar9[-0xffffffff00000007] = -1; + pcVar9[-0xffffffff00000006] = -1; + pcVar9[-0xffffffff00000005] = -1; + } + else { + FUN_00401280(iVar4); + pcVar8 = local_20; + pcVar5 = pcVar9; + do { + cVar2 = *pcVar5; + pcVar5[(int)local_20 - (int)pcVar9] = cVar2; + pcVar5 = pcVar5 + 1; + } while (cVar2 != '\0'); + LVar6 = InterlockedDecrement((LONG *)(pcVar9 + -0x10)); + if ((LVar6 == 0) && (pcVar9 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(pcVar9 + -0x14))(1); + } + } + strncpy(pcVar8 + iVar4 + -1,local_24,1); + pcVar8[*(int *)(pcVar8 + -4) + -1] = '\0'; + pbVar7 = local_18; + } + local_24[0] = local_14[bVar1 & 0xf]; + pcVar9 = pcVar8; + if (local_24[0] != '\0') { + iVar4 = *(int *)(pcVar8 + -4); + if ((*(int *)(pcVar8 + -0x10) == 1) && (iVar4 + 1U <= *(uint *)(pcVar8 + -0xc))) { + *(uint *)(pcVar8 + -4) = iVar4 + 1U; + pcVar8[-0xffffffff00000008] = -1; + pcVar8[-0xffffffff00000007] = -1; + pcVar8[-0xffffffff00000006] = -1; + pcVar8[-0xffffffff00000005] = -1; + } + else { + FUN_00401280(iVar4); + pcVar9 = local_20; + pcVar5 = pcVar8; + do { + cVar2 = *pcVar5; + pcVar5[(int)local_20 - (int)pcVar8] = cVar2; + pcVar5 = pcVar5 + 1; + } while (cVar2 != '\0'); + LVar6 = InterlockedDecrement((LONG *)(pcVar8 + -0x10)); + if ((LVar6 == 0) && (pcVar8 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(pcVar8 + -0x14))(1); + } + } + strncpy(pcVar9 + iVar4 + -1,local_24,1); + pcVar9[*(int *)(pcVar9 + -4) + -1] = '\0'; + } + pbVar3 = local_1c + 1; + local_1c = pbVar3; + } while (pbVar3 < pbVar7); + } + *param_1 = pcVar9; + InterlockedIncrement((LONG *)(pcVar9 + -0x10)); + LVar6 = InterlockedDecrement((LONG *)(pcVar9 + -0x10)); + if ((LVar6 == 0) && (pcVar9 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(pcVar9 + -0x14))(1); + } + return param_1; +} + + + +// --- FUN_0040d020 at 0x0040D020 (size: 341) --- + +undefined4 FUN_0040d020(int *param_1,uint param_2) + +{ + char cVar1; + int iVar2; + undefined *puVar3; + char *pcVar4; + int iVar5; + int *piVar6; + uint uVar7; + LONG LVar8; + LONG *lpAddend; + char *pcVar9; + char *pcVar10; + uint uVar11; + + piVar6 = param_1; + iVar2 = *param_1; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + puVar3 = (undefined *)*piVar6; + uVar11 = *(int *)(puVar3 + -4) - 1; + uVar7 = uVar11 / param_2; + if (puVar3 != PTR_DAT_00818344) { + LVar8 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + if ((LVar8 == 0) && ((undefined4 *)(puVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar3 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *piVar6 = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + FUN_00408d90(uVar7 + uVar11); + uVar7 = 0; + if (uVar11 != 0) { + do { + FUN_00404ef0(uVar7 + iVar2,param_2); + pcVar4 = (char *)*piVar6; + param_1 = (int *)CONCAT31(param_1._1_3_,10); + iVar5 = *(int *)(pcVar4 + -4); + if ((*(int *)(pcVar4 + -0x10) == 1) && (iVar5 + 1U <= *(uint *)(pcVar4 + -0xc))) { + *(uint *)(pcVar4 + -4) = iVar5 + 1U; + *(undefined4 *)(*piVar6 + -8) = 0xffffffff; + } + else { + FUN_00401280(iVar5); + pcVar10 = (char *)*piVar6; + pcVar9 = pcVar4; + do { + cVar1 = *pcVar9; + *pcVar10 = cVar1; + pcVar9 = pcVar9 + 1; + pcVar10 = pcVar10 + 1; + } while (cVar1 != '\0'); + LVar8 = InterlockedDecrement((LONG *)(pcVar4 + -0x10)); + if ((LVar8 == 0) && (pcVar4 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(pcVar4 + -0x14))(1); + } + } + strncpy((char *)(*piVar6 + -1 + iVar5),(char *)¶m_1,1); + uVar7 = uVar7 + param_2; + *(undefined1 *)(*(int *)(*piVar6 + -4) + -1 + *piVar6) = 0; + } while (uVar7 < uVar11); + } + LVar8 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar8 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + return 1; +} + + + +// --- FUN_0040d180 at 0x0040D180 (size: 115) --- + +undefined4 FUN_0040d180(int *param_1) + +{ + int iVar1; + int *piVar2; + LONG LVar3; + int local_4; + + piVar2 = (int *)FUN_00403350(&local_4,0); + iVar1 = *param_1; + if (iVar1 != *piVar2) { + LVar3 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *piVar2; + *param_1 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + LVar3 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + return 1; +} + + + +// --- FUN_0040d200 at 0x0040D200 (size: 95) --- + +undefined4 * FUN_0040d200(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + LONG LVar2; + undefined4 *puVar3; + undefined *local_4; + + local_4 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + FUN_0040d180(&local_4,param_2); + puVar1 = local_4; + *param_1 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + puVar3 = (undefined4 *)(puVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + return param_1; +} + + + +// --- FUN_0040d260 at 0x0040D260 (size: 427) --- + +undefined4 FUN_0040d260(undefined4 param_1,int *param_2) + +{ + char cVar1; + int iVar2; + undefined **ppuVar3; + undefined4 uVar4; + undefined4 *puVar5; + LONG LVar6; + char cVar7; + undefined *puVar8; + int *piVar9; + undefined4 uStack_24; + + piVar9 = param_2; + uStack_24 = (undefined4 *)CONCAT13(1,(uint3)uStack_24); + if (*(int *)(*param_2 + -4) == 1) { +LAB_0040d2cf: + uStack_24 = (undefined4 *)(uint)(uint3)uStack_24; + } + else { + iVar2 = (*(code *)PTR_FUN_0079548c)(); + if (iVar2 == 0) { + iVar2 = 0; + } + else { + iVar2 = iVar2 + -1; + } + cVar1 = (*(code *)PTR_FUN_00795494)(iVar2); + puVar8 = &DAT_00795474; + cVar7 = '\\'; + do { + if (cVar7 == cVar1) goto LAB_0040d2cf; + cVar7 = puVar8[1]; + puVar8 = puVar8 + 1; + } while (cVar7 != '\0'); + } + iVar2 = FUN_0040b270(param_1,&DAT_00795474,1); + if (iVar2 < 0) { + FUN_0040c8a0(piVar9); + if (uStack_24._3_1_ == '\0') { + return 1; + } + puVar5 = (undefined4 *)thunk_FUN_005df0f5(0x24); + if (puVar5 != (undefined4 *)0x0) { + param_2 = puVar5 + 5; + puVar5[1] = 1; + *puVar5 = &PTR_LAB_007cae34; + puVar5[4] = 1; + puVar5[2] = 1; + puVar5[3] = 0xffffffff; + *(undefined1 *)param_2 = 0; + puVar5[4] = 2; + puVar5[2] = 0x10; + } + piVar9 = param_2; + *(undefined1 *)param_2 = 0x2f; + *(undefined1 *)((int)param_2 + 1) = 0; + FUN_0040c8a0(¶m_2); + } + else { + FUN_0040b0f0(iVar2); + (*(code *)PTR_FUN_00795494)(0); + ppuVar3 = (undefined **)(*(code *)*uStack_24)(); + if (ppuVar3 <= &PTR_FUN_0079548c) { + (*(code *)PTR_FUN_0079548c)(); + } + FUN_0040c0b0(); + FUN_0040c8a0(piVar9); + if (uStack_24._3_1_ == '\0') { + return 1; + } + uVar4 = FUN_0040b870(param_2); + FUN_0040c8a0(uVar4); + piVar9 = param_2; + } + LVar6 = InterlockedDecrement(piVar9 + -4); + if ((LVar6 == 0) && (piVar9 + -5 != (int *)0x0)) { + (**(code **)piVar9[-5])(1); + } + return 1; +} + + + +// --- FUN_0040d410 at 0x0040D410 (size: 89) --- + +void __fastcall FUN_0040d410(int param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + undefined *local_4; + + while (*(int *)(param_1 + 4) != 0) { + local_4 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + FUN_0040c180(&local_4); + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + } + return; +} + + + +// --- FUN_0040d470 at 0x0040D470 (size: 36) --- + +undefined4 * __thiscall FUN_0040d470(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795488; + FUN_0040d410(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0040d4a0 at 0x0040D4A0 (size: 761) --- + +undefined4 FUN_0040d4a0(int *param_1,undefined4 param_2,int param_3,undefined4 param_4) + +{ + char cVar1; + int iVar2; + LONG LVar3; + intptr_t iVar4; + char *pcVar5; + undefined4 *puVar6; + char *local_154; + char *local_150; + undefined *local_14c; + int local_148; + int iStack_144; + int local_140; + intptr_t local_13c; + undefined **local_138; + undefined4 local_134; + undefined4 local_130; + int *local_12c; + undefined **local_128; + undefined4 local_124; + undefined4 local_120; + char **local_11c; + uint local_118 [5]; + undefined1 local_104 [260]; + + local_14c = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_0040c780(&local_14c,param_1); + FUN_00401340(&DAT_00795504); + FUN_0040d260(&local_140,&local_14c); + local_148 = *param_1; + InterlockedIncrement((LONG *)(local_148 + -0x10)); + FUN_0040c720(&local_148); + local_13c = findfirst(local_140,local_118); + iVar4 = local_13c; + while (iVar4 != -1) { + FUN_00401340(local_104); + iVar2 = _stricmp(local_150,DAT_008377f0); + if ((iVar2 != 0) && (iVar2 = _stricmp(local_150,DAT_008377f4), iVar2 != 0)) { + local_11c = &local_150; + local_128 = &PTR_FUN_0079548c; + local_138 = &PTR_FUN_0079548c; + local_12c = &local_148; + local_124 = 0; + local_120 = 0; + local_134 = 0; + local_130 = 0; + cVar1 = FUN_0040b400(&local_128,&local_138); + local_138 = &PTR_LAB_00795478; + local_128 = &PTR_LAB_00795478; + if (cVar1 != '\0') { + local_154 = local_150; + InterlockedIncrement((LONG *)(local_150 + -0x10)); + FUN_0040d260(&local_154,&local_14c); + FUN_0040b720(&local_154); + pcVar5 = local_154 + -0x14; + LVar3 = InterlockedDecrement((LONG *)(local_154 + -0x10)); + if ((LVar3 == 0) && (pcVar5 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar5)(1); + } + } + if (((local_118[0] >> 4 & 1) != 0) && ((param_3 != 0 || ((char)param_4 != '\0')))) { + local_154 = local_150; + InterlockedIncrement((LONG *)(local_150 + -0x10)); + FUN_0040d260(&local_154,&local_14c); + if (param_3 != 0) { + FUN_0040b720(&local_154); + } + if ((char)param_4 != '\0') { + iStack_144 = local_148; + InterlockedIncrement((LONG *)(local_148 + -0x10)); + FUN_0040d260(&iStack_144,&local_154); + FUN_0040d4a0(&iStack_144,param_2,param_3,param_4); + puVar6 = (undefined4 *)(iStack_144 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(iStack_144 + -0x10)); + if ((LVar3 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + } + pcVar5 = local_154 + -0x14; + LVar3 = InterlockedDecrement((LONG *)(local_154 + -0x10)); + if ((LVar3 == 0) && (pcVar5 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar5)(1); + } + } + } + pcVar5 = local_150 + -0x14; + LVar3 = InterlockedDecrement((LONG *)(local_150 + -0x10)); + if ((LVar3 == 0) && (pcVar5 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar5)(1); + } + iVar4 = findnext(local_13c,local_118); + } + _findclose(local_13c); + puVar6 = (undefined4 *)(local_148 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(local_148 + -0x10)); + if ((LVar3 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + LVar3 = InterlockedDecrement((LONG *)(local_140 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(local_140 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_140 + -0x14))(1); + } + puVar6 = (undefined4 *)(local_14c + -0x14); + LVar3 = InterlockedDecrement((LONG *)(local_14c + -0x10)); + if ((LVar3 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + return 1; +} + + + +// --- FUN_0040d7a0 at 0x0040D7A0 (size: 111) --- + +undefined4 FUN_0040d7a0(int *param_1) + +{ + int iVar1; + LONG LVar2; + int local_4; + + FUN_00408fd0(&local_4,0); + iVar1 = *param_1; + if (iVar1 != local_4) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + *param_1 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + } + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + return 1; +} + + + +// --- FUN_0040d810 at 0x0040D810 (size: 95) --- + +undefined4 * FUN_0040d810(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + LONG LVar2; + undefined4 *puVar3; + undefined *local_4; + + local_4 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_0040d7a0(&local_4,param_2); + puVar1 = local_4; + *param_1 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + puVar3 = (undefined4 *)(puVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + return param_1; +} + + + +// --- FUN_0040d870 at 0x0040D870 (size: 409) --- + +uint __thiscall FUN_0040d870(int *param_1,int *param_2,int *param_3) + +{ + wchar_t *pwVar1; + LONG LVar2; + int *piVar3; + wchar_t *pwVar4; + size_t _Count; + wchar_t *pwVar5; + wchar_t *_Source; + wchar_t *local_14; + wchar_t *local_10; + int local_c; + int *local_8; + int *local_4; + + piVar3 = (int *)0x0; + local_c = 0; + local_8 = (int *)0x0; + local_4 = (int *)0x0; + for (pwVar1 = wcsstr((wchar_t *)*param_1,(wchar_t *)*param_2); pwVar1 != (wchar_t *)0x0; + pwVar1 = wcsstr(pwVar1 + *(int *)((wchar_t *)*param_2 + -2) + -1,(wchar_t *)*param_2)) { + local_14 = pwVar1; + if (piVar3 == local_4) { + FUN_00660f50(piVar3,&local_14,¶m_3,1,1); + } + else { + if (piVar3 != (int *)0x0) { + *piVar3 = (int)pwVar1; + } + local_8 = piVar3 + 1; + } + piVar3 = local_8; + } + local_14 = (wchar_t *)((int)piVar3 - local_c >> 2); + if (local_14 == (wchar_t *)0x0) { + if (local_c != 0) { + FUN_004051c0(local_c,((int)local_4 - local_c >> 2) * 4); + } + return 0; + } + _Source = (wchar_t *)*param_1; + local_10 = _Source + -10; + FUN_004022d0((*(int *)(*param_3 + -4) - *(int *)(*param_2 + -4)) * (int)local_14 + -1 + + *(int *)(_Source + -2)); + pwVar1 = (wchar_t *)*param_1; + pwVar4 = (wchar_t *)0x0; + pwVar5 = _Source + -10; + if (local_14 != (wchar_t *)0x0) { + do { + _Count = *(int *)(local_c + (int)pwVar4 * 4) - (int)_Source >> 1; + wcsncpy(pwVar1,_Source,_Count); + wcscpy(pwVar1 + _Count,(wchar_t *)*param_3); + pwVar1 = pwVar1 + _Count + *(int *)(*param_3 + -4) + -1; + pwVar4 = (wchar_t *)((int)pwVar4 + 1); + _Source = _Source + *(int *)(*param_2 + -4) + _Count + -1; + pwVar5 = local_10; + } while (pwVar4 < local_14); + } + wcscpy(pwVar1,_Source); + LVar2 = InterlockedDecrement((LONG *)(pwVar5 + 2)); + if ((LVar2 == 0) && (pwVar5 != (wchar_t *)0x0)) { + (*(code *)**(undefined4 **)pwVar5)(1); + } + if (local_c != 0) { + FUN_004051c0(local_c,((int)local_4 - local_c >> 2) * 4); + } + return (uint)local_14; +} + + + +// --- FUN_0040da10 at 0x0040DA10 (size: 281) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 FUN_0040da10(undefined4 param_1,char param_2) + +{ + undefined4 *puVar1; + + if ((_DAT_008377ec & 1) == 0) { + _DAT_008377ec = _DAT_008377ec | 1; + puVar1 = (undefined4 *)thunk_FUN_005df0f5(0x24); + if (puVar1 != (undefined4 *)0x0) { + puVar1[1] = 1; + *puVar1 = &PTR_LAB_007cae34; + puVar1[4] = 1; + puVar1[2] = 1; + puVar1[3] = 0xffffffff; + DAT_008377e8 = puVar1 + 5; + *(undefined1 *)DAT_008377e8 = 0; + puVar1[4] = 2; + DAT_008377e8[-3] = 0x10; + } + *(undefined1 *)DAT_008377e8 = 0x5c; + *(undefined1 *)((int)DAT_008377e8 + 1) = 0; + _atexit((_func_4879 *)&LAB_00726bb0); + } + if ((_DAT_008377ec & 2) == 0) { + _DAT_008377ec = _DAT_008377ec | 2; + puVar1 = (undefined4 *)thunk_FUN_005df0f5(0x24); + if (puVar1 != (undefined4 *)0x0) { + puVar1[1] = 1; + *puVar1 = &PTR_LAB_007cae34; + puVar1[4] = 1; + puVar1[2] = 1; + puVar1[3] = 0xffffffff; + DAT_008377e4 = puVar1 + 5; + *(undefined1 *)DAT_008377e4 = 0; + puVar1[4] = 2; + DAT_008377e4[-3] = 0x10; + } + *(undefined1 *)DAT_008377e4 = 0x2f; + *(undefined1 *)((int)DAT_008377e4 + 1) = 0; + _atexit((_func_4879 *)&LAB_00726b80); + } + if (param_2 != '\0') { + FUN_004053a0(&DAT_008377e4,&DAT_008377e8); + return 1; + } + FUN_004053a0(&DAT_008377e8,&DAT_008377e4); + return 1; +} + + + +// --- FUN_0040db30 at 0x0040DB30 (size: 180) --- + +undefined4 FUN_0040db30(void) + +{ + DWORD DVar1; + LONG LVar2; + int local_408; + int local_404; + CHAR local_400 [1024]; + + DVar1 = GetCurrentDirectoryA(0x400,local_400); + if (DVar1 != 0) { + FUN_00405000(local_400); + FUN_00401340(&DAT_007954ac); + FUN_00401340(&DAT_0079550c); + FUN_004053a0(&local_404,&local_408); + LVar2 = InterlockedDecrement((LONG *)(local_404 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(local_404 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_404 + -0x14))(1); + } + LVar2 = InterlockedDecrement((LONG *)(local_408 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(local_408 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_408 + -0x14))(1); + } + return 1; + } + return 0; +} + + + +// --- thunk_FUN_0040da10 at 0x0040DBF0 (size: 5) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 thunk_FUN_0040da10(undefined4 param_1,char param_2) + +{ + undefined4 *puVar1; + + if ((_DAT_008377ec & 1) == 0) { + _DAT_008377ec = _DAT_008377ec | 1; + puVar1 = (undefined4 *)thunk_FUN_005df0f5(0x24); + if (puVar1 != (undefined4 *)0x0) { + puVar1[1] = 1; + *puVar1 = &PTR_LAB_007cae34; + puVar1[4] = 1; + puVar1[2] = 1; + puVar1[3] = 0xffffffff; + DAT_008377e8 = puVar1 + 5; + *(undefined1 *)DAT_008377e8 = 0; + puVar1[4] = 2; + DAT_008377e8[-3] = 0x10; + } + *(undefined1 *)DAT_008377e8 = 0x5c; + *(undefined1 *)((int)DAT_008377e8 + 1) = 0; + _atexit((_func_4879 *)&LAB_00726bb0); + } + if ((_DAT_008377ec & 2) == 0) { + _DAT_008377ec = _DAT_008377ec | 2; + puVar1 = (undefined4 *)thunk_FUN_005df0f5(0x24); + if (puVar1 != (undefined4 *)0x0) { + puVar1[1] = 1; + *puVar1 = &PTR_LAB_007cae34; + puVar1[4] = 1; + puVar1[2] = 1; + puVar1[3] = 0xffffffff; + DAT_008377e4 = puVar1 + 5; + *(undefined1 *)DAT_008377e4 = 0; + puVar1[4] = 2; + DAT_008377e4[-3] = 0x10; + } + *(undefined1 *)DAT_008377e4 = 0x2f; + *(undefined1 *)((int)DAT_008377e4 + 1) = 0; + _atexit((_func_4879 *)&LAB_00726b80); + } + if (param_2 != '\0') { + FUN_004053a0(&DAT_008377e4,&DAT_008377e8); + return 1; + } + FUN_004053a0(&DAT_008377e8,&DAT_008377e4); + return 1; +} + + + +// --- FUN_0040dc00 at 0x0040DC00 (size: 595) --- + +undefined1 FUN_0040dc00(undefined4 *param_1) + +{ + int iVar1; + LPCSTR pCVar2; + char cVar3; + DWORD DVar4; + LONG LVar5; + HANDLE hFindFile; + undefined4 *puVar6; + undefined *puVar7; + LPCSTR *ppCVar8; + int iVar9; + undefined1 local_371; + undefined *local_370; + int local_36c; + int local_368; + LPCSTR local_364; + undefined **local_360; + int local_35c; + undefined4 local_358; + undefined4 local_354; + int local_350; + LPSTR local_34c; + CHAR local_348 [260]; + CHAR local_244 [260]; + _WIN32_FIND_DATAA _Stack_140; + + local_371 = 0; + DVar4 = GetFullPathNameA((LPCSTR)*param_1,0x104,local_348,&local_34c); + if ((DVar4 == 0) || + (DVar4 = GetLongPathNameA(local_348,local_244,0x104), puVar7 = PTR_DAT_00818344, DVar4 == 0)) { + return 0; + } + local_370 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00401340(local_244); + cVar3 = FUN_0040da10(&local_36c,0); + if (cVar3 != '\0') { + local_360 = &PTR_FUN_00795074; + local_35c = 0; + local_358 = 0; + local_354 = 0; + cVar3 = FUN_0040c2d0(&local_36c,0x2f,&local_360); + iVar1 = local_35c; + if (cVar3 != '\0') { + FUN_00402070(local_35c); + if (iVar1 != 0) { + for (iVar1 = *(int *)(iVar1 + 4); iVar1 != 0; iVar1 = *(int *)(iVar1 + 4)) { + FUN_00401340(&DAT_007954ac); + ppCVar8 = &local_364; + iVar9 = iVar1; + FUN_0040bbc0(&local_350,&local_368); + FUN_0040bbc0(ppCVar8,iVar9); + puVar6 = (undefined4 *)(local_350 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(local_350 + -0x10)); + if ((LVar5 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + puVar6 = (undefined4 *)(local_368 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(local_368 + -0x10)); + if ((LVar5 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + pCVar2 = local_364; + hFindFile = FindFirstFileA(local_364,&_Stack_140); + if (hFindFile == (HANDLE)0xffffffff) { + LVar5 = InterlockedDecrement((LONG *)(pCVar2 + -0x10)); + if ((LVar5 == 0) && (pCVar2 + -0x14 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)(pCVar2 + -0x14))(1); + } + goto LAB_0040ddd5; + } + FUN_00406500(&local_370,&DAT_00795510,_Stack_140.cFileName); + FindClose(hFindFile); + LVar5 = InterlockedDecrement((LONG *)(pCVar2 + -0x10)); + if ((LVar5 == 0) && (pCVar2 + -0x14 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)(pCVar2 + -0x14))(1); + } + if (iVar1 == 0) break; + } + } + FUN_00401700(&local_370); + local_371 = 1; + } +LAB_0040ddd5: + local_360 = &PTR_FUN_00795074; + FUN_00405210(); + puVar7 = local_370; + } + LVar5 = InterlockedDecrement((LONG *)(local_36c + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(local_36c + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_36c + -0x14))(1); + } + LVar5 = InterlockedDecrement((LONG *)(puVar7 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(puVar7 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar7 + -0x14))(1); + } + return local_371; +} + + + +// --- FUN_0040de60 at 0x0040DE60 (size: 73) --- + +undefined4 FUN_0040de60(void) + +{ + LONG LVar1; + int local_4; + + FUN_00401340(&DAT_00795508); + FUN_004053a0(&local_4,&PTR_DAT_00818344); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + return 1; +} + + + +// --- FUN_0040deb0 at 0x0040DEB0 (size: 86) --- + +undefined4 FUN_0040deb0(int *param_1,undefined4 param_2) + +{ + uint uVar1; + uint uVar2; + undefined4 uVar3; + char cVar4; + + uVar3 = param_2; + FUN_0040da10(param_1,param_2); + uVar2 = *(uint *)(*param_1 + -4); + cVar4 = (-((char)uVar3 != '\0') & 0x2dU) + 0x2f; + if (1 < uVar2) { + uVar1 = uVar2 - 2; + if (uVar2 <= uVar1) { + uVar1 = uVar2 - 1; + } + if (*(char *)(*param_1 + uVar1) != cVar4) { + param_2 = CONCAT31(param_2._1_3_,cVar4); + FUN_00404ef0(¶m_2,1); + } + } + return 1; +} + + + +// --- thunk_FUN_0040deb0 at 0x0040DF10 (size: 5) --- + +undefined4 thunk_FUN_0040deb0(int *param_1,undefined4 param_2) + +{ + uint uVar1; + uint uVar2; + undefined4 uVar3; + char cVar4; + + uVar3 = param_2; + FUN_0040da10(param_1,param_2); + uVar2 = *(uint *)(*param_1 + -4); + cVar4 = (-((char)uVar3 != '\0') & 0x2dU) + 0x2f; + if (1 < uVar2) { + uVar1 = uVar2 - 2; + if (uVar2 <= uVar1) { + uVar1 = uVar2 - 1; + } + if (*(char *)(*param_1 + uVar1) != cVar4) { + param_2 = CONCAT31(param_2._1_3_,cVar4); + FUN_00404ef0(¶m_2,1); + } + } + return 1; +} + + + +// --- FUN_0040df20 at 0x0040DF20 (size: 492) --- + +undefined4 FUN_0040df20(int *param_1) + +{ + uint uVar1; + uint uVar2; + int *piVar3; + char *lpPathName; + char cVar4; + LONG LVar5; + int iVar6; + BOOL BVar7; + undefined4 *puVar8; + int local_18; + char *local_14; + undefined **local_10; + int *local_c; + undefined4 local_8; + undefined4 local_4; + + local_18 = *param_1; + InterlockedIncrement((LONG *)(local_18 + -0x10)); + FUN_0040da10(&local_18,0); + uVar2 = *(uint *)(local_18 + -4); + if (1 < uVar2) { + uVar1 = uVar2 - 2; + if (uVar2 <= uVar1) { + uVar1 = uVar2 - 1; + } + if (*(char *)(uVar1 + local_18) != '/') { + param_1 = (int *)CONCAT31(param_1._1_3_,0x2f); + FUN_00404ef0(¶m_1,1); + } + } + local_10 = &PTR_FUN_00795074; + local_c = (int *)0x0; + local_8 = 0; + local_4 = 0; + cVar4 = FUN_0040c2d0(&local_18,0x2f,&local_10); + piVar3 = local_c; + lpPathName = PTR_DAT_00818344; + if (cVar4 == '\0') { + local_10 = &PTR_FUN_00795074; + FUN_00405210(); + puVar8 = (undefined4 *)(local_18 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(local_18 + -0x10)); + if ((LVar5 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + return 0; + } + local_14 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + while( true ) { + if (piVar3 == (int *)0x0) { + LVar5 = InterlockedDecrement((LONG *)(lpPathName + -0x10)); + if ((LVar5 == 0) && (lpPathName + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(lpPathName + -0x14))(1); + } + local_10 = &PTR_FUN_00795074; + FUN_00405210(); + puVar8 = (undefined4 *)(local_18 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(local_18 + -0x10)); + if ((LVar5 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + return 1; + } + iVar6 = *(int *)(*piVar3 + -4); + if (iVar6 != 1) { + FUN_00404ef0(*piVar3,iVar6 + -1); + } + param_1 = (int *)CONCAT31(param_1._1_3_,0x2f); + FUN_00404ef0(¶m_1,1); + lpPathName = local_14; + iVar6 = _access(local_14,0); + if ((iVar6 != 0) && + (BVar7 = CreateDirectoryA(lpPathName,(LPSECURITY_ATTRIBUTES)0x0), BVar7 == 0)) break; + piVar3 = (int *)piVar3[1]; + } + LVar5 = InterlockedDecrement((LONG *)(lpPathName + -0x10)); + if ((LVar5 == 0) && (lpPathName + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(lpPathName + -0x14))(1); + } + local_10 = &PTR_FUN_00795074; + FUN_00405210(); + puVar8 = (undefined4 *)(local_18 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(local_18 + -0x10)); + if ((LVar5 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + return 0; +} + + + +// --- thunk_FUN_0040df20 at 0x0040E110 (size: 5) --- + +undefined4 thunk_FUN_0040df20(int *param_1) + +{ + uint uVar1; + uint uVar2; + int *piVar3; + char *lpPathName; + char cVar4; + LONG LVar5; + int iVar6; + BOOL BVar7; + undefined4 *puVar8; + int iStack_18; + char *pcStack_14; + undefined **ppuStack_10; + int *piStack_c; + undefined4 uStack_8; + undefined4 uStack_4; + + iStack_18 = *param_1; + InterlockedIncrement((LONG *)(iStack_18 + -0x10)); + FUN_0040da10(&iStack_18,0); + uVar2 = *(uint *)(iStack_18 + -4); + if (1 < uVar2) { + uVar1 = uVar2 - 2; + if (uVar2 <= uVar1) { + uVar1 = uVar2 - 1; + } + if (*(char *)(uVar1 + iStack_18) != '/') { + param_1 = (int *)CONCAT31(param_1._1_3_,0x2f); + FUN_00404ef0(¶m_1,1); + } + } + ppuStack_10 = &PTR_FUN_00795074; + piStack_c = (int *)0x0; + uStack_8 = 0; + uStack_4 = 0; + cVar4 = FUN_0040c2d0(&iStack_18,0x2f,&ppuStack_10); + piVar3 = piStack_c; + lpPathName = PTR_DAT_00818344; + if (cVar4 == '\0') { + ppuStack_10 = &PTR_FUN_00795074; + FUN_00405210(); + puVar8 = (undefined4 *)(iStack_18 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(iStack_18 + -0x10)); + if ((LVar5 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + return 0; + } + pcStack_14 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + while( true ) { + if (piVar3 == (int *)0x0) { + LVar5 = InterlockedDecrement((LONG *)(lpPathName + -0x10)); + if ((LVar5 == 0) && (lpPathName + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(lpPathName + -0x14))(1); + } + ppuStack_10 = &PTR_FUN_00795074; + FUN_00405210(); + puVar8 = (undefined4 *)(iStack_18 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(iStack_18 + -0x10)); + if ((LVar5 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + return 1; + } + iVar6 = *(int *)(*piVar3 + -4); + if (iVar6 != 1) { + FUN_00404ef0(*piVar3,iVar6 + -1); + } + param_1 = (int *)CONCAT31(param_1._1_3_,0x2f); + FUN_00404ef0(¶m_1,1); + lpPathName = pcStack_14; + iVar6 = _access(pcStack_14,0); + if ((iVar6 != 0) && + (BVar7 = CreateDirectoryA(lpPathName,(LPSECURITY_ATTRIBUTES)0x0), BVar7 == 0)) break; + piVar3 = (int *)piVar3[1]; + } + LVar5 = InterlockedDecrement((LONG *)(lpPathName + -0x10)); + if ((LVar5 == 0) && (lpPathName + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(lpPathName + -0x14))(1); + } + ppuStack_10 = &PTR_FUN_00795074; + FUN_00405210(); + puVar8 = (undefined4 *)(iStack_18 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(iStack_18 + -0x10)); + if ((LVar5 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + return 0; +} + + + +// --- FUN_0040e120 at 0x0040E120 (size: 119) --- + +bool FUN_0040e120(undefined4 *param_1,undefined4 *param_2,LPBYTE param_3,DWORD param_4,HKEY param_5) + +{ + LSTATUS LVar1; + bool bVar2; + HKEY local_4; + + local_4 = (HKEY)0x0; + LVar1 = RegOpenKeyExA(param_5,(LPCSTR)*param_1,0,0x20019,&local_4); + bVar2 = false; + if (LVar1 == 0) { + LVar1 = RegQueryValueExA(local_4,(LPCSTR)*param_2,(LPDWORD)0x0,(LPDWORD)¶m_1,param_3, + ¶m_4); + bVar2 = LVar1 == 0; + } + if (local_4 != (HKEY)0x0) { + RegCloseKey(local_4); + } + return bVar2; +} + + + +// --- FUN_0040e1a0 at 0x0040E1A0 (size: 122) --- + +bool FUN_0040e1a0(undefined4 *param_1) + +{ + int iVar1; + undefined4 unaff_EBX; + bool bVar2; + undefined4 in_stack_00000014; + HKEY hKey; + undefined4 uStack_10; + undefined4 *puStack_c; + undefined4 local_4; + + puStack_c = &local_4; + uStack_10 = 0x20019; + hKey = (HKEY)*param_1; + local_4 = 0; + iVar1 = (*(code *)PTR_FUN_00837350)(in_stack_00000014,hKey,0); + bVar2 = false; + if (iVar1 == 0) { + iVar1 = (*(code *)PTR_FUN_00837354)(hKey,*puStack_c,0,&uStack_10,unaff_EBX,&local_4); + bVar2 = iVar1 == 0; + } + if (hKey != (HKEY)0x0) { + RegCloseKey(hKey); + } + return bVar2; +} + + + +// --- FUN_0040e220 at 0x0040E220 (size: 94) --- + +bool FUN_0040e220(undefined4 *param_1,undefined4 *param_2,HKEY param_3) + +{ + LSTATUS LVar1; + bool bVar2; + HKEY local_4; + + local_4 = (HKEY)0x0; + LVar1 = RegOpenKeyExA(param_3,(LPCSTR)*param_1,0,0x20006,&local_4); + bVar2 = false; + if (LVar1 == 0) { + LVar1 = RegDeleteValueA(local_4,(LPCSTR)*param_2); + bVar2 = LVar1 == 0; + } + if (local_4 != (HKEY)0x0) { + RegCloseKey(local_4); + } + return bVar2; +} + + + +// --- FUN_0040e280 at 0x0040E280 (size: 82) --- + +undefined1 FUN_0040e280(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4) + +{ + char cVar1; + undefined1 local_800 [2048]; + + cVar1 = FUN_0040e120(param_1,param_2,local_800,0x800,param_4); + if (cVar1 == '\0') { + return 0; + } + FUN_00405000(local_800); + return 1; +} + + + +// --- FUN_0040e2e0 at 0x0040E2E0 (size: 89) --- + +/* WARNING: Function: __chkstk replaced with injection: alloca_probe */ + +undefined1 FUN_0040e2e0(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4) + +{ + char cVar1; + undefined1 local_1000 [4092]; + undefined4 uStack_4; + + uStack_4 = 0x40e2ea; + cVar1 = FUN_0040e1a0(param_1,param_2,local_1000,0x800,param_4); + if (cVar1 == '\0') { + return 0; + } + FUN_00407e40(local_1000); + return 1; +} + + + +// --- FUN_0040e340 at 0x0040E340 (size: 87) --- + +uint __thiscall FUN_0040e340(int *param_1,int param_2) + +{ + uint uVar1; + int *piVar2; + uint uVar3; + + uVar1 = 0; + if (param_1[2] != 0) { + piVar2 = (int *)*param_1; + do { + if (*piVar2 == param_2) { + *(undefined4 *)(param_2 + 4) = 0; + if (uVar1 < (uint)param_1[2]) { + uVar3 = param_1[2] - 1; + param_1[2] = uVar3; + if (uVar1 != uVar3) { + *(undefined4 *)(*param_1 + uVar1 * 4) = *(undefined4 *)(*param_1 + uVar3 * 4); + uVar1 = param_1[2]; + *(undefined4 *)(*param_1 + uVar1 * 4) = 0; + } + } + return CONCAT31((int3)(uVar1 >> 8),1); + } + uVar1 = uVar1 + 1; + piVar2 = piVar2 + 1; + } while (uVar1 < (uint)param_1[2]); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_0040e3a0 at 0x0040E3A0 (size: 55) --- + +void FUN_0040e3a0(void) + +{ + uint uVar1; + + if (DAT_008377f8 == '\0') { + uVar1 = 0; + DAT_008377f8 = '\x01'; + if (DAT_00837804 != 0) { + do { + (**(code **)(**(int **)(DAT_008377fc + uVar1 * 4) + 8))(); + uVar1 = uVar1 + 1; + } while (uVar1 < DAT_00837804); + } + } + return; +} + + + +// --- FUN_0040e3e0 at 0x0040E3E0 (size: 61) --- + +void __fastcall FUN_0040e3e0(int *param_1) + +{ + int iVar1; + uint uVar2; + + uVar2 = 0; + if (param_1[2] != 0) { + do { + iVar1 = uVar2 * 4; + uVar2 = uVar2 + 1; + *(undefined4 *)(*(int *)(*param_1 + iVar1) + 4) = 0; + } while (uVar2 < (uint)param_1[2]); + } + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + } + return; +} + + + +// --- FUN_0040e420 at 0x0040E420 (size: 48) --- + +void __fastcall FUN_0040e420(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_00795540; + FUN_0040e340(param_1); + *param_1 = &PTR_FUN_00795538; + if (param_1[1] != 0) { + FUN_0040e340(param_1); + param_1[1] = 0; + } + return; +} + + + +// --- FUN_0040e450 at 0x0040E450 (size: 51) --- + +undefined4 * __thiscall FUN_0040e450(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795538; + if (param_1[1] != 0) { + FUN_0040e340(param_1); + param_1[1] = 0; + } + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0040e490 at 0x0040E490 (size: 68) --- + +undefined4 * __thiscall FUN_0040e490(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795540; + FUN_0040e340(param_1); + *param_1 = &PTR_FUN_00795538; + if (param_1[1] != 0) { + FUN_0040e340(param_1); + param_1[1] = 0; + } + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0040e4e0 at 0x0040E4E0 (size: 84) --- + +undefined4 __thiscall FUN_0040e4e0(int *param_1,int *param_2) + +{ + char cVar1; + undefined4 uVar2; + + if (param_2[1] != 0) { + return 0; + } + if ((param_1[1] & 0x7fffffffU) <= (uint)param_1[2]) { + uVar2 = FUN_004077f0((param_1[1] & 0x7fffffffU) + 1); + cVar1 = FUN_00408220(uVar2); + if (cVar1 == '\0') goto LAB_0040e525; + } + *(int **)(*param_1 + param_1[2] * 4) = param_2; + param_1[2] = param_1[2] + 1; +LAB_0040e525: + (**(code **)(*param_2 + 4))(param_1); + return 1; +} + + + +// --- FUN_0040e540 at 0x0040E540 (size: 31) --- + +undefined4 * __fastcall FUN_0040e540(undefined4 *param_1) + +{ + param_1[1] = 0; + *param_1 = &PTR_FUN_00795540; + FUN_0040e4e0(param_1); + return param_1; +} + + + +// --- FUN_0040e560 at 0x0040E560 (size: 101) --- + +undefined8 FUN_0040e560(void) + +{ + uint uVar1; + uint uVar2; + LONG LVar3; + uint uVar4; + uint uVar5; + uint uVar6; + undefined8 uVar7; + + uVar4 = DAT_00837814; + uVar6 = DAT_00837810; + LVar3 = InterlockedIncrement((LONG *)&DAT_008183c0); + uVar1 = DAT_00837810; + uVar2 = DAT_00837814; + if ((LVar3 == 0) && (uVar5 = 0, uVar1 = uVar6, uVar2 = uVar4, DAT_00837820 != 0)) { + do { + (**(code **)(**(int **)(DAT_00837818 + uVar5 * 4) + 0x10))(); + uVar7 = __allshl(); + uVar5 = uVar5 + 1; + uVar6 = uVar6 | (uint)uVar7; + uVar4 = uVar4 | (uint)((ulonglong)uVar7 >> 0x20); + uVar1 = uVar6; + uVar2 = uVar4; + } while (uVar5 < DAT_00837820); + } + DAT_00837814 = uVar2; + DAT_00837810 = uVar1; + return CONCAT44(uVar4,uVar6); +} + + + +// --- FUN_0040e5d0 at 0x0040E5D0 (size: 80) --- + +void FUN_0040e5d0(void) + +{ + int iVar1; + LONG LVar2; + uint uVar3; + uint uVar4; + + LVar2 = InterlockedDecrement((LONG *)&DAT_008183c0); + if ((LVar2 < 0) && (uVar4 = 0, DAT_00837820 != 0)) { + do { + iVar1 = **(int **)(DAT_00837818 + uVar4 * 4); + uVar3 = __aullshr(); + (**(code **)(iVar1 + 0x14))(uVar3 & 0xffffff01); + uVar4 = uVar4 + 1; + } while (uVar4 < DAT_00837820); + } + return; +} + + + +// --- FUN_0040e620 at 0x0040E620 (size: 101) --- + +undefined8 FUN_0040e620(void) + +{ + uint uVar1; + uint uVar2; + LONG LVar3; + uint uVar4; + uint uVar5; + uint uVar6; + undefined8 uVar7; + + uVar4 = DAT_0083780c; + uVar6 = DAT_00837808; + LVar3 = InterlockedIncrement((LONG *)&DAT_008183bc); + uVar1 = DAT_00837808; + uVar2 = DAT_0083780c; + if ((LVar3 == 0) && (uVar5 = 0, uVar1 = uVar6, uVar2 = uVar4, DAT_00837820 != 0)) { + do { + (**(code **)(**(int **)(DAT_00837818 + uVar5 * 4) + 0x18))(); + uVar7 = __allshl(); + uVar5 = uVar5 + 1; + uVar6 = uVar6 | (uint)uVar7; + uVar4 = uVar4 | (uint)((ulonglong)uVar7 >> 0x20); + uVar1 = uVar6; + uVar2 = uVar4; + } while (uVar5 < DAT_00837820); + } + DAT_0083780c = uVar2; + DAT_00837808 = uVar1; + return CONCAT44(uVar4,uVar6); +} + + + +// --- FUN_0040e690 at 0x0040E690 (size: 80) --- + +void FUN_0040e690(void) + +{ + int iVar1; + LONG LVar2; + uint uVar3; + uint uVar4; + + LVar2 = InterlockedDecrement((LONG *)&DAT_008183bc); + if ((LVar2 < 0) && (uVar4 = 0, DAT_00837820 != 0)) { + do { + iVar1 = **(int **)(DAT_00837818 + uVar4 * 4); + uVar3 = __aullshr(); + (**(code **)(iVar1 + 0x1c))(uVar3 & 0xffffff01); + uVar4 = uVar4 + 1; + } while (uVar4 < DAT_00837820); + } + return; +} + + + +// --- FUN_0040e6e0 at 0x0040E6E0 (size: 48) --- + +void __fastcall FUN_0040e6e0(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_0079554c; + FUN_0040e340(param_1); + *param_1 = &PTR_FUN_00795538; + if (param_1[1] != 0) { + FUN_0040e340(param_1); + param_1[1] = 0; + } + return; +} + + + +// --- FUN_0040e740 at 0x0040E740 (size: 68) --- + +undefined4 * __thiscall FUN_0040e740(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079554c; + FUN_0040e340(param_1); + *param_1 = &PTR_FUN_00795538; + if (param_1[1] != 0) { + FUN_0040e340(param_1); + param_1[1] = 0; + } + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0040e790 at 0x0040E790 (size: 31) --- + +undefined4 * __fastcall FUN_0040e790(undefined4 *param_1) + +{ + param_1[1] = 0; + *param_1 = &PTR_FUN_0079554c; + FUN_0040e4e0(param_1); + return param_1; +} + + + +// --- FUN_0040e7b0 at 0x0040E7B0 (size: 24) --- + +void __fastcall FUN_0040e7b0(undefined4 *param_1) + +{ + CloseHandle((HANDLE)param_1[2]); + CloseHandle((HANDLE)*param_1); + return; +} + + + +// --- FUN_0040e7d0 at 0x0040E7D0 (size: 165) --- + +undefined4 * __thiscall FUN_0040e7d0(undefined4 *param_1,int param_2) + +{ + undefined4 *puVar1; + HANDLE pvVar2; + BOOL BVar3; + DWORD DVar4; + undefined4 uVar5; + HMODULE pHVar6; + undefined4 *local_4; + + local_4 = param_1; + puVar1 = GetCurrentProcess(); + local_4 = puVar1; + pvVar2 = GetCurrentProcess(); + BVar3 = DuplicateHandle(pvVar2,puVar1,pvVar2,&local_4,0,1,2); + if (BVar3 != 0) { + puVar1 = local_4; + } + *param_1 = puVar1; + DVar4 = GetCurrentThreadId(); + param_1[1] = DVar4; + puVar1 = GetCurrentThread(); + local_4 = puVar1; + pvVar2 = GetCurrentProcess(); + BVar3 = DuplicateHandle(pvVar2,puVar1,pvVar2,&local_4,0,1,2); + if (BVar3 != 0) { + puVar1 = local_4; + } + param_1[2] = puVar1; + if ((param_2 != 0) && (*(int *)(param_2 + 4) != 0)) { + uVar5 = FUN_00411120(); + param_1[3] = uVar5; + return param_1; + } + pHVar6 = GetModuleHandleA((LPCSTR)0x0); + param_1[3] = pHVar6; + return param_1; +} + + + +// --- FUN_0040e880 at 0x0040E880 (size: 93) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_0040e880(void) + +{ + if (DAT_0083782c != (HMODULE)0x0) { + _DAT_00837830 = 0; + _DAT_00837834 = 0; + _DAT_00837838 = 0; + _DAT_0083783c = 0; + _DAT_00837840 = 0; + _DAT_00837844 = 0; + _DAT_00837848 = 0; + _DAT_0083784c = 0; + _DAT_00837850 = 0; + _DAT_00837854 = 0; + _DAT_00837858 = 0; + FreeLibrary(DAT_0083782c); + DAT_0083782c = (HMODULE)0x0; + } + return; +} + + + +// --- FUN_0040e900 at 0x0040E900 (size: 1) --- + +void FUN_0040e900(void) + +{ + return; +} + + + +// --- FUN_0040e910 at 0x0040E910 (size: 231) --- + +/* WARNING: Function: __chkstk replaced with injection: alloca_probe */ + +int __thiscall FUN_0040e910(int param_1,undefined4 param_2,undefined4 param_3,char *param_4) + +{ + char cVar1; + char *pcVar2; + int iVar3; + uint uVar4; + int local_1004; + char local_1000 [4092]; + uint uStack_4; + + uStack_4 = 0x40e91a; + local_1004 = 2; + if (*(int *)(param_1 + 0x14) == 0) { + return 2; + } + strncpy(local_1000,param_4,0xfff); + pcVar2 = local_1000; + uStack_4 = uStack_4 & 0xffffff; + do { + cVar1 = *pcVar2; + pcVar2 = pcVar2 + 1; + } while (cVar1 != '\0'); + iVar3 = (int)pcVar2 - (int)(local_1000 + 1); + if (local_1000[iVar3 + -1] != '\n') { + if (iVar3 == 0xfff) { + iVar3 = 0xffe; + } + local_1000[iVar3] = '\n'; + local_1000[iVar3 + 1] = '\0'; + } + uVar4 = 0; + if (*(int *)(param_1 + 0x14) == 0) { + return 2; + } + do { + iVar3 = (**(code **)(**(int **)(*(int *)(param_1 + 0xc) + uVar4 * 4) + 4)) + (param_2,param_3,local_1000); + if (((-1 < iVar3) && (iVar3 < 2)) && (local_1004 != 0)) { + local_1004 = iVar3; + } + uVar4 = uVar4 + 1; + } while (uVar4 < *(uint *)(param_1 + 0x14)); + return local_1004; +} + + + +// --- FUN_0040ea40 at 0x0040EA40 (size: 64) --- + +undefined4 * __thiscall FUN_0040ea40(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007955bc; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0040ea80 at 0x0040EA80 (size: 73) --- + +undefined4 __fastcall FUN_0040ea80(int param_1) + +{ + undefined4 *puVar1; + + if (*(int *)(param_1 + 0xa4) == 0) { + puVar1 = (undefined4 *)FUN_005df0f5(8); + if (puVar1 == (undefined4 *)0x0) { + puVar1 = (undefined4 *)0x0; + } + else { + puVar1[1] = 1; + *puVar1 = &PTR_FUN_007955a0; + } + *(undefined4 **)(param_1 + 0xa4) = puVar1; + } + InterlockedIncrement((LONG *)(*(int *)(param_1 + 0xa4) + 4)); + return *(undefined4 *)(param_1 + 0xa4); +} + + + +// --- FUN_0040ead0 at 0x0040EAD0 (size: 73) --- + +undefined4 __fastcall FUN_0040ead0(int param_1) + +{ + undefined4 *puVar1; + + if (*(int *)(param_1 + 0xa8) == 0) { + puVar1 = (undefined4 *)FUN_005df0f5(8); + if (puVar1 == (undefined4 *)0x0) { + puVar1 = (undefined4 *)0x0; + } + else { + puVar1[1] = 1; + *puVar1 = &PTR_FUN_007955b0; + } + *(undefined4 **)(param_1 + 0xa8) = puVar1; + } + InterlockedIncrement((LONG *)(*(int *)(param_1 + 0xa8) + 4)); + return *(undefined4 *)(param_1 + 0xa8); +} + + + +// --- FUN_0040eb20 at 0x0040EB20 (size: 20) --- + +undefined4 FUN_0040eb20(int param_1) + +{ + undefined4 uVar1; + + if (param_1 != 0) { + uVar1 = FUN_0040a980(); + return uVar1; + } + return 0; +} + + + +// --- FUN_0040eb40 at 0x0040EB40 (size: 22) --- + +undefined4 FUN_0040eb40(void) + +{ + undefined4 uVar1; + + if (DAT_008378d9 == '\0') { + return 0; + } + uVar1 = FUN_0040ea80(); + return uVar1; +} + + + +// --- FUN_0040eb60 at 0x0040EB60 (size: 22) --- + +undefined4 FUN_0040eb60(void) + +{ + undefined4 uVar1; + + if (DAT_008378d9 == '\0') { + return 0; + } + uVar1 = FUN_0040ead0(); + return uVar1; +} + + + +// --- FUN_0040eb80 at 0x0040EB80 (size: 292) --- + +/* WARNING: Function: __chkstk replaced with injection: alloca_probe */ + +int __thiscall FUN_0040eb80(int *param_1,int param_2,int param_3) + +{ + undefined4 uVar1; + LONG LVar2; + HANDLE pvVar3; + DWORD DVar4; + int iVar5; + undefined4 *puVar6; + int local_1004; + char local_1000 [4092]; + undefined4 uStack_4; + + uStack_4 = 0x40eb8a; + if (param_1[1] != 0) { +LAB_0040ec70: + iVar5 = param_1[2]; + puVar6 = (undefined4 *)(param_3 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar2 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + return iVar5; + } + if (*(int *)(param_3 + -4) != 1) { + FUN_00402070(¶m_3); + } + if (*(int *)(*param_1 + -4) == 1) { + uVar1 = FUN_0040c230(&local_1004); + FUN_00402070(uVar1); + LVar2 = InterlockedDecrement((LONG *)(local_1004 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(local_1004 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_1004 + -0x14))(1); + } + thunk_FUN_0040c720(param_1); + } + iVar5 = param_2; + if (param_2 == 0) { + iVar5 = 1; + } + do { + sprintf(local_1000,"%s_%d",*param_1,iVar5); + SetLastError(0); + pvVar3 = CreateMutexA((LPSECURITY_ATTRIBUTES)0x0,0,local_1000); + param_1[1] = (int)pvVar3; + if (pvVar3 != (HANDLE)0x0) { + DVar4 = GetLastError(); + if (DVar4 != 0xb7) { + param_1[2] = iVar5; + goto LAB_0040ec70; + } + CloseHandle((HANDLE)param_1[1]); + if (param_2 != 0) goto LAB_0040ec70; + } + iVar5 = iVar5 + 1; + } while( true ); +} + + + +// --- FUN_0040ecb0 at 0x0040ECB0 (size: 86) --- + +int * __thiscall FUN_0040ecb0(int *param_1,byte param_2) + +{ + LONG LVar1; + undefined4 *puVar2; + + if ((HANDLE)param_1[1] != (HANDLE)0x0) { + CloseHandle((HANDLE)param_1[1]); + param_1[1] = 0; + param_1[2] = 0; + } + puVar2 = (undefined4 *)(*param_1 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*param_1 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0040ed10 at 0x0040ED10 (size: 158) --- + +bool __thiscall FUN_0040ed10(int param_1,undefined4 *param_2) + +{ + int iVar1; + FILE *pFVar2; + + if (*(int *)((char *)*param_2 + -4) == 1) { + return false; + } + if (*(int *)(param_1 + 8) != 0) { + iVar1 = _stricmp(*(char **)(param_1 + 0x10),(char *)*param_2); + if (iVar1 == 0) { + return true; + } + fclose(*(FILE **)(param_1 + 8)); + if (*(int *)(param_1 + 0x14) != 0) { + FUN_0040ecb0(1); + } + *(undefined4 *)(param_1 + 0x14) = 0; + } + pFVar2 = fopen(*(char **)(param_1 + 0x10),"w"); + *(FILE **)(param_1 + 8) = pFVar2; + if (pFVar2 != (FILE *)0x0) { + FUN_00402070(param_2); + return *(int *)(param_1 + 8) != 0; + } + FUN_00404cd0(); + return *(int *)(param_1 + 8) != 0; +} + + + +// --- FUN_0040edb0 at 0x0040EDB0 (size: 93) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 __thiscall FUN_0040edb0(int *param_1,undefined4 param_2,undefined4 param_3,char *param_4) + +{ + if ((char)param_1[3] != '\0') { + FUN_0040ed10(); + *(undefined1 *)(param_1 + 3) = 0; + } + if ((FILE *)param_1[2] != (FILE *)0x0) { + fprintf((FILE *)param_1[2],"%0.3lf: ",_DAT_008379a8); + fputs(param_4,(FILE *)param_1[2]); + (**(code **)(*param_1 + 8))(); + return 1; + } + return 0; +} + + + +// --- FUN_0040ee10 at 0x0040EE10 (size: 112) --- + +int * __thiscall FUN_0040ee10(int *param_1,int param_2,char param_3,undefined4 param_4) + +{ + LONG LVar1; + undefined *puVar2; + + *param_1 = param_2; + InterlockedIncrement((LONG *)(param_2 + -0x10)); + param_1[1] = 0; + param_1[2] = 0; + if (param_3 != '\0') { + puVar2 = PTR_DAT_008183b4; + InterlockedIncrement((LONG *)(PTR_DAT_008183b4 + -0x10)); + FUN_0040eb80(param_4,puVar2); + } + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(param_2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_2 + -0x14))(1); + } + return param_1; +} + + + +// --- FUN_0040ee80 at 0x0040EE80 (size: 91) --- + +undefined1 __thiscall FUN_0040ee80(int *param_1,uint param_2,char param_3) + +{ + char cVar1; + uint uVar2; + + if ((param_1[1] & 0x7fffffffU) < param_2) { + uVar2 = param_2; + if (param_3 == '\0') { + uVar2 = FUN_00453850(param_2); + } + cVar1 = FUN_004180a0(uVar2); + if (cVar1 == '\0') { + return 0; + } + } + else { + uVar2 = param_2; + if (param_2 < (uint)param_1[2]) { + do { + *(undefined4 *)(*param_1 + uVar2 * 4) = 0; + uVar2 = uVar2 + 1; + } while (uVar2 < (uint)param_1[2]); + } + } + param_1[2] = param_2; + return 1; +} + + + +// --- FUN_0040eee0 at 0x0040EEE0 (size: 144) --- + +void __fastcall FUN_0040eee0(undefined4 *param_1) + +{ + int *piVar1; + LONG LVar2; + undefined4 *puVar3; + + *param_1 = &PTR_FUN_007955c0; + if ((FILE *)param_1[2] != (FILE *)0x0) { + fclose((FILE *)param_1[2]); + } + piVar1 = (int *)param_1[5]; + if (piVar1 != (int *)0x0) { + if ((HANDLE)piVar1[1] != (HANDLE)0x0) { + CloseHandle((HANDLE)piVar1[1]); + piVar1[1] = 0; + piVar1[2] = 0; + } + puVar3 = (undefined4 *)(*piVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(*piVar1 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + operator_delete(piVar1); + } + puVar3 = (undefined4 *)(param_1[4] + -0x14); + param_1[5] = 0; + LVar2 = InterlockedDecrement((LONG *)(param_1[4] + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + *param_1 = &PTR_FUN_007952f4; + return; +} + + + +// --- FUN_0040ef70 at 0x0040EF70 (size: 66) --- + +undefined4 __thiscall FUN_0040ef70(int *param_1,undefined4 param_2,undefined4 param_3,char *param_4) + +{ + if ((char)param_1[3] != '\0') { + FUN_0040ed10(param_1 + 4); + *(undefined1 *)(param_1 + 3) = 0; + } + if ((FILE *)param_1[2] != (FILE *)0x0) { + fputs(param_4,(FILE *)param_1[2]); + (**(code **)(*param_1 + 8))(); + return 1; + } + return 0; +} + + + +// --- FUN_0040f020 at 0x0040F020 (size: 72) --- + +undefined4 * __thiscall FUN_0040f020(undefined4 *param_1,undefined4 param_2) + +{ + param_1[1] = 1; + *(undefined1 *)(param_1 + 3) = 1; + *param_1 = &PTR_FUN_007955c0; + param_1[2] = 0; + FUN_00401340(param_2); + param_1[5] = 0; + DeleteFileA((LPCSTR)param_1[4]); + *param_1 = &PTR_FUN_007955ec; + return param_1; +} + + + +// --- FUN_0040f070 at 0x0040F070 (size: 103) --- + +void __thiscall FUN_0040f070(int param_1,int param_2,uint param_3,undefined4 param_4) + +{ + int iVar1; + uint *puVar2; + + if (*(char *)(param_2 + 0x98 + param_1) == '\0') { + if ((*(uint *)(param_1 + 0x68) != 0) && + (puVar2 = *(uint **)(*(int *)(param_1 + 0x60) + (param_3 % *(uint *)(param_1 + 0x68)) * 4), + puVar2 != (uint *)0x0)) { + do { + if (*puVar2 == param_3) break; + puVar2 = (uint *)puVar2[1]; + } while (puVar2 != (uint *)0x0); + if (puVar2 != (uint *)0x0) { + if ((char)puVar2[2] == '\0') { + return; + } + iVar1 = FUN_0040e910(param_2,param_3,param_4); + if (iVar1 != 2) { + return; + } + } + } + FUN_0040e910(param_2,param_3,param_4); + } + return; +} + + + +// --- FUN_0040f0e0 at 0x0040F0E0 (size: 35) --- + +void FUN_0040f0e0(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + if (DAT_008378d9 != '\0') { + FUN_0040f070(param_1,param_2,param_3); + } + return; +} + + + +// --- FUN_0040f110 at 0x0040F110 (size: 106) --- + +void FUN_0040f110(undefined4 param_1) + +{ + undefined *puVar1; + LONG LVar2; + undefined4 *puVar3; + undefined *local_4; + + local_4 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00402710(&local_4,&DAT_0079559c,param_1); + puVar1 = local_4; + if (*(int *)(local_4 + -4) != 1) { + FUN_00404ef0(local_4,*(int *)(local_4 + -4) + -1); + } + puVar3 = (undefined4 *)(puVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + return; +} + + + +// --- FUN_0040f180 at 0x0040F180 (size: 430) --- + +undefined4 * __thiscall FUN_0040f180(undefined4 *param_1,int param_2) + +{ + int iVar1; + LONG LVar2; + undefined4 *puVar3; + undefined *puVar4; + undefined4 uVar5; + undefined4 uVar6; + undefined4 *local_4; + + param_1[1] = 1; + *param_1 = &PTR_FUN_007955c0; + param_1[2] = 0; + *(undefined1 *)(param_1 + 3) = 1; + puVar4 = PTR_DAT_00818344; + param_1[4] = PTR_DAT_00818344; + local_4 = param_1; + InterlockedIncrement((LONG *)(puVar4 + -0x10)); + FUN_0040c230(&local_4); + if ((char)param_2 != '\0') { + thunk_FUN_0040c720(&local_4); + } + FUN_0040cda0(&local_4); + iVar1 = FUN_005df0f5(0xc); + if (iVar1 == 0) { + uVar5 = 0; + } + else { + uVar6 = 0; + uVar5 = 0; + puVar4 = PTR_DAT_008183b4; + InterlockedIncrement((LONG *)(PTR_DAT_008183b4 + -0x10)); + uVar5 = FUN_0040ee10(puVar4,uVar5,uVar6); + } + param_1[5] = uVar5; + puVar4 = PTR_DAT_008183b4; + InterlockedIncrement((LONG *)(PTR_DAT_008183b4 + -0x10)); + iVar1 = FUN_0040eb80(0,puVar4); + if (iVar1 != 1) { + FUN_00401340(&DAT_00795500); + if (*(int *)(param_2 + -4) != 1) { + FUN_00404ef0(param_2,*(int *)(param_2 + -4) + -1); + } + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(param_2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_2 + -0x14))(1); + } + FUN_0040f110(iVar1); + } + FUN_00401340(&DAT_00795600); + if (*(int *)(param_2 + -4) != 1) { + FUN_00404ef0(param_2,*(int *)(param_2 + -4) + -1); + } + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(param_2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_2 + -0x14))(1); + } + puVar3 = (undefined4 *)param_1[4]; + if (puVar3 != local_4) { + LVar2 = InterlockedDecrement(puVar3 + -4); + if ((LVar2 == 0) && (puVar3 + -5 != (undefined4 *)0x0)) { + (**(code **)puVar3[-5])(1); + } + param_1[4] = local_4; + InterlockedIncrement(local_4 + -4); + } + DeleteFileA((LPCSTR)param_1[4]); + puVar3 = local_4 + -5; + LVar2 = InterlockedDecrement(local_4 + -4); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + return param_1; +} + + + +// --- FUN_0040f330 at 0x0040F330 (size: 30) --- + +void * __thiscall FUN_0040f330(void *param_1,byte param_2) + +{ + FUN_0040eee0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0040f350 at 0x0040F350 (size: 84) --- + +undefined4 __thiscall FUN_0040f350(int param_1,undefined4 param_2) + +{ + undefined4 *puVar1; + + if (*(int *)(param_1 + 0xa0) == 0) { + puVar1 = (undefined4 *)FUN_005df0f5(0x18); + if (puVar1 == (undefined4 *)0x0) { + puVar1 = (undefined4 *)0x0; + } + else { + FUN_0040f180(param_2); + *puVar1 = &PTR_FUN_007955ec; + } + *(undefined4 **)(param_1 + 0xa0) = puVar1; + } + InterlockedIncrement((LONG *)(*(int *)(param_1 + 0xa0) + 4)); + return *(undefined4 *)(param_1 + 0xa0); +} + + + +// --- FUN_0040f3b0 at 0x0040F3B0 (size: 105) --- + +undefined4 __fastcall FUN_0040f3b0(int param_1) + +{ + undefined4 *puVar1; + int iVar2; + LONG LVar3; + uint uVar4; + + while (*(int *)(param_1 + 0x14) != 0) { + iVar2 = *(int *)(param_1 + 0x14) + -1; + *(int *)(param_1 + 0x14) = iVar2; + puVar1 = *(undefined4 **)(*(int *)(param_1 + 0xc) + iVar2 * 4); + *(undefined4 *)(*(int *)(param_1 + 0xc) + iVar2 * 4) = 0; + LVar3 = InterlockedDecrement(puVar1 + 1); + if ((LVar3 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + } + uVar4 = 0; + if (*(int *)(param_1 + 0x20) != 0) { + do { + *(undefined4 *)(*(int *)(param_1 + 0x18) + uVar4 * 4) = 0; + uVar4 = uVar4 + 1; + } while (uVar4 < *(uint *)(param_1 + 0x20)); + } + *(undefined4 *)(param_1 + 0x20) = 0; + return CONCAT31((int3)(uVar4 >> 8),1); +} + + + +// --- FUN_0040f420 at 0x0040F420 (size: 118) --- + +/* WARNING: Function: __chkstk replaced with injection: alloca_probe */ +/* WARNING: Removing unreachable block (ram,0x0040f486) */ + +void FUN_0040f420(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4) + +{ + undefined1 local_1000 [4092]; + undefined4 uStack_4; + + uStack_4 = 0x40f42a; + if (DAT_008378d9 != '\0') { + FUN_004062a0(param_3,param_4); + if (DAT_008378d9 != '\0') { + FUN_0040f070(param_1,param_2,local_1000); + } + } + return; +} + + + +// --- FUN_0040f4a0 at 0x0040F4A0 (size: 30) --- + +void FUN_0040f4a0(undefined4 *param_1,undefined4 param_2) + +{ + FUN_0040f420(*param_1,param_1[1],param_2,&stack0x0000000c); + return; +} + + + +// --- FUN_0040f4c0 at 0x0040F4C0 (size: 25) --- + +undefined4 FUN_0040f4c0(void) + +{ + undefined4 uVar1; + + if (DAT_008378d9 == '\0') { + return 0; + } + uVar1 = FUN_0040f350(0); + return uVar1; +} + + + +// --- FUN_0040f4e0 at 0x0040F4E0 (size: 109) --- + +uint __thiscall FUN_0040f4e0(int *param_1,int *param_2) + +{ + int iVar1; + uint uVar2; + undefined4 uVar3; + int *piVar4; + + uVar2 = 0; + if (param_1[2] != 0) { + piVar4 = (int *)*param_1; + do { + if (*piVar4 == *param_2) { + if (uVar2 != 0xffffffff) goto LAB_0040f52f; + break; + } + uVar2 = uVar2 + 1; + piVar4 = piVar4 + 1; + } while (uVar2 < (uint)param_1[2]); + } + if ((param_1[1] & 0x7fffffffU) <= (uint)param_1[2]) { + uVar3 = FUN_004077f0((param_1[1] & 0x7fffffffU) + 1); + uVar2 = FUN_00408220(uVar3); + if ((char)uVar2 == '\0') { +LAB_0040f52f: + return uVar2 & 0xffffff00; + } + } + iVar1 = param_1[2]; + *(int *)(*param_1 + iVar1 * 4) = *param_2; + param_1[2] = param_1[2] + 1; + return CONCAT31((int3)((uint)iVar1 >> 8),1); +} + + + +// --- FUN_0040f550 at 0x0040F550 (size: 151) --- + +undefined4 * __thiscall FUN_0040f550(undefined4 *param_1,uint param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + uint local_4; + + local_4 = param_2; + param_2 = param_2 & 0xffffff00; + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_007955bc; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_004064a0(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 * 4); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_0040f5f0 at 0x0040F5F0 (size: 101) --- + +undefined4 __thiscall FUN_0040f5f0(int param_1,int param_2,undefined4 param_3) + +{ + char cVar1; + uint uVar2; + undefined4 uVar3; + + cVar1 = FUN_0040f4e0(¶m_2); + if (cVar1 == '\0') { + return 0; + } + InterlockedIncrement((LONG *)(param_2 + 4)); + uVar2 = *(uint *)(param_1 + 0x1c) & 0x7fffffff; + if (uVar2 <= *(uint *)(param_1 + 0x20)) { + uVar3 = FUN_00453850(uVar2 + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 == '\0') { + return 1; + } + } + *(undefined4 *)(*(int *)(param_1 + 0x18) + *(int *)(param_1 + 0x20) * 4) = param_3; + *(int *)(param_1 + 0x20) = *(int *)(param_1 + 0x20) + 1; + return 1; +} + + + +// --- FUN_0040f660 at 0x0040F660 (size: 79) --- + +uint __thiscall FUN_0040f660(int param_1,uint *param_2) + +{ + uint *puVar1; + uint *puVar2; + + puVar1 = (uint *)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + puVar2 = (uint *)*puVar1; + do { + if (puVar2 == (uint *)0x0) { +LAB_0040f68b: + param_2[1] = *puVar1; + *puVar1 = (uint)param_2; + if (puVar1 < *(uint **)(param_1 + 100)) { + *(uint **)(param_1 + 100) = puVar1; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + return 1; + } + if (*puVar2 == *param_2) { + if (puVar2 != (uint *)0x0) { + return (uint)puVar2 & 0xffffff00; + } + goto LAB_0040f68b; + } + puVar2 = (uint *)puVar2[1]; + } while( true ); +} + + + +// --- FUN_0040f6c0 at 0x0040F6C0 (size: 188) --- + +void __fastcall FUN_0040f6c0(int param_1) + +{ + int iVar1; + void *pvVar2; + void *pvVar3; + int *piVar4; + void *pvVar5; + + iVar1 = *(int *)(param_1 + 0x6c); + do { + if (iVar1 == 0) { + return; + } + piVar4 = *(int **)(param_1 + 100); + while (piVar4 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar4 = *(int **)(param_1 + 100); + pvVar5 = (void *)*piVar4; + goto LAB_0040f6ff; + } + piVar4 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar4; + } + piVar4 = (int *)0x0; + pvVar5 = (void *)0x0; +LAB_0040f6ff: + pvVar3 = (void *)*piVar4; + if (pvVar3 == pvVar5) { +LAB_0040f712: + *piVar4 = *(int *)((int)pvVar3 + 4); + } + else { + do { + pvVar2 = pvVar3; + pvVar3 = *(void **)((int)pvVar2 + 4); + } while (pvVar3 != pvVar5); + if (pvVar2 == (void *)0x0) goto LAB_0040f712; + *(undefined4 *)((int)pvVar2 + 4) = *(undefined4 *)((int)pvVar3 + 4); + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + if (pvVar5 != (void *)0x0) { + FUN_0040f3b0(); + if ((*(uint *)((int)pvVar5 + 0x1c) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)((int)pvVar5 + 0x18)); + } + if ((*(uint *)((int)pvVar5 + 0x10) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)((int)pvVar5 + 0xc)); + } + operator_delete(pvVar5); + } + iVar1 = *(int *)(param_1 + 0x6c); + } while( true ); +} + + + +// --- FUN_0040f780 at 0x0040F780 (size: 98) --- + +int __fastcall FUN_0040f780(int param_1) + +{ + FUN_0040f550(10); + *(undefined4 *)(param_1 + 0x70) = 10; + *(undefined4 *)(param_1 + 0x74) = 0; + *(undefined4 *)(param_1 + 0x78) = 0; + *(undefined1 *)(param_1 + 0x7c) = 1; + *(undefined4 *)(param_1 + 0x80) = 0; + *(undefined4 *)(param_1 + 0x84) = 0; + *(undefined4 *)(param_1 + 0x88) = 0; + *(undefined4 *)(param_1 + 0x8c) = 0; + *(undefined4 *)(param_1 + 0x90) = 0; + *(undefined4 *)(param_1 + 0x94) = 0; + *(undefined4 *)(param_1 + 0xa0) = 0; + *(undefined4 *)(param_1 + 0xa4) = 0; + *(undefined4 *)(param_1 + 0xa8) = 0; + *(undefined4 *)(param_1 + 0x98) = 0; + *(undefined2 *)(param_1 + 0x9c) = 0; + FUN_0040f660((undefined4 *)(param_1 + 0x74)); + DAT_008378d8 = 1; + return param_1; +} + + + +// --- FUN_0040f7f0 at 0x0040F7F0 (size: 265) --- + +void __fastcall FUN_0040f7f0(undefined4 *param_1) + +{ + undefined4 *puVar1; + LONG LVar2; + + DAT_008378d8 = 0; + DAT_008378d9 = 0; + FUN_00410e70(&DAT_00795598); + FUN_0040f6c0(); + puVar1 = (undefined4 *)param_1[0x28]; + if (puVar1 != (undefined4 *)0x0) { + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + param_1[0x28] = 0; + } + puVar1 = (undefined4 *)param_1[0x29]; + if (puVar1 != (undefined4 *)0x0) { + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + param_1[0x29] = 0; + } + puVar1 = (undefined4 *)param_1[0x2a]; + if (puVar1 != (undefined4 *)0x0) { + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + param_1[0x2a] = 0; + } + FUN_0040f3b0(); + if ((param_1[0x24] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0x23]); + } + if ((param_1[0x21] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0x20]); + } + *param_1 = &PTR_FUN_007955bc; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + return; +} + + + +// --- FUN_0040f900 at 0x0040F900 (size: 134) --- + +undefined4 __thiscall FUN_0040f900(int param_1,uint param_2,undefined4 param_3) + +{ + uint *puVar1; + + for (puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + (param_2 % *(uint *)(param_1 + 0x68)) * 4); + (puVar1 != (uint *)0x0 && (*puVar1 != param_2)); puVar1 = (uint *)puVar1[1]) { + } + if (puVar1 == (uint *)0x0) { + puVar1 = (uint *)FUN_005df0f5(0x24); + if (puVar1 == (uint *)0x0) { + puVar1 = (uint *)0x0; + } + else { + *puVar1 = param_2; + puVar1[1] = 0; + *(undefined1 *)(puVar1 + 2) = 1; + puVar1[3] = 0; + puVar1[4] = 0; + puVar1[5] = 0; + puVar1[6] = 0; + puVar1[7] = 0; + puVar1[8] = 0; + } + FUN_0040f660(puVar1); + } + *(int *)(param_1 + 0x70) = *(int *)(param_1 + 0x70) + 1; + FUN_0040f5f0(param_3,*(undefined4 *)(param_1 + 0x70)); + return *(undefined4 *)(param_1 + 0x70); +} + + + +// --- FUN_0040f990 at 0x0040F990 (size: 166) --- + +void __thiscall FUN_0040f990(int param_1,undefined4 param_2) + +{ + undefined4 *puVar1; + LONG LVar2; + + puVar1 = (undefined4 *)FUN_0040f350(param_2); + FUN_0040f5f0(puVar1,0); + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + if (*(int *)(param_1 + 0xa8) == 0) { + puVar1 = (undefined4 *)FUN_005df0f5(8); + if (puVar1 == (undefined4 *)0x0) { + puVar1 = (undefined4 *)0x0; + } + else { + puVar1[1] = 1; + *puVar1 = &PTR_FUN_007955b0; + } + *(undefined4 **)(param_1 + 0xa8) = puVar1; + } + InterlockedIncrement((LONG *)(*(int *)(param_1 + 0xa8) + 4)); + puVar1 = *(undefined4 **)(param_1 + 0xa8); + FUN_0040f5f0(puVar1,1); + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + return; +} + + + +// --- FUN_0040fa40 at 0x0040FA40 (size: 32) --- + +void FUN_0040fa40(undefined4 param_1) + +{ + if (DAT_008378d9 == '\0') { + FUN_0040f990(param_1); + DAT_008378d9 = '\x01'; + } + return; +} + + + +// --- FUN_0040fa60 at 0x0040FA60 (size: 33) --- + +undefined4 FUN_0040fa60(undefined4 param_1,undefined4 param_2) + +{ + undefined4 uVar1; + + if (DAT_008378d9 == '\0') { + return 0; + } + uVar1 = FUN_0040f900(param_1,param_2); + return uVar1; +} + + + +// --- FUN_0040fa90 at 0x0040FA90 (size: 12) --- + +time_t FUN_0040fa90(void) + +{ + time_t tVar1; + + tVar1 = time((time_t *)0x0); + return tVar1; +} + + + +// --- FUN_0040faa0 at 0x0040FAA0 (size: 39) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +float10 FUN_0040faa0(void) + +{ + int iVar1; + float10 fVar2; + + iVar1 = DAT_008379a0; + if (DAT_008379b8 == '\0') { + return (float10)_DAT_00795610; + } + fVar2 = (float10)FUN_00411280(0); + return fVar2 + (float10)*(double *)(iVar1 + 0x58); +} + + + +// --- FUN_0040fad0 at 0x0040FAD0 (size: 33) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +float10 FUN_0040fad0(void) + +{ + float10 fVar1; + + if (DAT_008379b8 == '\0') { + return (float10)_DAT_00795610; + } + fVar1 = (float10)FUN_00411280(0); + return fVar1; +} + + + +// --- FUN_0040fb00 at 0x0040FB00 (size: 194) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_0040fb00(double *param_1) + +{ + double *pdVar1; + double *pdVar2; + double dVar3; + double dVar4; + int iVar5; + float10 fVar6; + + iVar5 = DAT_008379a0; + if (DAT_008379b8 != '\0') { + dVar3 = *param_1; + pdVar1 = (double *)(DAT_008379a0 + 0x68); + if (*(double *)(DAT_008379a0 + 0x68) < dVar3) { + dVar4 = *(double *)(DAT_008379a0 + 0x60); + pdVar2 = (double *)(DAT_008379a0 + 0x60); + fVar6 = (float10)FUN_00411280(1); + *pdVar2 = (double)fVar6; + if (fVar6 <= (float10)dVar4) { + *pdVar2 = dVar4; + } + else { + *pdVar1 = (double)(fVar6 + (float10)*(double *)(iVar5 + 0x58)); + } + if (*pdVar1 + _DAT_00795608 < dVar3) { + *(double *)(iVar5 + 0x58) = dVar3 - *pdVar2; + *pdVar1 = dVar3; + } + else if (_DAT_00795608 + dVar3 < *pdVar1) { + *pdVar2 = *pdVar2 - (*pdVar1 - dVar3); + *pdVar1 = dVar3; + } + } + _DAT_008379b0 = *(undefined8 *)(DAT_008379a0 + 0x60); + _DAT_008379a8 = *(undefined8 *)(DAT_008379a0 + 0x68); + } + return; +} + + + +// --- FUN_0040fbd0 at 0x0040FBD0 (size: 99) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_0040fbd0(void) + +{ + double *pdVar1; + double dVar2; + int iVar3; + float10 fVar4; + + iVar3 = DAT_008379a0; + if (DAT_008379b8 != '\0') { + dVar2 = *(double *)(DAT_008379a0 + 0x60); + pdVar1 = (double *)(DAT_008379a0 + 0x60); + fVar4 = (float10)FUN_00411280(1); + *pdVar1 = (double)fVar4; + if (fVar4 <= (float10)dVar2) { + *pdVar1 = dVar2; + } + else { + *(double *)(iVar3 + 0x68) = (double)(fVar4 + (float10)*(double *)(iVar3 + 0x58)); + } + _DAT_008379b0 = *(undefined8 *)(DAT_008379a0 + 0x60); + _DAT_008379a8 = *(undefined8 *)(DAT_008379a0 + 0x68); + } + return; +} + + + +// --- FUN_0040fc40 at 0x0040FC40 (size: 61) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 * __fastcall FUN_0040fc40(undefined4 *param_1) + +{ + param_1[1] = 1; + *param_1 = &PTR_FUN_007952f4; + FUN_00411190(); + *(undefined8 *)(param_1 + 0x16) = _DAT_00795610; + *param_1 = &PTR_FUN_007952f4; + *(undefined8 *)(param_1 + 0x18) = _DAT_00795610; + *(undefined8 *)(param_1 + 0x1a) = _DAT_00795610; + return param_1; +} + + + +// --- FUN_0040fc80 at 0x0040FC80 (size: 31) --- + +undefined4 * __thiscall FUN_0040fc80(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007952f4; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0040fca0 at 0x0040FCA0 (size: 44) --- + +void FUN_0040fca0(void) + +{ + int iVar1; + + if (DAT_008379a0 == 0) { + iVar1 = FUN_005df0f5(0x78); + if (iVar1 != 0) { + DAT_008379a0 = FUN_0040fc40(); + return; + } + DAT_008379a0 = 0; + } + return; +} + + + +// --- FUN_0040fcd0 at 0x0040FCD0 (size: 95) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_0040fcd0(void) + +{ + int iVar1; + + if (DAT_008379b8 == '\0') { + _DAT_008379a8 = _DAT_00795610; + _DAT_008379b0 = _DAT_00795610; + if (DAT_008379a0 == 0) { + iVar1 = FUN_005df0f5(0x78); + if (iVar1 == 0) { + DAT_008379a0 = 0; + } + else { + DAT_008379a0 = FUN_0040fc40(); + } + } + iVar1 = DAT_008379a0; + FUN_004111b0(); + *(undefined1 *)(iVar1 + 0x70) = 1; + DAT_008379b8 = '\x01'; + } + return; +} + + + +// --- FUN_0040fd30 at 0x0040FD30 (size: 170) --- + +uint __thiscall FUN_0040fd30(undefined4 *param_1,char *param_2) + +{ + uint *puVar1; + undefined2 *puVar2; + undefined4 *puVar3; + undefined4 *puVar4; + uint uVar5; + int iVar6; + + puVar1 = param_1 + 3; + puVar2 = (undefined2 *)((int)param_1 + 10); + puVar3 = param_1 + 2; + puVar4 = param_1 + 1; + iVar6 = sscanf(param_2,"%08lX-%04hX-%04hX-%04hX-%04hX%08lX",param_1,puVar4,(int)param_1 + 6,puVar3 + ,puVar2,puVar1); + if (iVar6 != 6) { + *puVar3 = 0; + *param_1 = 0; + *puVar4 = 0; + *puVar1 = 0; + return (uint)puVar4 & 0xffffff00; + } + *(ushort *)puVar3 = + CONCAT11((char)*(undefined2 *)puVar3,(char)((ushort)*(undefined2 *)puVar3 >> 8)); + *puVar2 = CONCAT11((char)*puVar2,(char)((ushort)*puVar2 >> 8)); + uVar5 = *puVar1; + *puVar1 = (uVar5 & 0xff0000 | uVar5 >> 0x10) >> 8 | (uVar5 & 0xff00 | uVar5 << 0x10) << 8; + return CONCAT31((int3)((uVar5 << 0x10) >> 8),1); +} + + + +// --- FUN_0040fde0 at 0x0040FDE0 (size: 152) --- + +undefined4 * __thiscall FUN_0040fde0(undefined4 *param_1,undefined4 *param_2) + +{ + undefined *puVar1; + LONG LVar2; + undefined4 *puVar3; + undefined *local_4; + + local_4 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00402710(&local_4,"%08X-%04hX-%04hX-%02X%02X-%02X%02X%02X%02X%02X%02X",*param_1, + *(undefined2 *)(param_1 + 1),*(undefined2 *)((int)param_1 + 6), + *(undefined1 *)(param_1 + 2),*(undefined1 *)((int)param_1 + 9), + *(undefined1 *)((int)param_1 + 10),*(undefined1 *)((int)param_1 + 0xb), + *(undefined1 *)(param_1 + 3),*(undefined1 *)((int)param_1 + 0xd), + *(undefined1 *)((int)param_1 + 0xe),*(undefined1 *)((int)param_1 + 0xf)); + puVar1 = local_4; + *param_2 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + puVar3 = (undefined4 *)(puVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + return param_2; +} + + + +// --- FUN_0040fe80 at 0x0040FE80 (size: 108) --- + +void __fastcall FUN_0040fe80(undefined1 *param_1) + +{ + HANDLE hConsoleOutput; + BOOL BVar1; + DWORD DVar2; + _CONSOLE_SCREEN_BUFFER_INFO local_18; + + *(undefined4 *)(param_1 + 4) = 0; + *(undefined2 *)(param_1 + 8) = 8; + *param_1 = 1; + hConsoleOutput = GetStdHandle(0xfffffff5); + BVar1 = GetConsoleScreenBufferInfo(hConsoleOutput,&local_18); + if (BVar1 == 0) { + DVar2 = GetLastError(); + fprintf((FILE *)(_iob_exref + 0x40),"GetConsoleScreenBufferInfo %d",DVar2); + return; + } + *(HANDLE *)(param_1 + 4) = hConsoleOutput; + *(WORD *)(param_1 + 8) = local_18.wAttributes; + *(WORD *)(param_1 + 10) = local_18.wAttributes; + return; +} + + + +// --- FUN_0040fef0 at 0x0040FEF0 (size: 46) --- + +void __thiscall FUN_0040fef0(char *param_1,byte param_2) + +{ + if (*param_1 == '\0') { + FUN_0040fe80(); + } + *(ushort *)(param_1 + 10) = *(ushort *)(param_1 + 10) ^ (byte)(param_1[10] ^ param_2) & 0xf; + SetConsoleTextAttribute(*(HANDLE *)(param_1 + 4),*(WORD *)(param_1 + 10)); + return; +} + + + +// --- FUN_0040ff20 at 0x0040FF20 (size: 48) --- + +void __thiscall FUN_0040ff20(char *param_1,byte param_2) + +{ + if (*param_1 == '\0') { + FUN_0040fe80(); + } + *(ushort *)(param_1 + 10) = *(ushort *)(param_1 + 10) ^ (byte)(param_1[10] ^ param_2) & 0xf0; + SetConsoleTextAttribute(*(HANDLE *)(param_1 + 4),*(WORD *)(param_1 + 10)); + return; +} + + + +// --- FUN_0040ff50 at 0x0040FF50 (size: 34) --- + +void __fastcall FUN_0040ff50(char *param_1) + +{ + if (*param_1 == '\0') { + FUN_0040fe80(); + } + *(WORD *)(param_1 + 10) = *(WORD *)(param_1 + 8); + SetConsoleTextAttribute(*(HANDLE *)(param_1 + 4),*(WORD *)(param_1 + 8)); + return; +} + + + +// --- FUN_0040ff80 at 0x0040FF80 (size: 552) --- + +char * FUN_0040ff80(char *param_1) + +{ + int iVar1; + bool bVar2; + bool bVar3; + int iVar4; + uint uVar5; + undefined2 extraout_var; + undefined2 extraout_var_00; + undefined2 uVar6; + char *_Src; + int *piVar7; + uint uVar8; + int local_34; + uint local_30; + char *local_2c; + int local_28 [10]; + + if ((*param_1 != '\x1b') || (local_2c = param_1, param_1[1] != '[')) { + return (char *)0x0; + } + _Src = param_1 + 2; + param_1 = (char *)0x0; + bVar2 = true; + piVar7 = local_28; + do { + iVar4 = sscanf(_Src,"%d%n",piVar7,&local_34); + if (iVar4 == 0) break; + _Src = _Src + local_34; + if (*_Src == ';') { + _Src = _Src + 1; + } + else { + bVar2 = false; + } + param_1 = (char *)((int)param_1 + 1); + piVar7 = piVar7 + 1; + } while (bVar2); + if (*_Src != 'm') { + return (char *)0x0; + } + if (param_1 == (char *)0x1) { + switch(local_28[0]) { + case 0: + FUN_0040ff50(); + return _Src + (1 - (int)local_2c); + case 1: + case 4: + uVar6 = extraout_var; + if (DAT_008379cc == '\0') { + FUN_0040fe80(); + uVar6 = extraout_var_00; + } + FUN_0040fef0(CONCAT31((int3)(CONCAT22(uVar6,DAT_008379d6) >> 8),(char)DAT_008379d6) | 8); + return _Src + (1 - (int)local_2c); + case 0x16: + case 0x18: + if (DAT_008379cc == '\0') { + FUN_0040fe80(); + } + FUN_0040fef0(DAT_008379d6 & 0xfff7); + return _Src + (1 - (int)local_2c); + } + } + if (DAT_008379cc == '\0') { + FUN_0040fe80(); + } + local_30 = CONCAT22(local_30._2_2_,DAT_008379d6); + bVar2 = false; + bVar3 = false; + if (0 < (int)param_1) { + iVar4 = 0; + uVar8 = local_30; + do { + iVar1 = local_28[iVar4]; + switch(iVar1) { + case 0: + bVar2 = true; + break; + case 1: + bVar3 = true; + break; + case 0x1e: + case 0x1f: + case 0x20: + case 0x21: + case 0x22: + case 0x23: + case 0x24: + case 0x25: + uVar5 = iVar1 - 0x1e; + uVar8 = uVar8 & 0xfff8; + if ((uVar5 & 1) != 0) { + uVar8 = uVar8 | 4; + } + if ((uVar5 & 2) != 0) { + uVar8 = uVar8 | 2; + } + if ((uVar5 & 4) != 0) { + uVar8 = uVar8 | 1; + } + if (bVar2) { + uVar8 = uVar8 & 0xfff7; + } + if (bVar3) { + uVar8 = uVar8 | 8; + } + FUN_0040fef0(uVar8); + goto LAB_0041017f; + case 0x28: + case 0x29: + case 0x2a: + case 0x2b: + case 0x2c: + case 0x2d: + case 0x2e: + case 0x2f: + uVar5 = iVar1 - 0x28; + uVar8 = uVar8 & 0xff8f; + if ((uVar5 & 1) != 0) { + uVar8 = uVar8 | 0x40; + } + if ((uVar5 & 2) != 0) { + uVar8 = uVar8 | 0x20; + } + if ((uVar5 & 4) != 0) { + uVar8 = uVar8 | 0x10; + } + if (bVar2) { + uVar8 = uVar8 & 0xff7f; + } + if (bVar3) { + uVar8 = uVar8 | 0x80; + } + FUN_0040ff20(uVar8); +LAB_0041017f: + bVar2 = false; + bVar3 = false; + } + iVar4 = iVar4 + 1; + } while (iVar4 < (int)param_1); + } + return _Src + (1 - (int)local_2c); +} + + + diff --git a/docs/research/decompiled/chunk_00410000.c b/docs/research/decompiled/chunk_00410000.c new file mode 100644 index 0000000..a806e2f --- /dev/null +++ b/docs/research/decompiled/chunk_00410000.c @@ -0,0 +1,13664 @@ +// Decompiled from acclient.exe — chunk 0x00410000 +// Ghidra 12.0.4 + pyghidra headless + +// --- FUN_00410220 at 0x00410220 (size: 122) --- + +int FUN_00410220(char *param_1) + +{ + char cVar1; + char *pcVar2; + int iVar3; + int iVar4; + + iVar3 = 0; + cVar1 = *param_1; + pcVar2 = param_1; + do { + if (cVar1 == '\0') { + if (*param_1 != '\0') { + iVar4 = 0; + pcVar2 = param_1; + do { + pcVar2 = pcVar2 + 1; + iVar4 = iVar4 + 1; + } while (*pcVar2 != '\0'); + if (iVar4 != 0) { + printf("%0.*s",iVar4,param_1); + iVar3 = iVar3 + iVar4; + } + } + return iVar3; + } + if (*pcVar2 == '\x1b') { + iVar4 = (int)pcVar2 - (int)param_1; + if (iVar4 != 0) { + printf("%0.*s",iVar4,param_1); + iVar3 = iVar3 + iVar4; + } + iVar4 = FUN_0040ff80(pcVar2); + if (iVar4 == 0) goto LAB_00410261; + param_1 = pcVar2 + iVar4; + pcVar2 = param_1; + } + else { +LAB_00410261: + pcVar2 = pcVar2 + 1; + } + cVar1 = *pcVar2; + } while( true ); +} + + + +// --- FUN_004102a0 at 0x004102A0 (size: 97) --- + +int FUN_004102a0(undefined4 param_1) + +{ + undefined *puVar1; + int iVar2; + LONG LVar3; + + puVar1 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + iVar2 = FUN_00402390(param_1,&stack0x00000008); + if (-1 < iVar2) { + iVar2 = FUN_00410220(puVar1); + } + LVar3 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + return iVar2; +} + + + +// --- FUN_00410310 at 0x00410310 (size: 49) --- + +void FUN_00410310(undefined4 *param_1,int param_2) + +{ + undefined4 *puVar1; + + FUN_0040ad10(4); + puVar1 = (undefined4 *)FUN_0040acf0(4); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *puVar1 = *param_1; + return; + } + *param_1 = *puVar1; + } + return; +} + + + +// --- FUN_00410350 at 0x00410350 (size: 89) --- + +void __fastcall FUN_00410350(int *param_1) + +{ + int iVar1; + int iVar2; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) != 0x80000000) { + if (*param_1 != 0) { + iVar2 = (param_1[1] & 0x7fffffffU) - 1; + while (-1 < iVar2) { + iVar1 = *param_1; + iVar2 = iVar2 + -1; + *(undefined4 *)(iVar1 + 8 + iVar2 * 8) = 0; + *(undefined4 *)(iVar1 + 0xc + iVar2 * 8) = 0; + } + } + return; + } + operator_delete__((void *)*param_1); + *param_1 = 0; + param_1[1] = 0; + return; +} + + + +// --- FUN_004103f0 at 0x004103F0 (size: 164) --- + +undefined4 __thiscall FUN_004103f0(int *param_1,uint param_2) + +{ + int iVar1; + int iVar2; + int iVar3; + + if (param_2 < (uint)param_1[2]) { + return 0; + } + if ((param_1[1] & 0x7fffffffU) < param_2) { + if (param_2 != 0) { + iVar2 = thunk_FUN_005df0f5(param_2 * 8); + if (iVar2 == 0) { + return 0; + } + if (*param_1 != 0) { + iVar3 = param_1[2] + -1; + while (-1 < iVar3) { + iVar3 = iVar3 + -1; + iVar1 = *param_1; + *(undefined4 *)(iVar2 + 8 + iVar3 * 8) = *(undefined4 *)(iVar1 + 8 + iVar3 * 8); + *(undefined4 *)(iVar2 + 0xc + iVar3 * 8) = *(undefined4 *)(iVar1 + 0xc + iVar3 * 8); + } + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + } + } + *param_1 = iVar2; + param_1[1] = param_2 | 0x80000000; + return 1; + } + FUN_00410350(); + } + return 1; +} + + + +// --- FUN_004104a0 at 0x004104A0 (size: 93) --- + +undefined1 __thiscall FUN_004104a0(int *param_1,uint param_2,char param_3) + +{ + int iVar1; + char cVar2; + uint uVar3; + + if ((param_1[1] & 0x7fffffffU) < param_2) { + uVar3 = param_2; + if (param_3 == '\0') { + uVar3 = FUN_004077f0(param_2); + } + cVar2 = FUN_004103f0(uVar3); + if (cVar2 == '\0') { + return 0; + } + } + else { + uVar3 = param_2; + if (param_2 < (uint)param_1[2]) { + do { + iVar1 = *param_1; + *(undefined4 *)(iVar1 + uVar3 * 8) = 0; + *(undefined4 *)(iVar1 + 4 + uVar3 * 8) = 0; + uVar3 = uVar3 + 1; + } while (uVar3 < (uint)param_1[2]); + } + } + param_1[2] = param_2; + return 1; +} + + + +// --- FUN_00410500 at 0x00410500 (size: 132) --- + +bool __thiscall FUN_00410500(int param_1,int param_2,int param_3) + +{ + uint uVar1; + char cVar2; + uint uVar3; + undefined4 uVar4; + int *piVar5; + + uVar1 = *(uint *)(param_1 + 0xc); + uVar3 = 0; + if (uVar1 != 0) { + piVar5 = *(int **)(param_1 + 4); + do { + if (*piVar5 == param_2) { + if (uVar3 != 0xffffffff) { + return (*(int **)(param_1 + 4))[uVar3 * 2 + 1] == param_3; + } + break; + } + uVar3 = uVar3 + 1; + piVar5 = piVar5 + 2; + } while (uVar3 < uVar1); + } + uVar3 = *(int *)(param_1 + 0xc) + 1; + if ((*(uint *)(param_1 + 8) & 0x7fffffff) < uVar3) { + uVar4 = FUN_004077f0(uVar3); + cVar2 = FUN_004103f0(uVar4); + if (cVar2 == '\0') goto LAB_00410557; + } + *(uint *)(param_1 + 0xc) = uVar3; +LAB_00410557: + *(int *)(*(int *)(param_1 + 4) + uVar1 * 8) = param_2; + *(int *)(*(int *)(param_1 + 4) + 4 + uVar1 * 8) = param_3; + return true; +} + + + +// --- FUN_00410590 at 0x00410590 (size: 157) --- + +void __thiscall FUN_00410590(int param_1,int param_2) + +{ + undefined4 *puVar1; + undefined4 *puVar2; + undefined4 uVar3; + int iVar4; + + uVar3 = *(undefined4 *)(param_1 + 0xc); + FUN_0040ad10(4); + puVar1 = (undefined4 *)FUN_0040acf0(4); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + uVar3 = *puVar1; + } + else { + *puVar1 = uVar3; + } + } + if ((*(uint *)(param_2 + 4) >> 2 & 1) == 0) { + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + FUN_004104a0(uVar3,1); + } + iVar4 = *(int *)(param_1 + 0xc); + while (iVar4 != 0) { + iVar4 = iVar4 + -1; + puVar1 = (undefined4 *)(*(int *)(param_1 + 4) + iVar4 * 8); + FUN_0040ad10(8); + puVar2 = (undefined4 *)FUN_0040acf0(8); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *puVar1 = *puVar2; + puVar1[1] = puVar2[1]; + } + else { + *puVar2 = *puVar1; + puVar2[1] = puVar1[1]; + } + } + } + } + return; +} + + + +// --- FUN_00410630 at 0x00410630 (size: 188) --- + +undefined4 FUN_00410630(int param_1) + +{ + char cVar1; + undefined4 uVar2; + uint *puVar3; + undefined4 uVar4; + uint uVar5; + + uVar2 = 0xffffffff; + if ((~(byte)(*(uint *)(param_1 + 4) >> 2) & 1) != 0) { + uVar2 = FUN_0040a8d0(); + uVar5 = 0x4d676963; + FUN_0040ad10(4); + puVar3 = (uint *)FUN_0040acf0(4); + if (puVar3 != (uint *)0x0) { + if ((*(byte *)(param_1 + 4) & 1) == 0) { + uVar5 = *puVar3; + } + else { + *puVar3 = 0x4d676963; + } + } + if ((~*(byte *)(param_1 + 4) & 1) != 0) { + if ((int)uVar5 < 0) { + uVar4 = FUN_0040a8d0(); + FUN_0040a8e0(uVar5 & 0x3fffffff); + FUN_00410590(param_1); + FUN_0040a8e0(uVar4); + return uVar2; + } + cVar1 = FUN_00410500(0x436f7265,uVar5 & 0x3fffffff); + if (cVar1 == '\0') { + FUN_0040aa50(); + } + } + } + return uVar2; +} + + + +// --- FUN_004106f0 at 0x004106F0 (size: 294) --- + +uint __thiscall FUN_004106f0(int param_1,uint param_2,int param_3) + +{ + int iVar1; + int iVar2; + byte bVar3; + uint *puVar4; + uint uVar5; + uint uVar6; + + iVar2 = param_3; + bVar3 = ~(byte)(*(uint *)(param_3 + 4) >> 2); + uVar6 = CONCAT31((uint3)(*(uint *)(param_3 + 4) >> 10),bVar3); + if (((bVar3 & 1) == 0) || (uVar6 = param_2, param_2 == 0xffffffff)) { + return uVar6 & 0xffffff00; + } + puVar4 = (uint *)FUN_0040ac70(param_2,4); + if (puVar4 == (uint *)0x0) goto LAB_00410786; + if ((~*(byte *)(iVar2 + 4) & 1) == 0) { + if (*puVar4 == 0x4d676963) { + iVar1 = *(int *)(param_1 + 0xc); + if ((iVar1 != 0) && ((iVar1 != 1 || (**(int **)(param_1 + 4) == 0x436f7265)))) { + if (iVar1 == 1) { + *puVar4 = 0xd676963; + *puVar4 = *(uint *)(*(int *)(param_1 + 4) + 4) & 0x3fffffff; + return ~(*(uint *)(iVar2 + 4) >> 2) & 1; + } + *puVar4 = 0x8d676963; + uVar6 = FUN_0040a8d0(); + *puVar4 = *puVar4 ^ (*puVar4 ^ uVar6) & 0x3fffffff; + FUN_00410590(iVar2); + return ~(*(uint *)(iVar2 + 4) >> 2) & 1; + } + } + } + else { + uVar6 = *puVar4; + if (-1 < (int)uVar6) goto LAB_00410786; + uVar5 = FUN_0040a8d0(); + if (uVar5 == (uVar6 & 0x3fffffff)) { + FUN_00410310(¶m_3,iVar2); + FUN_0040acf0(param_3 * 8); + return ~(*(uint *)(iVar2 + 4) >> 2) & 1; + } + if (-1 < (int)uVar6) goto LAB_00410786; + } + FUN_0040aa50(); +LAB_00410786: + return ~(*(uint *)(iVar2 + 4) >> 2) & 1; +} + + + +// --- FUN_00410820 at 0x00410820 (size: 81) --- + +void __thiscall FUN_00410820(int *param_1,int *param_2,int *param_3) + +{ + if (param_3 == (int *)0x0) { + *param_2 = *param_1; + if (*param_1 != 0) { + *(int **)(*param_1 + 4) = param_2; + *param_1 = (int)param_2; + param_2[1] = 0; + return; + } + param_1[1] = (int)param_2; + *param_1 = (int)param_2; + param_2[1] = 0; + return; + } + *param_2 = *param_3; + if (*param_3 != 0) { + *(int **)(*param_3 + 4) = param_2; + *param_3 = (int)param_2; + param_2[1] = (int)param_3; + return; + } + param_1[1] = (int)param_2; + *param_3 = (int)param_2; + param_2[1] = (int)param_3; + return; +} + + + +// --- FUN_00410880 at 0x00410880 (size: 80) --- + +void __thiscall FUN_00410880(int *param_1,int *param_2) + +{ + int iVar1; + undefined4 *puVar2; + + if ((int *)param_2[1] == (int *)0x0) { + iVar1 = *(int *)*param_1; + *param_1 = iVar1; + if (iVar1 != 0) { + *(undefined4 *)(iVar1 + 4) = 0; + } + } + else { + *(int *)param_2[1] = *param_2; + } + if (*param_2 != 0) { + *(int *)(*param_2 + 4) = param_2[1]; + *param_2 = 0; + param_2[1] = 0; + return; + } + puVar2 = *(undefined4 **)(param_1[1] + 4); + param_1[1] = (int)puVar2; + if (puVar2 != (undefined4 *)0x0) { + *puVar2 = 0; + } + *param_2 = 0; + param_2[1] = 0; + return; +} + + + +// --- FUN_004108d0 at 0x004108D0 (size: 149) --- + +void __thiscall FUN_004108d0(int param_1,undefined4 *param_2,int *param_3,int *param_4) + +{ + undefined4 *puVar1; + int *piVar2; + undefined4 **ppuVar3; + undefined4 *local_18; + undefined4 *local_14 [5]; + + piVar2 = &DAT_00795700; + local_18 = &DAT_00795700; + local_14[0] = (undefined4 *)0x0; + local_14[1] = &DAT_00795710; + local_14[2] = (undefined4 *)0x0; + local_14[3] = (undefined4 *)0x0; + local_14[4] = (undefined4 *)0x0; + ppuVar3 = &local_18; + while ((((*piVar2 != *param_3 || (piVar2[1] != param_3[1])) || (piVar2[2] != param_3[2])) || + (piVar2[3] != param_3[3]))) { + piVar2 = ppuVar3[2]; + ppuVar3 = ppuVar3 + 2; + if (piVar2 == (int *)0x0) { + *param_2 = 0x80004002; + return; + } + } + if (param_4 != (int *)0x0) { + puVar1 = ppuVar3[1]; + (**(code **)(*(int *)((int)puVar1 + param_1) + 0x10))(); + *param_4 = (int)puVar1 + param_1; + } + *param_2 = 0; + return; +} + + + +// --- FUN_00410a00 at 0x00410A00 (size: 133) --- + +int * __thiscall FUN_00410a00(int *param_1,int *param_2) + +{ + undefined4 *puVar1; + int iVar2; + char cVar3; + undefined4 *puVar4; + uint uVar5; + undefined4 *puVar6; + + if ((param_1[1] & 0x7fffffffU) < (param_2[1] & 0x7fffffffU)) { + param_1[2] = 0; + cVar3 = FUN_004103f0(param_2[1] & 0x7fffffff); + if (cVar3 == '\0') { + return param_1; + } + } + puVar4 = (undefined4 *)*param_2; + puVar1 = puVar4 + param_2[2] * 2; + puVar6 = (undefined4 *)*param_1; + for (; puVar4 < puVar1; puVar4 = puVar4 + 2) { + *puVar6 = *puVar4; + puVar6[1] = puVar4[1]; + puVar6 = puVar6 + 2; + } + uVar5 = param_2[2]; + if (uVar5 < (uint)param_1[2]) { + do { + iVar2 = *param_1; + *(undefined4 *)(iVar2 + uVar5 * 8) = 0; + *(undefined4 *)(iVar2 + 4 + uVar5 * 8) = 0; + uVar5 = uVar5 + 1; + } while (uVar5 < (uint)param_1[2]); + } + param_1[2] = param_2[2]; + return param_1; +} + + + +// --- FUN_00410a90 at 0x00410A90 (size: 82) --- + +void __fastcall FUN_00410a90(int param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + uint local_8; + undefined4 local_4; + + puVar1 = PTR_DAT_00818558; + local_4 = *(undefined4 *)(param_1 + 0x68); + local_8 = local_8 & 0xffffff00; + puVar2 = (undefined4 *)FUN_004064a0(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,local_8,0); + if ((puVar2 != (undefined4 *)puVar1) || (puVar2 = puVar2 + -1, puVar2 != (undefined4 *)puVar1)) { + puVar2 = puVar2 + 1; + } + FUN_00410b30(*puVar2); + return; +} + + + +// --- FUN_00410af0 at 0x00410AF0 (size: 58) --- + +int __thiscall FUN_00410af0(int param_1,uint param_2,undefined4 *param_3) + +{ + uint *puVar1; + uint3 uVar2; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x6c) + (param_2 % *(uint *)(param_1 + 0x74)) * 4); + uVar2 = (uint3)((uint)*(int *)(param_1 + 0x6c) >> 8); + do { + if (puVar1 == (uint *)0x0) { +LAB_00410b11: + return (uint)uVar2 << 8; + } + if (*puVar1 == param_2) { + if (puVar1 != (uint *)0x0) { + *param_3 = puVar1 + 4; + return CONCAT31(uVar2,1); + } + goto LAB_00410b11; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_00410b30 at 0x00410B30 (size: 234) --- + +undefined4 __thiscall FUN_00410b30(int param_1,int param_2) + +{ + int iVar1; + uint *puVar2; + int *piVar3; + undefined4 *puVar4; + uint uVar5; + uint *puVar6; + + if (param_2 == *(int *)(param_1 + 0x68)) { + return 0; + } + iVar1 = *(int *)(param_1 + 0x6c); + puVar2 = (uint *)0x0; + do { + if (iVar1 == 0) { + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_0065ec90(param_2); + while (puVar2 != (uint *)0x0) { + puVar6 = (uint *)puVar2[1]; + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + FUN_00410a90(); + } + uVar5 = *puVar2 % *(uint *)(param_1 + 0x68); + iVar1 = *(int *)(param_1 + 0x60); + puVar2[1] = *(uint *)(iVar1 + uVar5 * 4); + *(uint **)(iVar1 + uVar5 * 4) = puVar2; + uVar5 = iVar1 + uVar5 * 4; + if (uVar5 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar5; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + puVar2 = puVar6; + } + return 1; + } + piVar3 = *(int **)(param_1 + 100); + while (piVar3 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + puVar4 = *(undefined4 **)(param_1 + 100); + puVar6 = (uint *)*puVar4; + goto LAB_00410b7e; + } + piVar3 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar3; + } + puVar4 = (undefined4 *)0x0; + puVar6 = (uint *)0x0; +LAB_00410b7e: + FUN_00410d00(param_1,puVar4,puVar6); + puVar6[1] = (uint)puVar2; + iVar1 = *(int *)(param_1 + 0x6c); + puVar2 = puVar6; + } while( true ); +} + + + +// --- FUN_00410c20 at 0x00410C20 (size: 117) --- + +uint __thiscall FUN_00410c20(int param_1,uint *param_2) + +{ + uint *puVar1; + int iVar2; + uint uVar3; + + puVar1 = *(uint **)(*(uint *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + do { + if (puVar1 == (uint *)0x0) { +LAB_00410c4b: + if ((int)(*(uint *)(param_1 + 0x68) * 2) < *(int *)(param_1 + 0x6c) + 1) { + FUN_00410a90(); + } + uVar3 = *param_2 % *(uint *)(param_1 + 0x68); + iVar2 = *(int *)(param_1 + 0x60); + param_2[1] = *(uint *)(iVar2 + uVar3 * 4); + *(uint **)(iVar2 + uVar3 * 4) = param_2; + uVar3 = iVar2 + uVar3 * 4; + if (uVar3 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar3; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + return CONCAT31((int3)(uVar3 >> 8),1); + } + if (*puVar1 == *param_2) { + if (puVar1 != (uint *)0x0) { + return *(uint *)(param_1 + 0x60) & 0xffffff00; + } + goto LAB_00410c4b; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_00410ca0 at 0x00410CA0 (size: 82) --- + +undefined4 __thiscall FUN_00410ca0(int param_1,uint *param_2) + +{ + uint *puVar1; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + do { + if (puVar1 == (uint *)0x0) { +LAB_00410ccb: + FUN_00410c20(param_2); + FUN_00410820(param_2 + 2,*(undefined4 *)(param_1 + 0x74)); + return 1; + } + if (*puVar1 == *param_2) { + if (puVar1 != (uint *)0x0) { + return 0; + } + goto LAB_00410ccb; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_00410d00 at 0x00410D00 (size: 58) --- + +void __thiscall FUN_00410d00(int param_1,undefined4 param_2,int *param_3,int param_4) + +{ + int iVar1; + int iVar2; + + iVar2 = *param_3; + if (iVar2 != param_4) { + do { + iVar1 = iVar2; + iVar2 = *(int *)(iVar1 + 4); + } while (iVar2 != param_4); + if (iVar1 != 0) { + *(undefined4 *)(iVar1 + 4) = *(undefined4 *)(iVar2 + 4); + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + return; + } + } + *param_3 = *(int *)(iVar2 + 4); + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + return; +} + + + +// --- FUN_00410d40 at 0x00410D40 (size: 146) --- + +void __thiscall FUN_00410d40(int param_1,undefined4 *param_2) + +{ + undefined4 uVar1; + undefined4 *puVar2; + + *(int *)(param_1 + 0xe4) = *(int *)(param_1 + 0xe4) + 2; + uVar1 = *(undefined4 *)(param_1 + 0xe4); + if (*(int *)(param_1 + 0x78) == 0) { + *(undefined4 *)(param_1 + 0x84) = uVar1; + FUN_00410ca0((undefined4 *)(param_1 + 0x84)); + *param_2 = uVar1; + return; + } + puVar2 = (undefined4 *)FUN_005df0f5(0x60); + if (puVar2 != (undefined4 *)0x0) { + *puVar2 = uVar1; + puVar2[1] = 0; + puVar2[2] = 0; + puVar2[3] = 0; + puVar2[4] = &PTR_LAB_00795430; + puVar2[5] = puVar2 + 8; + puVar2[6] = 8; + puVar2[7] = 0; + FUN_00410ca0(puVar2); + *param_2 = uVar1; + return; + } + FUN_00410ca0(0); + *param_2 = uVar1; + return; +} + + + +// --- FUN_00410de0 at 0x00410DE0 (size: 136) --- + +void __thiscall FUN_00410de0(int param_1,undefined4 *param_2,int param_3) + +{ + undefined4 uVar1; + undefined4 *puVar2; + undefined4 *puVar3; + + *(int *)(param_1 + 0xe4) = *(int *)(param_1 + 0xe4) + 2; + uVar1 = *(undefined4 *)(param_1 + 0xe4); + if (*(int *)(param_1 + 0x78) == 0) { + *(undefined4 *)(param_1 + 0x84) = uVar1; + puVar3 = (undefined4 *)(param_1 + 0x84); + } + else { + puVar2 = (undefined4 *)FUN_005df0f5(0x60); + puVar3 = (undefined4 *)0x0; + if (puVar2 != (undefined4 *)0x0) { + puVar2[1] = 0; + *puVar2 = uVar1; + puVar2[2] = 0; + puVar2[3] = 0; + puVar2[4] = &PTR_LAB_00795430; + puVar2[7] = 0; + puVar2[5] = puVar2 + 8; + puVar2[6] = 8; + puVar3 = puVar2; + } + } + FUN_00410a00(param_3 + 4); + FUN_00410ca0(puVar3); + *param_2 = uVar1; + return; +} + + + +// --- FUN_00410e70 at 0x00410E70 (size: 81) --- + +uint * __thiscall FUN_00410e70(int param_1,uint *param_2) + +{ + uint *puVar1; + uint uVar2; + + uVar2 = *param_2 % *(uint *)(param_1 + 0x68); + puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + uVar2 * 4); + while( true ) { + if (puVar1 == (uint *)0x0) { + return (uint *)0x0; + } + if (*puVar1 == *param_2) break; + puVar1 = (uint *)puVar1[1]; + } + if (puVar1 == (uint *)0x0) { + return (uint *)0x0; + } + FUN_00410d00(param_1,*(int *)(param_1 + 0x60) + uVar2 * 4,puVar1); + return puVar1; +} + + + +// --- FUN_00410ed0 at 0x00410ED0 (size: 83) --- + +uint * __thiscall FUN_00410ed0(int param_1,uint *param_2) + +{ + uint *puVar1; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + if (puVar1 != (uint *)0x0) { + while (*puVar1 != *param_2) { + puVar1 = (uint *)puVar1[1]; + if (puVar1 == (uint *)0x0) { + return (uint *)0x0; + } + } + if (puVar1 != (uint *)0x0) { + FUN_00410880(puVar1 + 2); + FUN_00410e70(param_2); + } + } + return puVar1; +} + + + +// --- FUN_00410f30 at 0x00410F30 (size: 85) --- + +undefined4 __fastcall FUN_00410f30(int param_1) + +{ + void *pvVar1; + + pvVar1 = (void *)FUN_00410ed0(&stack0x00000004); + if (pvVar1 != (void *)0x0) { + if (pvVar1 != (void *)(param_1 + 0x84)) { + if ((*(uint *)((int)pvVar1 + 0x18) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)((int)pvVar1 + 0x14)); + } + operator_delete(pvVar1); + } + return 1; + } + return 0; +} + + + +// --- FUN_00410f90 at 0x00410F90 (size: 289) --- + +void __fastcall FUN_00410f90(int param_1) + +{ + int iVar1; + undefined4 *puVar2; + uint *puVar3; + uint *puVar4; + uint *puVar5; + uint *puVar6; + uint uVar7; + uint *local_8; + + if ((*(int *)(param_1 + 0x78) != 0) && (*(int *)(param_1 + 0x7c) != 0)) { + local_8 = (uint *)(*(int *)(param_1 + 0x7c) + -8); +joined_r0x00410fb1: + puVar4 = local_8; + if (puVar4 != (uint *)0x0) { + puVar6 = puVar4 + 2; + if (puVar4[2] == 0) { + local_8 = (uint *)0x0; + } + else { + local_8 = (uint *)(puVar4[2] - 8); + } + if ((uint *)puVar4[3] == (uint *)0x0) { + iVar1 = **(int **)(param_1 + 0x7c); + *(int *)(param_1 + 0x7c) = iVar1; + if (iVar1 != 0) { + *(undefined4 *)(iVar1 + 4) = 0; + } + } + else { + *(uint *)puVar4[3] = *puVar6; + } + if (*puVar6 == 0) { + puVar2 = *(undefined4 **)(*(int *)(param_1 + 0x80) + 4); + *(undefined4 **)(param_1 + 0x80) = puVar2; + if (puVar2 != (undefined4 *)0x0) { + *puVar2 = 0; + } + } + else { + *(uint *)(*puVar6 + 4) = puVar4[3]; + } + *puVar6 = 0; + puVar4[3] = 0; + uVar7 = *puVar4 % *(uint *)(param_1 + 0x74); + puVar6 = *(uint **)(*(int *)(param_1 + 0x6c) + uVar7 * 4); + for (puVar3 = puVar6; puVar3 != (uint *)0x0; puVar3 = (uint *)puVar3[1]) { + if (*puVar3 == *puVar4) { + if (puVar3 != (uint *)0x0) { + if (puVar6 != puVar3) goto LAB_00411050; + goto LAB_0041105d; + } + break; + } + } + goto LAB_0041106e; + } + } + return; +LAB_00411050: + do { + puVar5 = puVar6; + puVar6 = (uint *)puVar5[1]; + } while (puVar6 != puVar3); + if (puVar5 == (uint *)0x0) { +LAB_0041105d: + *(uint *)(*(int *)(param_1 + 0x6c) + uVar7 * 4) = puVar6[1]; + } + else { + puVar5[1] = puVar6[1]; + } + *(int *)(param_1 + 0x78) = *(int *)(param_1 + 0x78) + -1; +LAB_0041106e: + if (puVar4 != (uint *)(param_1 + 0x84)) { + if ((puVar4[6] & 0x80000000) == 0x80000000) { + operator_delete__((void *)puVar4[5]); + } + operator_delete(puVar4); + } + goto joined_r0x00410fb1; +} + + + +// --- FUN_004110c0 at 0x004110C0 (size: 96) --- + +void __fastcall FUN_004110c0(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_00795434; + FUN_00410f90(); + if ((param_1[0x27] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0x26]); + } + param_1[3] = &PTR_FUN_0079542c; + if ((undefined4 *)param_1[0x1b] != param_1 + 4) { + operator_delete__((undefined4 *)param_1[0x1b]); + } + param_1[0x1b] = 0; + param_1[0x1c] = 0; + param_1[0x1d] = 0; + param_1[0x1e] = 0; + param_1[1] = &PTR_LAB_00793b6c; + return; +} + + + +// --- FUN_00411120 at 0x00411120 (size: 25) --- + +PVOID __fastcall FUN_00411120(LPCVOID param_1) + +{ + _MEMORY_BASIC_INFORMATION local_1c; + + VirtualQuery(param_1,&local_1c,0x1c); + return local_1c.AllocationBase; +} + + + +// --- FUN_00411140 at 0x00411140 (size: 73) --- + +void __fastcall FUN_00411140(LONG *param_1) + +{ + int iVar1; + uint uVar2; + + uVar2 = 0; + iVar1 = InterlockedExchange(param_1,1); + while (iVar1 != 0) { + iVar1 = *param_1; + while (iVar1 != 0) { + uVar2 = uVar2 + 1; + if (0x1ff < uVar2) { + Sleep(0); + uVar2 = 0; + } + iVar1 = *param_1; + } + iVar1 = InterlockedExchange(param_1,1); + } + return; +} + + + +// --- FUN_00411190 at 0x00411190 (size: 17) --- + +void __fastcall FUN_00411190(int param_1) + +{ + *(undefined4 *)(param_1 + 0x40) = 0; + *(undefined4 *)(param_1 + 0x44) = 0; + *(undefined4 *)(param_1 + 0x48) = 0; + *(undefined4 *)(param_1 + 0x20) = 0; + return; +} + + + +// --- FUN_004111b0 at 0x004111B0 (size: 203) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __fastcall FUN_004111b0(double *param_1) + +{ + undefined4 uVar1; + undefined4 uVar2; + BOOL BVar3; + DWORD DVar4; + double dVar5; + LARGE_INTEGER local_8; + + BVar3 = QueryPerformanceFrequency(&local_8); + uVar2 = local_8.s.HighPart; + uVar1 = local_8.s.LowPart; + if (BVar3 != 0) { + dVar5 = (double)__alldiv(local_8.s.LowPart,local_8.s.HighPart,1000,0); + param_1[1] = dVar5; + dVar5 = (double)__alldiv(uVar1,uVar2,2,0); + *param_1 = (double)CONCAT44(local_8.s.HighPart,local_8.s.LowPart); + param_1[2] = dVar5; + QueryPerformanceCounter(&local_8); + } + FUN_00411140(); + dVar5 = _DAT_00795610; + if (((ulonglong)param_1[4] & 1) == 0) { + *(DWORD *)(param_1 + 7) = local_8.s.LowPart; + *(LONG *)((int)param_1 + 0x3c) = local_8.s.HighPart; + param_1[3] = dVar5; + param_1[5] = _DAT_00795610; + DVar4 = timeGetTime(); + *(DWORD *)(param_1 + 6) = DVar4; + if (BVar3 != 0) { + *(uint *)(param_1 + 4) = *(uint *)(param_1 + 4) & 0xfffffffd; + } + else { + *(uint *)(param_1 + 4) = *(uint *)(param_1 + 4) | 2; + } + *(uint *)(param_1 + 4) = *(uint *)(param_1 + 4) | 1; + } + InterlockedExchange((LONG *)(param_1 + 8),0); + return; +} + + + +// --- FUN_00411280 at 0x00411280 (size: 489) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +float10 __thiscall FUN_00411280(double *param_1,char param_2) + +{ + double dVar1; + DWORD DVar2; + int iVar3; + uint uVar4; + uint uVar5; + uint uVar6; + double *pdVar7; + double *pdVar8; + uint uVar9; + double *pdVar10; + undefined8 uVar11; + LARGE_INTEGER local_38; + double local_30; + uint local_28; + double local_20; + DWORD local_18; + uint local_10; + int local_c; + + FUN_00411140(); + pdVar10 = param_1 + 3; + pdVar7 = pdVar10; + pdVar8 = &local_30; + for (iVar3 = 10; iVar3 != 0; iVar3 = iVar3 + -1) { + *(undefined4 *)pdVar8 = *(undefined4 *)pdVar7; + pdVar7 = (double *)((int)pdVar7 + 4); + pdVar8 = (double *)((int)pdVar8 + 4); + } + InterlockedExchange((LONG *)(param_1 + 8),0); + if ((local_28 & 1) != 0) { + DVar2 = timeGetTime(); + uVar4 = DVar2 - local_18; + if ((local_28 & 2) == 0) { + QueryPerformanceCounter(&local_38); + uVar9 = local_38.s.LowPart - local_10; + uVar6 = (local_38.s.HighPart - local_c) - (uint)(local_38.s.LowPart < local_10); + uVar11 = __allmul(*(undefined4 *)(param_1 + 1),*(undefined4 *)((int)param_1 + 0xc),uVar4,0); + uVar5 = (int)((ulonglong)uVar11 >> 0x20) + *(int *)((int)param_1 + 0x14) + + (uint)CARRY4((uint)uVar11,*(uint *)(param_1 + 2)); + if ((uVar5 < uVar6) || ((uVar5 <= uVar6 && ((uint)uVar11 + *(int *)(param_1 + 2) <= uVar9)))) + { + dVar1 = (double)(int)uVar4; + local_28 = local_28 | 2; + if ((int)uVar4 < 0) { + dVar1 = dVar1 + _DAT_00795518; + } + dVar1 = dVar1 * _DAT_00795720 + local_20; + if (DAT_008379dd == '\0') { + DAT_008379dd = '\x01'; + } + if ((param_2 != '\0') && (DAT_008379dc == '\0')) { + DAT_008379dc = '\x01'; + } + } + else { + dVar1 = (-(double)(longlong)(((ulonglong)uVar6 & 0x80000000) << 0x20) + + (double)(CONCAT44(uVar6,uVar9) & 0x7fffffffffffffff)) / *param_1 + local_20; + } + } + else { + dVar1 = (double)(int)uVar4; + if ((int)uVar4 < 0) { + dVar1 = dVar1 + _DAT_00795518; + } + dVar1 = dVar1 * _DAT_00795720 + local_20; + } + if ((local_30 < dVar1) && (local_30 = dVar1, 9999 < uVar4)) { + local_10 = local_38.s.LowPart; + local_c = local_38.s.HighPart; + local_20 = dVar1; + local_18 = DVar2; + } + FUN_00411140(); + if (local_30 <= *pdVar10) { + local_30 = *pdVar10; + } + else if (param_2 == '\0') { + *pdVar10 = local_30; + } + else { + pdVar7 = &local_30; + for (iVar3 = 10; iVar3 != 0; iVar3 = iVar3 + -1) { + *(undefined4 *)pdVar10 = *(undefined4 *)pdVar7; + pdVar7 = (double *)((int)pdVar7 + 4); + pdVar10 = (double *)((int)pdVar10 + 4); + } + } + InterlockedExchange((LONG *)(param_1 + 8),0); + return (float10)local_30; + } + return (float10)_DAT_00795610; +} + + + +// --- FUN_00411470 at 0x00411470 (size: 25) --- + +void __fastcall FUN_00411470(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_00795824; + if (DAT_00837ff4 != (int *)0x0) { + (**(code **)(*DAT_00837ff4 + 0x3c))(param_1); + } + return; +} + + + +// --- FUN_00411490 at 0x00411490 (size: 47) --- + +undefined4 * __thiscall FUN_00411490(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795824; + if (DAT_00837ff4 != (int *)0x0) { + (**(code **)(*DAT_00837ff4 + 0x3c))(param_1); + } + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004114c0 at 0x004114C0 (size: 6) --- + +undefined4 FUN_004114c0(void) + +{ + return DAT_008379e4; +} + + + +// --- FUN_004114d0 at 0x004114D0 (size: 143) --- + +void __fastcall FUN_004114d0(int param_1) + +{ + if (*(int **)(param_1 + 0xb0) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0xb0) + 0x14))(); + *(undefined4 *)(param_1 + 0xb0) = 0; + } + if (DAT_0083e03c != 0) { + FUN_0045f200(); + FUN_00459310(); + } + if (*(int **)(param_1 + 0x118) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x118) + 0x1c))(); + if (*(int **)(param_1 + 0x118) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x118) + 0x14))(); + *(undefined4 *)(param_1 + 0x118) = 0; + } + } + if (*(int *)(param_1 + 0x120) != 0) { + FUN_004538e0(*(int *)(param_1 + 0x120)); + } + if (DAT_00837ff4 != (int *)0x0) { + (**(code **)(*DAT_00837ff4 + 0x3c))(param_1 + 0x24); + } + FUN_0043a370(); + FUN_00557ba0(); + /* WARNING: Could not recover jumptable at 0x00411559. Too many branches */ + /* WARNING: Treating indirect jump as call */ + CoUninitialize(); + return; +} + + + +// --- FUN_00411560 at 0x00411560 (size: 30) --- + +void __fastcall FUN_00411560(int param_1) + +{ + if (*(int **)(param_1 + 0xac) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0xac) + 0x14))(); + *(undefined4 *)(param_1 + 0xac) = 0; + } + return; +} + + + +// --- FUN_004115d0 at 0x004115D0 (size: 24) --- + +undefined4 __fastcall FUN_004115d0(int param_1) + +{ + FUN_00541640(1,param_1 + 0x74,0,0); + return 1; +} + + + +// --- FUN_004115f0 at 0x004115F0 (size: 50) --- + +undefined4 __fastcall FUN_004115f0(int param_1) + +{ + undefined4 in_EAX; + undefined3 uVar1; + undefined3 extraout_var; + + uVar1 = (undefined3)((uint)in_EAX >> 8); + if (*(char *)(param_1 + 0xb4) != '\0') { + if (*(int *)(param_1 + 0x100) != 0) { + FUN_00544ab0(); + } + (**(code **)(**(int **)(param_1 + 0xac) + 0x20))(); + *(undefined1 *)(param_1 + 0xb4) = 0; + uVar1 = extraout_var; + } + return CONCAT31(uVar1,1); +} + + + +// --- FUN_00411630 at 0x00411630 (size: 107) --- + +void __fastcall FUN_00411630(int param_1) + +{ + char cVar1; + + FUN_0040fbd0(); + cVar1 = FUN_00439e50(); + if (cVar1 != '\0') { + FUN_00543fc0(); + return; + } + FUN_00543440(); + (**(code **)(*(int *)(*(int *)(param_1 + 0xac) + 4) + 0x48))(); + FUN_0045d0b0(); + FUN_004554b0(); + FUN_0043e690(); + thunk_FUN_0043dc70(); + FUN_00455610(); + FUN_0043fcd0(1); + FUN_004392b0(); + return; +} + + + +// --- FUN_004116d0 at 0x004116D0 (size: 4) --- + +float10 __fastcall FUN_004116d0(int param_1) + +{ + return (float10)*(float *)(param_1 + 0x1c); +} + + + +// --- FUN_004116e0 at 0x004116E0 (size: 69) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +float10 __thiscall FUN_004116e0(int param_1,uint *param_2) + +{ + uint uVar1; + float10 fVar2; + + uVar1 = (uint)(*(int *)(param_1 + 8) == 3); + *param_2 = uVar1; + if (uVar1 == 0) { + fVar2 = (float10)_DAT_00795610; + } + else { + fVar2 = (float10)_DAT_008379a8 - (float10)*(double *)(param_1 + 0x10); + } + if ((*(int *)(param_1 + 0x2c) != 0) && ((float10)_DAT_00795870 < fVar2)) { + fVar2 = (float10)_DAT_00795870; + } + return fVar2; +} + + + +// --- FUN_00411760 at 0x00411760 (size: 67) --- + +uint FUN_00411760(undefined4 param_1) + +{ + int *piVar1; + undefined *puVar2; + undefined4 uVar3; + uint *puVar4; + uint local_8; + int local_4; + + puVar4 = &local_8; + uVar3 = 0; + puVar2 = &DAT_00795814; + piVar1 = &local_4; + local_8 = 0; + FUN_00406d10(piVar1,param_1,&DAT_00795814,0,&local_8); + FUN_00406650(piVar1,param_1,puVar2,uVar3,puVar4); + return (local_4 < 0) - 1 & local_8; +} + + + +// --- FUN_004117b0 at 0x004117B0 (size: 68) --- + +void __thiscall FUN_004117b0(int *param_1,int *param_2,uint param_3) + +{ + int iVar1; + uint uVar2; + + uVar2 = (**(code **)(*param_1 + 8))(); + if ((uVar2 <= param_3) && (3 < param_3)) { + *(int *)*param_2 = param_1[1]; + iVar1 = *param_2; + *param_2 = iVar1 + 4; + if (3 < param_3 - 4) { + *(int *)(iVar1 + 4) = param_1[2]; + *param_2 = *param_2 + 4; + } + } + (**(code **)(*param_1 + 8))(); + return; +} + + + +// --- FUN_00411800 at 0x00411800 (size: 70) --- + +undefined4 __thiscall FUN_00411800(int *param_1,int *param_2,uint param_3) + +{ + int iVar1; + uint uVar2; + + uVar2 = (**(code **)(*param_1 + 8))(); + if (param_3 < uVar2) { + return 0; + } + if (3 < param_3) { + param_1[1] = *(int *)*param_2; + iVar1 = *param_2; + *param_2 = iVar1 + 4; + if (3 < param_3 - 4) { + param_1[2] = *(int *)(iVar1 + 4); + *param_2 = *param_2 + 4; + } + } + return 1; +} + + + +// --- FUN_00411850 at 0x00411850 (size: 26) --- + +int * __fastcall FUN_00411850(int *param_1) + +{ + LONG *lpAddend; + + lpAddend = (LONG *)(DAT_008ef11c + 4); + *param_1 = DAT_008ef11c; + InterlockedIncrement(lpAddend); + return param_1; +} + + + +// --- FUN_00411870 at 0x00411870 (size: 90) --- + +void __fastcall FUN_00411870(int *param_1) + +{ + undefined4 *puVar1; + LONG LVar2; + uint uVar3; + uint uVar4; + undefined4 *puVar5; + undefined4 *puVar6; + + puVar1 = (undefined4 *)*param_1; + if (puVar1[1] == 1) { + puVar1[4] = 0xffffffff; + return; + } + FUN_00403560(puVar1[2] + -1); + uVar4 = *(uint *)(*param_1 + 8); + puVar5 = puVar1 + 5; + puVar6 = (undefined4 *)(*param_1 + 0x14); + for (uVar3 = uVar4 >> 2; uVar3 != 0; uVar3 = uVar3 - 1) { + *puVar6 = *puVar5; + puVar5 = puVar5 + 1; + puVar6 = puVar6 + 1; + } + for (uVar4 = uVar4 & 3; uVar4 != 0; uVar4 = uVar4 - 1) { + *(undefined1 *)puVar6 = *(undefined1 *)puVar5; + puVar5 = (undefined4 *)((int)puVar5 + 1); + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + return; +} + + + +// --- FUN_004118d0 at 0x004118D0 (size: 163) --- + +void __fastcall FUN_004118d0(int *param_1) + +{ + void *pvVar1; + + (**(code **)(*param_1 + 0x28))(); + FUN_00557170(); + (**(code **)(*param_1 + 0x8c))(); + FUN_00422210(); + (**(code **)(*param_1 + 0x84))(); + (**(code **)(*param_1 + 0x6c))(); + if ((undefined4 *)param_1[0x42] != (undefined4 *)0x0) { + (*(code *)**(undefined4 **)param_1[0x42])(1); + } + param_1[0x42] = 0; + if ((undefined4 *)param_1[0x41] != (undefined4 *)0x0) { + (*(code *)**(undefined4 **)param_1[0x41])(1); + } + param_1[0x41] = 0; + FUN_00406d10(); + pvVar1 = DAT_00837740; + if (DAT_00837740 != (void *)0x0) { + FUN_00406bf0(); + operator_delete(pvVar1); + DAT_00837740 = (void *)0x0; + DAT_00837744 = 1; + } + (**(code **)(*param_1 + 0x88))(); + thunk_FUN_00550ec0(); + return; +} + + + +// --- FUN_00411aa0 at 0x00411AA0 (size: 102) --- + +undefined4 __thiscall FUN_00411aa0(int param_1,undefined4 param_2) + +{ + undefined4 *puVar1; + int iVar2; + + puVar1 = (undefined4 *)FUN_005df0f5(8); + if (puVar1 == (undefined4 *)0x0) { + puVar1 = (undefined4 *)0x0; + } + else { + *puVar1 = 0; + puVar1[1] = 0; + } + iVar2 = (short)param_2 * 4; + *(undefined4 **)(iVar2 + *(int *)(param_1 + 300)) = puVar1; + iVar2 = *(int *)(iVar2 + *(int *)(param_1 + 300)); + if (iVar2 != 0) { + iVar2 = FUN_00541780(param_2,iVar2); + if (iVar2 != 0) { + return 1; + } + } + return 0; +} + + + +// --- FUN_00411b50 at 0x00411B50 (size: 77) --- + +void __thiscall FUN_00411b50(int param_1,int *param_2) + +{ + int iVar1; + LONG LVar2; + + iVar1 = *(int *)(param_1 + 0x88); + if (iVar1 != *param_2) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *param_2; + *(int *)(param_1 + 0x88) = iVar1; + /* WARNING: Could not recover jumptable at 0x00411b92. Too many branches */ + /* WARNING: Treating indirect jump as call */ + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + return; + } + return; +} + + + +// --- FUN_00411c20 at 0x00411C20 (size: 156) --- + +void __fastcall FUN_00411c20(int param_1) + +{ + int *piVar1; + int iVar2; + undefined4 *puVar3; + int *piVar4; + LONG LVar5; + undefined4 *puVar6; + + piVar1 = *(int **)(param_1 + 0x124); + if (piVar1 != (int *)0x0) { + iVar2 = *piVar1; + while (iVar2 != 0) { + puVar3 = (undefined4 *)*piVar1; + if (puVar3 == (undefined4 *)0x0) { + puVar6 = (undefined4 *)0x0; + } + else { + iVar2 = puVar3[1]; + *piVar1 = iVar2; + if (iVar2 == 0) { + piVar1[1] = 0; + } + puVar6 = (undefined4 *)*puVar3; + operator_delete(puVar3); + } + piVar1 = (int *)puVar6[0xb]; + if (((piVar1 != (int *)0x0) && (3 < (uint)puVar6[0xc])) && (*piVar1 == 0xf7de)) { + iVar2 = piVar1[1]; + FUN_00556f40(); + piVar4 = (int *)FUN_00557440(); + if (piVar4 != (int *)0x0) { + (**(code **)(*piVar4 + 0xc))(piVar4,iVar2,piVar1 + 2); + } + } + LVar5 = InterlockedDecrement(puVar6 + 1); + if (LVar5 == 0) { + (**(code **)*puVar6)(1); + } + piVar1 = *(int **)(param_1 + 0x124); + iVar2 = *piVar1; + } + } + return; +} + + + +// --- FUN_00411d90 at 0x00411D90 (size: 126) --- + +void __thiscall +FUN_00411d90(int param_1,int *param_2,undefined4 param_3,undefined4 param_4,undefined4 param_5, + undefined4 param_6,undefined4 param_7) + +{ + int *piVar1; + char cVar2; + int iVar3; + + piVar1 = param_2; + if (param_1 != 0) { + FUN_004369a0(param_1,2,param_2,param_3,param_4,param_5,param_6,param_7); + } + if (DAT_008380c8 == 0) { + iVar3 = FUN_005df0f5(0x8100); + if (iVar3 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar2 = FUN_00433710(piVar1,¶m_2); + if ((cVar2 != '\0') && (iVar3 = (**(code **)(*param_2 + 0x44))(), iVar3 != 0)) { + *(undefined1 *)(iVar3 + 0x28) = 1; + } + return; +} + + + +// --- FUN_00411e10 at 0x00411E10 (size: 106) --- + +void __fastcall FUN_00411e10(undefined4 *param_1) + +{ + undefined4 *puVar1; + LONG LVar2; + + operator_delete__((void *)param_1[0xf]); + param_1[0xf] = 0; + operator_delete__((void *)param_1[0xc]); + param_1[0xc] = 0; + puVar1 = (undefined4 *)param_1[8]; + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + puVar1 = (undefined4 *)param_1[4]; + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + *param_1 = &PTR_FUN_0079385c; + return; +} + + + +// --- FUN_00411fa0 at 0x00411FA0 (size: 126) --- + +undefined4 __fastcall FUN_00411fa0(int param_1) + +{ + char cVar1; + + FUN_0040fbd0(); + cVar1 = FUN_00439e50(); + if (cVar1 != '\0') { + return 0; + } + FUN_00543440(); + FUN_00411c20(); + FUN_00541cb0(); + (**(code **)(*(int *)(*(int *)(param_1 + 0xac) + 4) + 0x48))(); + FUN_0045d0b0(); + FUN_004554b0(); + FUN_0043e690(); + thunk_FUN_0043dc70(); + FUN_00455610(); + FUN_0043fcd0(1); + FUN_004392b0(); + return 1; +} + + + +// --- FUN_00412020 at 0x00412020 (size: 51) --- + +undefined4 * __thiscall FUN_00412020(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795538; + if (param_1[1] != 0) { + FUN_0040e340(param_1); + param_1[1] = 0; + } + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00412180 at 0x00412180 (size: 288) --- + +bool __thiscall FUN_00412180(int *param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4) + +{ + char cVar1; + BOOL BVar2; + HMODULE hLibModule; + int iVar3; + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined4 extraout_ECX_01; + _OSVERSIONINFOA *p_Var4; + undefined4 uVar5; + undefined4 uVar6; + undefined4 uVar7; + _OSVERSIONINFOA _Stack_a0; + + _set_new_handler((_func_int_uint *)&LAB_00411580); + cVar1 = (**(code **)(*param_1 + 0x80))(); + if (cVar1 == '\0') { + p_Var4 = &_Stack_a0; + for (iVar3 = 0x25; iVar3 != 0; iVar3 = iVar3 + -1) { + p_Var4->dwOSVersionInfoSize = 0; + p_Var4 = (_OSVERSIONINFOA *)&p_Var4->dwMajorVersion; + } + _Stack_a0.dwOSVersionInfoSize = 0x94; + BVar2 = GetVersionExA(&_Stack_a0); + if ((BVar2 == 0) || (_Stack_a0.dwPlatformId == 1)) { + hLibModule = LoadLibraryA("unicows.dll"); + if (hLibModule == (HMODULE)0x0) { + uVar7 = extraout_ECX; + FUN_00402730(&DAT_00795320); + uVar6 = extraout_ECX_00; + FUN_00402730(&DAT_00795320); + uVar5 = extraout_ECX_01; + FUN_00402730(L"UnicoWS.dll"); + FUN_0043d090(0x6d,uVar5,uVar6,uVar7,hLibModule); + return false; + } + FreeLibrary(hLibModule); + } + FUN_0040fcd0(); + FUN_0042c800(); + iVar3 = FUN_0054bb50(); + param_1[0x41] = iVar3; + if (iVar3 != 0) { + iVar3 = FUN_0054bb70(); + param_1[0x42] = iVar3; + if (iVar3 != 0) { + (**(code **)(*param_1 + 0x68))(); + cVar1 = (**(code **)(*param_1 + 0x70))(); + if (((cVar1 != '\0') && + (cVar1 = (**(code **)(*param_1 + 0x74))(param_3,param_4,param_1[0x1c] != 0), + cVar1 != '\0')) && (cVar1 = FUN_004221c0(), cVar1 != '\0')) { + cVar1 = (**(code **)(*param_1 + 0x7c))(param_2); + return cVar1 != '\0'; + } + } + } + } + return false; +} + + + +// --- FUN_00412310 at 0x00412310 (size: 259) --- + +undefined4 __fastcall FUN_00412310(int param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + int local_4; + + local_4 = param_1; + FUN_00438fe0(0,param_1 + 100); + FUN_00438940(); + FUN_00401340("Network Bind Interface"); + FUN_004020e0(&DAT_00837a10,&local_4,0,0,0,0); + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("Flag to compute a unique port"); + FUN_00411d90(&DAT_00837a14,&local_4,0,0,0,0); + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("The user specified port"); + FUN_00402160(&DAT_00837a18,&local_4,0,0,0,0); + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00430d80(); + return 1; +} + + + +// --- FUN_00412420 at 0x00412420 (size: 1070) --- + +void __thiscall FUN_00412420(int param_1,int param_2) + +{ + LONG LVar1; + undefined4 *puVar2; + int local_8; + int local_4; + + FUN_00401340(": Specifies the account name to logon with."); + FUN_00401340("account"); + FUN_00402660(2,0x61,&local_8,&local_4,0,0,0); + LVar1 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(local_8 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_8 + -0x14))(1); + } + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("<32 bitfield>: Controls what kinds of debug outputs are enabled."); + FUN_00401340("debug"); + FUN_00402660(2,0,¶m_2,&local_4,0,0,0); + puVar2 = (undefined4 *)(param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("[host/IP]:Specifies where to find the server to talk to."); + FUN_00401340(&DAT_00795b68); + FUN_00402660(0x32,0x68,¶m_2,&local_4,param_1 + 0x88,0,0); + puVar2 = (undefined4 *)(param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(": Language to run the client in."); + FUN_00401340("language"); + FUN_00402660(0x32,0,¶m_2,&local_4,param_1 + 0x84,0,0); + puVar2 = (undefined4 *)(param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("<1-65535>: Specify the outgoing network port to use."); + FUN_00401340("outport"); + FUN_00402660(0x22,0x71,¶m_2,&local_4,param_1 + 0x94,0,0); + puVar2 = (undefined4 *)(param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("<1-65535>: Specify the server port to contact. See \'host\'"); + FUN_00401340(&DAT_00795aac); + FUN_00402660(0x22,0x70,¶m_2,&local_4,param_1 + 0x90,0,0); + puVar2 = (undefined4 *)(param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(": Specify the preferences file to use."); + FUN_00401340("prefs"); + FUN_00402660(0x32,0,¶m_2,&local_4,param_1 + 0x60,0,0); + puVar2 = (undefined4 *)(param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("Opens the DAT files readonly"); + FUN_00401340("rodat"); + FUN_00402660(3,0,¶m_2,&local_4,0,0,0); + puVar2 = (undefined4 *)(param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("Enables the use of the memory manager."); + FUN_00401340("usemem"); + FUN_00402660(0x11,0,¶m_2,&local_4,param_1 + 0x68,1,0); + puVar2 = (undefined4 *)(param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + return; +} + + + +// --- FUN_00412850 at 0x00412850 (size: 546) --- + +char __thiscall FUN_00412850(int *param_1,undefined4 param_2,int *param_3) + +{ + char *_Str; + char cVar1; + char cVar2; + char cVar3; + LONG LVar4; + int *piVar5; + ulong uVar6; + undefined4 *puVar7; + int local_4; + + cVar1 = FUN_004083f0(param_2,param_3); + cVar2 = '\0'; + if (cVar1 != '\0') { + FUN_00401340("account"); + cVar2 = FUN_00401920(&local_4); + puVar7 = (undefined4 *)(local_4 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar4 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + if (cVar2 != '\0') { + FUN_004034c0(*param_3); + FUN_00411870(); + _strlwr((char *)(param_1[0x1c] + 0x14)); + return cVar1; + } + FUN_00401340("debug"); + cVar2 = FUN_00401920(&local_4); + puVar7 = (undefined4 *)(local_4 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar4 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + if (cVar2 != '\0') { + _Str = (char *)*param_3; + piVar5 = _errno(); + *piVar5 = 0; + uVar6 = strtoul(_Str,(char **)0x0,0); + FUN_00405e60(uVar6,1); + FUN_00405e60(~uVar6,0); + return cVar1; + } + FUN_00401340("logfile"); + cVar3 = FUN_00401920(&local_4); + LVar4 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + cVar2 = cVar1; + if (cVar3 == '\0') { + FUN_00401340("outport"); + cVar1 = FUN_00401920(&local_4); + FUN_004011b0(); + if (cVar1 == '\0') { + FUN_00401340("rodat"); + cVar1 = FUN_00401920(&local_4); + FUN_004011b0(); + if (cVar1 != '\0') { + param_1[0x1b] = (uint)(*(int *)(*param_3 + -4) == 1); + } + } + else if ((param_1[0x25] < 1) || (0xffff < param_1[0x25])) { + FUN_00401340("Client port must be between 1 and 65535\n"); + (**(code **)(*param_1 + 0x20))(¶m_3); + FUN_004011b0(); + return '\0'; + } + } + } + return cVar2; +} + + + +// --- FUN_00412ae0 at 0x00412AE0 (size: 120) --- + +undefined4 __thiscall FUN_00412ae0(int param_1,undefined4 param_2) + +{ + if ((*(int *)(param_1 + 4) != 0) && (*(int *)(param_1 + 8) != 0)) { + FUN_0042dc80(); + FUN_0042c9c0(*(undefined4 *)(param_1 + 4),*(undefined4 *)(param_1 + 8)); + FUN_0042e740(param_2,1); + FUN_0042e590(); + return param_2; + } + FUN_00402730(L"unknown"); + return param_2; +} + + + +// --- FUN_00412b70 at 0x00412B70 (size: 515) --- + +void __fastcall FUN_00412b70(undefined4 *param_1) + +{ + int iVar1; + LONG LVar2; + uint uVar3; + undefined4 *puVar4; + + param_1[-7] = &PTR_LAB_00795d48; + param_1[-6] = &PTR_LAB_00795cf8; + *param_1 = &PTR_FUN_00795ce8; + param_1[2] = &PTR_LAB_00795cdc; + param_1[3] = &PTR_LAB_00795ccc; + DAT_008379e4 = 0; + if ((HANDLE)param_1[0x45] != (HANDLE)0x0) { + CloseHandle((HANDLE)param_1[0x45]); + param_1[0x45] = 0; + } + puVar4 = (undefined4 *)(param_1[0x3c] + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_1[0x3c] + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + FUN_00411e10(); + puVar4 = (undefined4 *)(param_1[0x23] + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_1[0x23] + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + puVar4 = (undefined4 *)(param_1[0x1c] + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_1[0x1c] + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + puVar4 = (undefined4 *)(param_1[0x1b] + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_1[0x1b] + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + puVar4 = (undefined4 *)(param_1[0x1a] + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_1[0x1a] + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + puVar4 = (undefined4 *)param_1[0x16]; + LVar2 = InterlockedDecrement(puVar4 + 1); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + puVar4 = (undefined4 *)(param_1[0x12] + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_1[0x12] + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + puVar4 = (undefined4 *)(param_1[0x11] + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_1[0x11] + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + puVar4 = (undefined4 *)(-(uint)(param_1 != (undefined4 *)0x1c) & (uint)(param_1 + 3)); + param_1[0xf] = &PTR_LAB_00793b6c; + puVar4[8] = &PTR_FUN_0079385c; + *puVar4 = &PTR_FUN_00795538; + if (puVar4[1] != 0) { + FUN_0040e340(puVar4); + puVar4[1] = 0; + } + puVar4 = (undefined4 *)(-(uint)(param_1 != (undefined4 *)0x1c) & (uint)(param_1 + 2)); + *puVar4 = &PTR_FUN_00795824; + if (DAT_00837ff4 != (int *)0x0) { + (**(code **)(*DAT_00837ff4 + 0x3c))(puVar4); + } + puVar4 = (undefined4 *)(-(uint)(param_1 != (undefined4 *)0x1c) & (uint)param_1); + *puVar4 = &PTR_FUN_00795538; + if (puVar4[1] != 0) { + FUN_0040e340(puVar4); + puVar4[1] = 0; + } + uVar3 = -(uint)(param_1 != (undefined4 *)0x1c) & (uint)(param_1 + -6); + iVar1 = *(int *)(uVar3 + 8); + puVar4 = (undefined4 *)(iVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + iVar1 = *(int *)(uVar3 + 4); + puVar4 = (undefined4 *)(iVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + return; +} + + + +// --- FUN_00412e10 at 0x00412E10 (size: 58) --- + +undefined4 * __thiscall FUN_00412e10(undefined4 *param_1,byte param_2) + +{ + param_1[8] = &PTR_FUN_0079385c; + *param_1 = &PTR_FUN_00795538; + if (param_1[1] != 0) { + FUN_0040e340(param_1); + param_1[1] = 0; + } + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00412e50 at 0x00412E50 (size: 494) --- + +undefined4 * __fastcall FUN_00412e50(undefined4 *param_1) + +{ + LONG *pLVar1; + + param_1[1] = &PTR_LAB_00795c80; + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[2] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + FUN_00401340(&DAT_00795c7c); + param_1[7] = &PTR_FUN_007959a8; + param_1[8] = 0; + param_1[9] = &PTR_FUN_00795824; + param_1[0xb] = 0; + param_1[10] = &PTR_FUN_00795dd8; + param_1[0xc] = 0; + param_1[0xe] = 0; + param_1[0xf] = 0; + param_1[0x10] = 0; + param_1[0x11] = 0x3f800000; + param_1[0x12] = &PTR_FUN_00795878; + param_1[0x15] = 0; + *param_1 = &PTR_LAB_00795d48; + param_1[1] = &PTR_LAB_00795cf8; + param_1[7] = &PTR_FUN_00795ce8; + param_1[9] = &PTR_LAB_00795cdc; + param_1[10] = &PTR_LAB_00795ccc; + param_1[0x17] = 1; + param_1[0x16] = &PTR_LAB_00793b6c; + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x18] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x19] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + param_1[0x1a] = 1; + param_1[0x1b] = 0; + param_1[0x1c] = 1; + pLVar1 = (LONG *)(DAT_008ef11c + 4); + param_1[0x1d] = DAT_008ef11c; + InterlockedIncrement(pLVar1); + param_1[0x1e] = 0; + param_1[0x1f] = 0; + param_1[0x20] = 0; + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x21] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x22] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x23] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + param_1[0x24] = 0; + param_1[0x25] = 0x1c88; + param_1[0x26] = 0; + param_1[0x27] = 0; + param_1[0x28] = 0; + param_1[0x29] = 1; + pLVar1 = (LONG *)(PTR_DAT_00818340 + -0x10); + param_1[0x2a] = PTR_DAT_00818340; + InterlockedIncrement(pLVar1); + param_1[0x2b] = 0; + param_1[0x2c] = 0; + *(undefined1 *)(param_1 + 0x2d) = 0; + FUN_005414a0(); + param_1[0x40] = 0; + param_1[0x41] = 0; + param_1[0x42] = 0; + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x43] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + *(undefined1 *)(param_1 + 0x44) = 0; + param_1[0x45] = 0; + param_1[0x46] = 0; + param_1[0x48] = 0; + param_1[0x49] = 0; + param_1[0x4a] = 0; + param_1[0x4b] = 0; + param_1[0x4c] = 0; + DAT_008379e4 = param_1; + FUN_00556eb0(); + FUN_00405e60(0x100,1); + return param_1; +} + + + +// --- FUN_00413040 at 0x00413040 (size: 34) --- + +int __thiscall FUN_00413040(int param_1,byte param_2) + +{ + FUN_00412b70(); + if ((param_2 & 1) != 0) { + operator_delete((void *)(param_1 + -0x1c)); + } + return param_1 + -0x1c; +} + + + +// --- FUN_00413180 at 0x00413180 (size: 714) --- + +undefined4 * __thiscall FUN_00413180(int *param_1,undefined4 *param_2) + +{ + int iVar1; + undefined *puVar2; + HMODULE pHVar3; + LONG LVar4; + undefined4 *puVar5; + int iStack_1fc; + undefined *puStack_1f8; + undefined **ppuStack_1f4; + int iStack_1f0; + int iStack_1ec; + int iStack_1e8; + undefined4 uStack_1e4; + undefined4 uStack_1e0; + undefined4 uStack_1dc; + undefined4 uStack_1d8; + undefined4 uStack_1d4; + undefined4 *puStack_1d0; + int iStack_1cc; + uint uStack_1c8; + undefined1 auStack_1c4 [24]; + undefined4 uStack_1ac; + undefined4 uStack_1a8; + undefined1 auStack_120 [144]; + undefined1 auStack_90 [144]; + + (**(code **)(*param_1 + 0x78))(); + iStack_1cc = param_1[0x26]; + iStack_1fc = param_1[0x25]; + iVar1 = param_1[0x23]; + if (iStack_1cc == 0) { + iStack_1cc = param_1[0x45]; + } + FUN_0040e4e0(param_1 + 10); + puStack_1d0 = DAT_008ef11c; + uStack_1e4 = 0; + uStack_1e0 = 0; + uStack_1dc = 0; + uStack_1d8 = 0; + uStack_1d4 = 0; + InterlockedIncrement(DAT_008ef11c + 1); + uStack_1c8 = (uint)*(byte *)(param_1 + 0x44); + FUN_004034c0(param_1[0x43]); + pHVar3 = LoadLibraryA("acpl.dll"); + if ((pHVar3 != (HMODULE)0x0) || (pHVar3 = LoadLibraryA("pl.dll"), pHVar3 != (HMODULE)0x0)) { + puVar2 = PTR_FUN_00837388; + iStack_1ec = (*(code *)PTR_FUN_00837388)(pHVar3,"LogWireDataReceived"); + uStack_1e0 = (*(code *)puVar2)(pHVar3,"LogWireDataSent"); + } + FUN_00413980(); + FUN_00545bd0(&ppuStack_1f4,iStack_1fc,iVar1,auStack_1c4,param_1 + 0x2e,&uStack_1e4); + if (iStack_1f0 == DAT_00822344) { + if (iStack_1ec == DAT_00822348) { + iVar1 = param_1[0xc]; + while (iVar1 < 3) { + FUN_00411630(); + iVar1 = param_1[0xc]; + } + iStack_1f0 = param_1[0x13]; + iStack_1ec = param_1[0x14]; + } + if ((iStack_1f0 == DAT_00822344) && (iStack_1ec == DAT_00822348)) { + *(undefined1 *)(param_1 + 0x2d) = 1; + goto LAB_004133fd; + } + } + FUN_0042dc80(); + FUN_0042c9c0(iStack_1f0,iStack_1ec); + FUN_0042e510(auStack_120); + FUN_0042e590(); + FUN_0042e510(auStack_90); + FUN_0042e590(); + FUN_00412ae0(&iStack_1fc); + FUN_00408fd0(&iStack_1e8,0); + puVar5 = (undefined4 *)(iStack_1fc + -0x14); + LVar4 = InterlockedDecrement((LONG *)(iStack_1fc + -0x10)); + if ((LVar4 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + puStack_1f8 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00402710(&puStack_1f8,"Failed to establish connection to the server: %s (%8X:%08X)",iStack_1e8 + ,uStack_1a8,uStack_1ac); + FUN_00555860(puStack_1f8); + puVar5 = (undefined4 *)(puStack_1f8 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(puStack_1f8 + -0x10)); + if ((LVar4 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + LVar4 = InterlockedDecrement((LONG *)(iStack_1e8 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(iStack_1e8 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iStack_1e8 + -0x14))(1); + } + FUN_0042e590(); +LAB_004133fd: + param_2[2] = iStack_1ec; + *param_2 = &PTR_FUN_00795878; + param_2[1] = iStack_1f0; + ppuStack_1f4 = &PTR_FUN_0079385c; + FUN_00695670(); + puVar5 = puStack_1d0; + LVar4 = InterlockedDecrement(puStack_1d0 + 1); + if ((LVar4 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + return param_2; +} + + + +// --- FUN_00413470 at 0x00413470 (size: 64) --- + +undefined4 * __thiscall FUN_00413470(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795ef8; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004134b0 at 0x004134B0 (size: 25) --- + +void __fastcall FUN_004134b0(int *param_1) + +{ + int iVar1; + undefined4 uVar2; + + iVar1 = *param_1; + if (*(int *)(iVar1 + -8) == -1) { + uVar2 = FUN_004016b0(iVar1); + *(undefined4 *)(iVar1 + -8) = uVar2; + } + return; +} + + + +// --- FUN_004134d0 at 0x004134D0 (size: 16) --- + +int FUN_004134d0(int *param_1,int *param_2) + +{ + return *param_2 - *param_1 >> 2; +} + + + +// --- FUN_004134e0 at 0x004134E0 (size: 18) --- + +void FUN_004134e0(int *param_1,int param_2) + +{ + *param_1 = *param_1 + param_2 * 4; + return; +} + + + +// --- FUN_00413500 at 0x00413500 (size: 102) --- + +undefined4 * FUN_00413500(undefined4 *param_1,undefined4 param_2) + +{ + LONG LVar1; + undefined4 *puVar2; + undefined *local_4; + + local_4 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00402710(&local_4,"\'\' (did=0x%08X)",param_2); + *param_1 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return param_1; +} + + + +// --- FUN_00413570 at 0x00413570 (size: 213) --- + +void FUN_00413570(undefined4 param_1,undefined4 param_2) + +{ + LONG LVar1; + undefined4 *puVar2; + undefined *local_c; + undefined *local_8; + int local_4; + + FUN_00413500(&local_4,param_1); + local_8 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00402390(param_2,&stack0x0000000c); + local_c = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00402710(&local_c,"Error in file \"%s\": %s\n",local_4,local_8); + FUN_0065af70(&local_c); + puVar2 = (undefined4 *)(local_c + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_8 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + return; +} + + + +// --- FUN_00413650 at 0x00413650 (size: 143) --- + +undefined4 * __thiscall FUN_00413650(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00795ef8; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_004136e0 at 0x004136E0 (size: 58) --- + +void __fastcall FUN_004136e0(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_00795f38; + FUN_00433a10(); + param_1[1] = &PTR_FUN_00795ef8; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + return; +} + + + +// --- FUN_00413720 at 0x00413720 (size: 82) --- + +undefined4 * __thiscall FUN_00413720(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795f38; + FUN_00433a10(); + param_1[1] = &PTR_FUN_00795ef8; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004137f0 at 0x004137F0 (size: 95) --- + +undefined4 * FUN_004137f0(void) + +{ + undefined4 *puVar1; + + if (DAT_00837b9c == (undefined4 *)0x0) { + puVar1 = (undefined4 *)FUN_005df0f5(0x80); + if (puVar1 == (undefined4 *)0x0) { + DAT_00837b9c = (undefined4 *)0x0; + } + else { + puVar1[1] = 1; + *puVar1 = &PTR_FUN_00795f3c; + *(undefined1 *)(puVar1 + 2) = 0; + *(undefined1 *)((int)puVar1 + 9) = 0; + puVar1[3] = &PTR_FUN_00795f38; + FUN_00413650(0x17); + DAT_00837b9c = puVar1; + } + } + InterlockedIncrement(DAT_00837b9c + 1); + return DAT_00837b9c; +} + + + +// --- FUN_00413850 at 0x00413850 (size: 210) --- + +void FUN_00413850(int param_1,int *param_2) + +{ + undefined4 *puVar1; + LONG LVar2; + int iVar3; + undefined4 uVar4; + + puVar1 = (undefined4 *)FUN_0040f4c0(); + FUN_0065af30(puVar1); + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + if (param_1 != 0) { + if (param_1 == 1) { + puVar1 = (undefined4 *)FUN_0040eb60(); + } + else { + if (param_1 != 2) { + return; + } + puVar1 = (undefined4 *)FUN_0040eb40(); + } + FUN_0065af30(puVar1); + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + return; + } + if (*(int *)(*param_2 + -4) == 1) { + uVar4 = FUN_004137f0(); + FUN_0065af30(uVar4); + FUN_00405f70(); + return; + } + iVar3 = FUN_005df0f5(0x18); + if (iVar3 == 0) { + FUN_0065af30(0); + FUN_00405f70(); + return; + } + uVar4 = FUN_0040f020(*param_2); + FUN_0065af30(uVar4); + FUN_00405f70(); + return; +} + + + +// --- FUN_00413930 at 0x00413930 (size: 39) --- + +undefined4 * __thiscall FUN_00413930(undefined4 *param_1,byte param_2) + +{ + FUN_004136e0(); + *param_1 = &PTR_FUN_007952f4; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00413960 at 0x00413960 (size: 19) --- + +void __fastcall FUN_00413960(undefined4 *param_1) + +{ + *param_1 = 0; + param_1[1] = 0; + param_1[2] = 0; + param_1[3] = 0; + param_1[4] = 0; + return; +} + + + +// --- FUN_00413980 at 0x00413980 (size: 21) --- + +void __fastcall FUN_00413980(undefined4 *param_1) + +{ + *param_1 = 0; + param_1[1] = 0; + param_1[2] = 0; + param_1[3] = 0; + param_1[4] = 0; + return; +} + + + +// --- FUN_004139a0 at 0x004139A0 (size: 45) --- + +void __thiscall FUN_004139a0(undefined4 *param_1,undefined4 *param_2) + +{ + *param_1 = *param_2; + param_1[1] = param_2[1]; + param_1[2] = param_2[2]; + param_1[3] = param_2[3]; + param_1[4] = param_2[4]; + return; +} + + + +// --- FUN_004139d0 at 0x004139D0 (size: 46) --- + +void __fastcall FUN_004139d0(int param_1) + +{ + if (DAT_00837bac != 0) { + (**(code **)(*(int *)(DAT_00837bac + 4) + 0x34))(DAT_00818684); + } + DAT_00818684 = DAT_00837c20; + /* WARNING: Could not recover jumptable at 0x004139fb. Too many branches */ + /* WARNING: Treating indirect jump as call */ + (**(code **)(*(int *)(param_1 + 4) + 0x58))(); + return; +} + + + +// --- FUN_00413a00 at 0x00413A00 (size: 34) --- + +undefined4 FUN_00413a00(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + undefined4 uVar1; + + if (DAT_00837bac != (int *)0x0) { + uVar1 = (**(code **)(*DAT_00837bac + 0x24))(param_1,param_2,param_3); + return uVar1; + } + return 0; +} + + + +// --- FUN_00413a30 at 0x00413A30 (size: 24) --- + +undefined4 FUN_00413a30(undefined4 param_1) + +{ + undefined4 uVar1; + + if (DAT_00837bac != (int *)0x0) { + uVar1 = (**(code **)(*DAT_00837bac + 0x2c))(param_1); + return uVar1; + } + return 0; +} + + + +// --- FUN_00413a50 at 0x00413A50 (size: 27) --- + +undefined4 FUN_00413a50(undefined4 *param_1) + +{ + undefined4 uVar1; + + if (DAT_00837bac != 0) { + uVar1 = *(undefined4 *)(DAT_00837bac + 0x120); + *param_1 = uVar1; + return CONCAT31((int3)((uint)uVar1 >> 8),1); + } + return 0; +} + + + +// --- FUN_00413a70 at 0x00413A70 (size: 19) --- + +undefined4 FUN_00413a70(void) + +{ + if (DAT_00837bac != 0) { + return CONCAT31((int3)((uint)DAT_00837bac >> 8),*(undefined1 *)(DAT_00837bac + 0x128)); + } + return 0; +} + + + +// --- FUN_00413a90 at 0x00413A90 (size: 19) --- + +undefined4 FUN_00413a90(void) + +{ + if (DAT_00837bac != 0) { + return CONCAT31((int3)((uint)DAT_00837bac >> 8),*(undefined1 *)(DAT_00837bac + 0x129)); + } + return 0; +} + + + +// --- FUN_00413ab0 at 0x00413AB0 (size: 19) --- + +undefined4 FUN_00413ab0(void) + +{ + if (DAT_00837bac != 0) { + return CONCAT31((int3)((uint)DAT_00837bac >> 8),*(undefined1 *)(DAT_00837bac + 0x12a)); + } + return 0; +} + + + +// --- FUN_00413ad0 at 0x00413AD0 (size: 15) --- + +undefined4 __thiscall FUN_00413ad0(int param_1,undefined4 param_2) + +{ + *(undefined4 *)(param_1 + 0x120) = param_2; + return 1; +} + + + +// --- FUN_00413ae0 at 0x00413AE0 (size: 29) --- + +uint FUN_00413ae0(undefined4 param_1,undefined4 param_2) + +{ + uint in_EAX; + uint uVar1; + + if (DAT_00837bac != (int *)0x0) { + uVar1 = (**(code **)(*DAT_00837bac + 0x4c))(param_1,param_2); + return uVar1; + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00413b00 at 0x00413B00 (size: 19) --- + +undefined4 FUN_00413b00(void) + +{ + if (DAT_00837bac != 0) { + return *(undefined4 *)(DAT_00837bac + 0x124); + } + return 0; +} + + + +// --- FUN_00413b30 at 0x00413B30 (size: 47) --- + +undefined4 * __thiscall FUN_00413b30(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795f70; + if ((void *)param_1[1] != (void *)0x0) { + operator_delete__((void *)param_1[1]); + } + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00413b60 at 0x00413B60 (size: 25) --- + +void __thiscall FUN_00413b60(int param_1,undefined4 *param_2,undefined4 param_3) + +{ + undefined4 uVar1; + + uVar1 = *(undefined4 *)(param_1 + 0x11c); + *(undefined4 *)(param_1 + 0x11c) = param_3; + *param_2 = uVar1; + return; +} + + + +// --- FUN_00413b80 at 0x00413B80 (size: 49) --- + +void FUN_00413b80(undefined4 param_1,undefined4 param_2) + +{ + undefined4 *puVar1; + undefined4 uVar2; + + puVar1 = *(undefined4 **)(DAT_00837bac + 4); + uVar2 = FUN_004220b0(param_1,param_2); + (*(code *)*puVar1)(2,uVar2); + return; +} + + + +// --- FUN_00413bc0 at 0x00413BC0 (size: 48) --- + +undefined4 * FUN_00413bc0(undefined4 *param_1,undefined4 param_2,undefined4 param_3) + +{ + if (DAT_00837bac != (int *)0x0) { + (**(code **)(*DAT_00837bac + 0x28))(param_1,param_2,param_3); + return param_1; + } + *param_1 = DAT_00837bb0; + return param_1; +} + + + +// --- FUN_00413d20 at 0x00413D20 (size: 185) --- + +char __thiscall FUN_00413d20(int param_1,undefined4 param_2,undefined4 param_3) + +{ + char cVar1; + char cVar2; + int *piVar3; + int *piVar4; + char unaff_BP; + undefined4 unaff_ESI; + undefined1 local_8 [4]; + char cStack_4; + + FUN_004220b0(param_2,param_3); + piVar3 = (int *)(**(code **)(*(int *)(param_1 + 4) + 0x38))(local_8); + if (piVar3 == (int *)0x0) { + return '\0'; + } + piVar4 = (int *)(**(code **)(*(int *)(param_1 + 4) + 0x84))(&stack0xfffffff4,piVar3); + if (piVar4 == (int *)0x0) { + return '\0'; + } + cStack_4 = (char)piVar4[2]; + if (cStack_4 != '\0') { + (**(code **)(*piVar4 + 0x2c))(); + } + (**(code **)(*piVar4 + 0x3c))(); + cVar1 = (**(code **)(*(int *)(param_1 + 4) + 0x7c))(piVar4,&stack0xffffffec,piVar3); + cVar2 = '\0'; + if ((cVar1 != '\0') && (cVar2 = (**(code **)(*piVar4 + 0x24))(), cVar2 != '\0')) { + if (unaff_BP != '\0') { + cVar2 = (**(code **)(*piVar4 + 0x28))(); + } + if (cVar2 != '\0') goto LAB_00413dc6; + } + (**(code **)(*piVar3 + 0x1c))(unaff_ESI); +LAB_00413dc6: + (**(code **)(*piVar4 + 0x14))(); + return cVar2; +} + + + +// --- FUN_00413de0 at 0x00413DE0 (size: 108) --- + +void FUN_00413de0(int *param_1) + +{ + char cVar1; + undefined4 uVar2; + + if (DAT_00837bac != 0) { + if ((param_1[10] != DAT_00837bb0) && (*(int *)(DAT_00837bac + 300) != 0)) { + uVar2 = (**(code **)(*param_1 + 0x48))(); + cVar1 = FUN_0041c4a0(uVar2); + if (cVar1 == '\0') { + uVar2 = (**(code **)(*param_1 + 0x48))(); + switch(uVar2) { + case 0x15: + case 0x1c: + case 0x24: + case 0x26: + case 0x28: + case 0x2d: + break; + default: + (**(code **)(*param_1 + 0x40))(*(undefined4 *)(DAT_00837bac + 300)); + } + } + } + } + return; +} + + + +// --- FUN_00413e70 at 0x00413E70 (size: 64) --- + +undefined4 * __thiscall FUN_00413e70(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795f84; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00413eb0 at 0x00413EB0 (size: 64) --- + +undefined4 * __thiscall FUN_00413eb0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795f88; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00413ef0 at 0x00413EF0 (size: 64) --- + +undefined4 * __thiscall FUN_00413ef0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795f8c; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00413f30 at 0x00413F30 (size: 64) --- + +undefined4 * __thiscall FUN_00413f30(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795f90; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00413f70 at 0x00413F70 (size: 64) --- + +undefined4 * __thiscall FUN_00413f70(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795f94; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00413fb0 at 0x00413FB0 (size: 160) --- + +int __thiscall FUN_00413fb0(int param_1,undefined4 *param_2) + +{ + int iVar1; + uint uVar2; + uint uVar3; + + if (*(int *)(param_1 + 0x10) == *(int *)(param_1 + 0x14)) { + iVar1 = thunk_FUN_005df0f5((*(int *)(param_1 + 0x18) + *(int *)(param_1 + 0x14)) * 4); + if (*(int *)(param_1 + 4) != 0) { + uVar3 = *(uint *)(param_1 + 8); + uVar2 = 0; + if (*(int *)(param_1 + 0x10) != 0) { + do { + *(undefined4 *)(iVar1 + uVar2 * 4) = *(undefined4 *)(*(int *)(param_1 + 4) + uVar3 * 4); + uVar3 = (uVar3 + 1) % *(uint *)(param_1 + 0x14); + uVar2 = uVar2 + 1; + } while (uVar2 < *(uint *)(param_1 + 0x10)); + } + operator_delete__(*(void **)(param_1 + 4)); + } + *(int *)(param_1 + 4) = iVar1; + *(undefined4 *)(param_1 + 8) = 0; + *(undefined4 *)(param_1 + 0xc) = *(undefined4 *)(param_1 + 0x10); + *(int *)(param_1 + 0x14) = *(int *)(param_1 + 0x14) + *(int *)(param_1 + 0x18); + } + *(undefined4 *)(*(int *)(param_1 + 4) + *(int *)(param_1 + 0xc) * 4) = *param_2; + *(uint *)(param_1 + 0xc) = (*(int *)(param_1 + 0xc) + 1U) % *(uint *)(param_1 + 0x14); + iVar1 = *(int *)(param_1 + 0x10); + *(int *)(param_1 + 0x10) = iVar1 + 1; + return iVar1; +} + + + +// --- FUN_00414050 at 0x00414050 (size: 130) --- + +uint __thiscall FUN_00414050(int param_1,int param_2) + +{ + uint uVar1; + uint uVar2; + uint uVar3; + int iVar4; + + *(int *)(param_1 + 0x10) = *(int *)(param_1 + 0x10) + -1; + uVar1 = *(uint *)(param_1 + 0x14); + if (param_2 == 0) { + uVar2 = *(int *)(param_1 + 8) + 1; + *(uint *)(param_1 + 8) = uVar2 % uVar1; + return uVar2 / uVar1; + } + uVar2 = (uVar1 - 1) + *(int *)(param_1 + 0xc); + uVar3 = uVar2 / uVar1; + *(uint *)(param_1 + 0xc) = uVar2 % uVar1; + if (param_2 != *(int *)(param_1 + 0x10)) { + uVar1 = *(uint *)(param_1 + 8); + uVar2 = (uVar1 + param_2) % *(uint *)(param_1 + 0x14); + if ((*(uint *)(param_1 + 0xc) < uVar1) && (uVar1 < uVar2)) { + iVar4 = *(uint *)(param_1 + 0x14) - 1; + FUN_004140e0(uVar2,uVar2 + 1,iVar4 - uVar2); + (*(undefined4 **)(param_1 + 4))[iVar4] = **(undefined4 **)(param_1 + 4); + uVar2 = 0; + } + uVar3 = FUN_004140e0(uVar2,uVar2 + 1,*(int *)(param_1 + 0xc) - uVar2); + } + return uVar3; +} + + + +// --- FUN_004140e0 at 0x004140E0 (size: 120) --- + +void __thiscall FUN_004140e0(int param_1,uint param_2,uint param_3,int param_4) + +{ + int iVar1; + int iVar2; + + if (param_4 != 0) { + if (param_2 < param_3) { + if (param_4 != 0) { + iVar2 = param_2 * 4; + iVar1 = param_3 * 4; + do { + *(undefined4 *)(iVar2 + *(int *)(param_1 + 4)) = + *(undefined4 *)(iVar1 + *(int *)(param_1 + 4)); + iVar1 = iVar1 + 4; + iVar2 = iVar2 + 4; + param_4 = param_4 + -1; + } while (param_4 != 0); + return; + } + } + else if (param_4 != 0) { + iVar1 = ((param_2 - 1) + param_4) * 4; + iVar2 = ((param_3 - 1) + param_4) * 4; + do { + *(undefined4 *)(iVar1 + *(int *)(param_1 + 4)) = + *(undefined4 *)(iVar2 + *(int *)(param_1 + 4)); + iVar2 = iVar2 + -4; + iVar1 = iVar1 + -4; + param_4 = param_4 + -1; + } while (param_4 != 0); + } + } + return; +} + + + +// --- FUN_00414190 at 0x00414190 (size: 66) --- + +void __thiscall FUN_00414190(int param_1,int *param_2,int *param_3) + +{ + undefined4 *puVar1; + int *piVar2; + + puVar1 = (undefined4 *) + (*(int *)(param_1 + 0x60) + + ((uint)(*param_3 + param_3[1]) % *(uint *)(param_1 + 0x68)) * 4); + for (piVar2 = (int *)*puVar1; + (piVar2 != (int *)0x0 && ((*piVar2 != *param_3 || (piVar2[1] != param_3[1])))); + piVar2 = (int *)piVar2[2]) { + } + param_2[1] = (int)puVar1; + *param_2 = param_1; + param_2[2] = (int)piVar2; + return; +} + + + +// --- FUN_004141e0 at 0x004141E0 (size: 424) --- + +undefined1 FUN_004141e0(void) + +{ + char cVar1; + undefined4 *puVar2; + LONG LVar3; + int *piVar4; + int *piVar5; + int local_10; + int local_c; + int local_8; + int iStack_4; + + if (DAT_00837c68 == 0) { + puVar2 = (undefined4 *)FUN_005df0f5(4); + if (puVar2 == (undefined4 *)0x0) { + puVar2 = (undefined4 *)0x0; + } + else { + *puVar2 = &PTR_FUN_00795f5c; + } + cVar1 = FUN_0041c220(puVar2); + if (cVar1 == '\0') { + return 0; + } + } + piVar5 = &local_10; + FUN_00401340(&DAT_007954ac); + piVar4 = &local_c; + FUN_00423430(&local_8,&DAT_00837be4,&local_10,piVar4); + FUN_0040bbc0(piVar5,piVar4); + puVar2 = (undefined4 *)(local_8 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar3 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_c + -0x14); + LVar3 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar3 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_0041c2e0(&local_10); + FUN_00401340(&DAT_007954ac); + piVar4 = &local_c; + piVar5 = &local_8; + FUN_00423430(&iStack_4,&DAT_00837be8,piVar5,piVar4); + piVar4 = (int *)FUN_0040bbc0(piVar5,piVar4); + if (local_10 != *piVar4) { + LVar3 = InterlockedDecrement((LONG *)(local_10 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(local_10 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_10 + -0x14))(1); + } + local_10 = *piVar4; + InterlockedIncrement((LONG *)(local_10 + -0x10)); + } + LVar3 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(local_8 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_8 + -0x14))(1); + } + LVar3 = InterlockedDecrement((LONG *)(iStack_4 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iStack_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iStack_4 + -0x14))(1); + } + LVar3 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(local_c + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_c + -0x14))(1); + } + FUN_0041c330(&local_10); + puVar2 = (undefined4 *)(local_10 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(local_10 + -0x10)); + if ((LVar3 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return 1; +} + + + +// --- FUN_00414390 at 0x00414390 (size: 92) --- + +void FUN_00414390(void) + +{ + int iVar1; + int *piVar2; + int iVar3; + undefined1 auStack_c [12]; + + FUN_00417710(); + piVar2 = (int *)FUN_0052dcf0(auStack_c); + iVar3 = piVar2[2]; + iVar1 = *piVar2; + piVar2 = (int *)piVar2[1]; + do { + if (iVar3 == 0) { + return; + } + do { + if (*(int *)(iVar3 + 8) != 0) { + FUN_00416ac0(); + } + iVar3 = *(int *)(iVar3 + 4); + } while (iVar3 != 0); + do { + piVar2 = piVar2 + 1; + if (piVar2 == (int *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) { + return; + } + iVar3 = *piVar2; + } while (iVar3 == 0); + } while( true ); +} + + + +// --- FUN_004144e0 at 0x004144E0 (size: 82) --- + +void FUN_004144e0(uint param_1) + +{ + int iVar1; + uint *puVar2; + int *piVar3; + int iVar4; + undefined1 auStack_c [12]; + + if (param_1 == 0) { + piVar3 = (int *)FUN_0052dcf0(auStack_c); + iVar4 = piVar3[2]; + iVar1 = *piVar3; + piVar3 = (int *)piVar3[1]; + while (iVar4 != 0) { + do { + if (*(int **)(iVar4 + 8) != (int *)0x0) { + (**(code **)(**(int **)(iVar4 + 8) + 0x28))(); + } + iVar4 = *(int *)(iVar4 + 4); + } while (iVar4 != 0); + do { + piVar3 = piVar3 + 1; + if (piVar3 == (int *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) { + return; + } + iVar4 = *piVar3; + } while (iVar4 == 0); + } + } + else { + puVar2 = *(uint **)(DAT_0081866c + (param_1 % DAT_00818674) * 4); + if (puVar2 != (uint *)0x0) { + while (*puVar2 != param_1) { + puVar2 = (uint *)puVar2[1]; + if (puVar2 == (uint *)0x0) { + return; + } + } + if ((puVar2 != (uint *)0x0) && (puVar2 + 2 != (uint *)0x0)) { + (**(code **)(*(int *)puVar2[2] + 0x28))(); + return; + } + } + } + return; +} + + + +// --- FUN_00414532 at 0x00414532 (size: 90) --- + +void FUN_00414532(void) + +{ + int iVar1; + int *piVar2; + int iVar3; + + piVar2 = (int *)FUN_0052dcf0(&stack0x00000000); + iVar3 = piVar2[2]; + iVar1 = *piVar2; + piVar2 = (int *)piVar2[1]; + do { + if (iVar3 == 0) { + return; + } + do { + if (*(int **)(iVar3 + 8) != (int *)0x0) { + (**(code **)(**(int **)(iVar3 + 8) + 0x28))(); + } + iVar3 = *(int *)(iVar3 + 4); + } while (iVar3 != 0); + do { + piVar2 = piVar2 + 1; + if (piVar2 == (int *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) { + return; + } + iVar3 = *piVar2; + } while (iVar3 == 0); + } while( true ); +} + + + +// --- FUN_00414590 at 0x00414590 (size: 61) --- + +uint FUN_00414590(uint param_1) + +{ + uint *puVar1; + + puVar1 = *(uint **)(DAT_0081866c + (param_1 % DAT_00818674) * 4); + if (puVar1 != (uint *)0x0) { + while (*puVar1 != param_1) { + puVar1 = (uint *)puVar1[1]; + if (puVar1 == (uint *)0x0) { + return 0; + } + } + if ((puVar1 != (uint *)0x0) && (puVar1 + 2 != (uint *)0x0)) { + return puVar1[2]; + } + } + return 0; +} + + + +// --- FUN_004145d0 at 0x004145D0 (size: 73) --- + +void __fastcall FUN_004145d0(int param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + undefined4 local_4; + + puVar1 = PTR_DAT_00818558; + local_4 = *(undefined4 *)(param_1 + 0x68); + puVar2 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,local_4,0); + if ((puVar2 != (undefined4 *)puVar1) || (puVar2 = puVar2 + -1, puVar2 != (undefined4 *)puVar1)) { + puVar2 = puVar2 + 1; + } + FUN_004148b0(*puVar2); + return; +} + + + +// --- FUN_00414620 at 0x00414620 (size: 143) --- + +undefined4 FUN_00414620(undefined4 param_1,int param_2) + +{ + int iVar1; + int *piVar2; + int iVar3; + undefined1 local_c [12]; + + if (param_2 == 0) { + piVar2 = (int *)FUN_0052dcf0(local_c); + iVar3 = piVar2[2]; + iVar1 = *piVar2; + piVar2 = (int *)piVar2[1]; + while (iVar3 != 0) { + do { + if (*(int *)(iVar3 + 8) != 0) { + FUN_00416970(param_1); + } + iVar3 = *(int *)(iVar3 + 4); + } while (iVar3 != 0); + do { + piVar2 = piVar2 + 1; + if (piVar2 == (int *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) { + return 1; + } + iVar3 = *piVar2; + } while (iVar3 == 0); + } + } + else { + iVar1 = FUN_00414590(param_2); + if (iVar1 != 0) { + FUN_00416970(param_1); + return 1; + } + } + return 1; +} + + + +// --- FUN_00414700 at 0x00414700 (size: 143) --- + +undefined4 * __thiscall FUN_00414700(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00795f84; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00414790 at 0x00414790 (size: 143) --- + +undefined4 * __thiscall FUN_00414790(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00795f90; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00414820 at 0x00414820 (size: 143) --- + +undefined4 * __thiscall FUN_00414820(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00795f94; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_004148b0 at 0x004148B0 (size: 319) --- + +undefined4 __thiscall FUN_004148b0(int param_1,int param_2) + +{ + int iVar1; + int iVar2; + int *piVar3; + undefined4 *puVar4; + int *piVar5; + int *piVar6; + undefined4 *puVar7; + int *piVar8; + uint uVar9; + int *piVar10; + + iVar2 = param_2; + if (param_2 == *(int *)(param_1 + 0x68)) { + return 0; + } + iVar1 = *(int *)(param_1 + 0x6c); + piVar3 = (int *)0x0; + do { + if (iVar1 == 0) { + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_00693b20(iVar2); + puVar4 = (undefined4 *)PTR_DAT_00818558; + while (piVar3 != (int *)0x0) { + param_2 = *(int *)(param_1 + 0x68); + piVar10 = (int *)piVar3[2]; + PTR_DAT_00818558 = (undefined *)puVar4; + if (param_2 * 2 < *(int *)(param_1 + 0x6c) + 1) { + puVar7 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,puVar4,¶m_2,param_2,0); + if ((puVar7 != puVar4) || (puVar7 = puVar7 + -1, puVar7 != puVar4)) { + puVar7 = puVar7 + 1; + } + FUN_004148b0(*puVar7); + } + uVar9 = (uint)(piVar3[1] + *piVar3) % *(uint *)(param_1 + 0x68); + iVar2 = *(int *)(param_1 + 0x60); + piVar3[2] = *(int *)(iVar2 + uVar9 * 4); + *(int **)(iVar2 + uVar9 * 4) = piVar3; + uVar9 = iVar2 + uVar9 * 4; + if (uVar9 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar9; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + puVar4 = (undefined4 *)PTR_DAT_00818558; + piVar3 = piVar10; + } + PTR_DAT_00818558 = (undefined *)puVar4; + return 1; + } + piVar10 = *(int **)(param_1 + 100); + while (piVar10 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar10 = *(int **)(param_1 + 100); + piVar8 = (int *)*piVar10; + goto LAB_004148ff; + } + piVar10 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar10; + } + piVar10 = (int *)0x0; + piVar8 = (int *)0x0; +LAB_004148ff: + piVar6 = (int *)*piVar10; + if (piVar6 == piVar8) { +LAB_00414912: + *piVar10 = piVar6[2]; + } + else { + do { + piVar5 = piVar6; + piVar6 = (int *)piVar5[2]; + } while (piVar6 != piVar8); + if (piVar5 == (int *)0x0) goto LAB_00414912; + piVar5[2] = piVar6[2]; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + piVar8[2] = (int)piVar3; + iVar1 = *(int *)(param_1 + 0x6c); + piVar3 = piVar8; + } while( true ); +} + + + +// --- FUN_004149f0 at 0x004149F0 (size: 52) --- + +undefined4 * __thiscall FUN_004149f0(undefined4 *param_1,undefined4 param_2) + +{ + FUN_00414700(param_2); + *param_1 = &PTR_FUN_00795f98; + param_1[0x1c] = 0; + param_1[0x1d] = 0; + param_1[0x1e] = 0; + param_1[0x1f] = 0xffffffff; + param_1[0x1e] = 0; + param_1[0x1d] = 0; + param_1[0x1c] = param_1; + return param_1; +} + + + +// --- FUN_00414a30 at 0x00414A30 (size: 30) --- + +void * __thiscall FUN_00414a30(void *param_1,byte param_2) + +{ + FUN_0041a410(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00414a50 at 0x00414A50 (size: 110) --- + +uint __thiscall FUN_00414a50(int param_1,int *param_2) + +{ + int iVar1; + uint uVar2; + undefined1 local_c [8]; + uint local_4; + + FUN_00414190(local_c,param_2); + if (local_4 != 0) { + return local_4 & 0xffffff00; + } + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + FUN_004145d0(); + } + uVar2 = (uint)(param_2[1] + *param_2) % *(uint *)(param_1 + 0x68); + iVar1 = *(int *)(param_1 + 0x60); + param_2[2] = *(int *)(iVar1 + uVar2 * 4); + *(int **)(iVar1 + uVar2 * 4) = param_2; + uVar2 = iVar1 + uVar2 * 4; + if (uVar2 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar2; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + return CONCAT31((int3)(uVar2 >> 8),1); +} + + + +// --- FUN_00414ac0 at 0x00414AC0 (size: 269) --- + +undefined4 __thiscall FUN_00414ac0(int param_1,int param_2) + +{ + int iVar1; + int *piVar2; + int *piVar3; + int *piVar4; + undefined4 uVar5; + int *piVar6; + uint uVar7; + int *piVar8; + + if (param_2 == *(int *)(param_1 + 0x68)) { + return 0; + } + iVar1 = *(int *)(param_1 + 0x6c); + piVar2 = (int *)0x0; + do { + if (iVar1 == 0) { + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_00693b20(param_2); + while (piVar2 != (int *)0x0) { + piVar8 = (int *)piVar2[2]; + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + uVar5 = FUN_004184d0(*(int *)(param_1 + 0x68)); + FUN_00414ac0(uVar5); + } + uVar7 = (uint)(piVar2[1] + *piVar2) % *(uint *)(param_1 + 0x68); + iVar1 = *(int *)(param_1 + 0x60); + piVar2[2] = *(int *)(iVar1 + uVar7 * 4); + *(int **)(iVar1 + uVar7 * 4) = piVar2; + uVar7 = iVar1 + uVar7 * 4; + if (uVar7 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar7; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + piVar2 = piVar8; + } + return 1; + } + piVar8 = *(int **)(param_1 + 100); + while (piVar8 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar8 = *(int **)(param_1 + 100); + piVar6 = (int *)*piVar8; + goto LAB_00414b0e; + } + piVar8 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar8; + } + piVar8 = (int *)0x0; + piVar6 = (int *)0x0; +LAB_00414b0e: + piVar4 = (int *)*piVar8; + if (piVar4 == piVar6) { +LAB_00414b21: + *piVar8 = piVar4[2]; + } + else { + do { + piVar3 = piVar4; + piVar4 = (int *)piVar3[2]; + } while (piVar4 != piVar6); + if (piVar3 == (int *)0x0) goto LAB_00414b21; + piVar3[2] = piVar4[2]; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + piVar6[2] = (int)piVar2; + iVar1 = *(int *)(param_1 + 0x6c); + piVar2 = piVar6; + } while( true ); +} + + + +// --- FUN_00414bd0 at 0x00414BD0 (size: 264) --- + +undefined4 __thiscall FUN_00414bd0(int param_1,int param_2) + +{ + int iVar1; + uint *puVar2; + int *piVar3; + uint *puVar4; + uint *puVar5; + undefined4 uVar6; + uint *puVar7; + uint uVar8; + uint *puVar9; + + if (param_2 == *(int *)(param_1 + 0x68)) { + return 0; + } + iVar1 = *(int *)(param_1 + 0x6c); + puVar2 = (uint *)0x0; + do { + if (iVar1 == 0) { + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_00693b20(param_2); + while (puVar2 != (uint *)0x0) { + puVar9 = (uint *)puVar2[1]; + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + uVar6 = FUN_004184d0(*(int *)(param_1 + 0x68)); + FUN_00414bd0(uVar6); + } + uVar8 = *puVar2 % *(uint *)(param_1 + 0x68); + iVar1 = *(int *)(param_1 + 0x60); + puVar2[1] = *(uint *)(iVar1 + uVar8 * 4); + *(uint **)(iVar1 + uVar8 * 4) = puVar2; + uVar8 = iVar1 + uVar8 * 4; + if (uVar8 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar8; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + puVar2 = puVar9; + } + return 1; + } + piVar3 = *(int **)(param_1 + 100); + while (piVar3 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + puVar9 = *(uint **)(param_1 + 100); + puVar7 = (uint *)*puVar9; + goto LAB_00414c1e; + } + piVar3 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar3; + } + puVar9 = (uint *)0x0; + puVar7 = (uint *)0x0; +LAB_00414c1e: + puVar5 = (uint *)*puVar9; + if (puVar5 == puVar7) { +LAB_00414c31: + *puVar9 = puVar5[1]; + } + else { + do { + puVar4 = puVar5; + puVar5 = (uint *)puVar4[1]; + } while (puVar5 != puVar7); + if (puVar4 == (uint *)0x0) goto LAB_00414c31; + puVar4[1] = puVar5[1]; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + puVar7[1] = (uint)puVar2; + iVar1 = *(int *)(param_1 + 0x6c); + puVar2 = puVar7; + } while( true ); +} + + + +// --- FUN_00414ce0 at 0x00414CE0 (size: 73) --- + +void __fastcall FUN_00414ce0(int param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + undefined4 local_4; + + puVar1 = PTR_DAT_00818558; + local_4 = *(undefined4 *)(param_1 + 0x68); + puVar2 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,local_4,0); + if ((puVar2 != (undefined4 *)puVar1) || (puVar2 = puVar2 + -1, puVar2 != (undefined4 *)puVar1)) { + puVar2 = puVar2 + 1; + } + FUN_00414ac0(*puVar2); + return; +} + + + +// --- FUN_00414d30 at 0x00414D30 (size: 73) --- + +void __fastcall FUN_00414d30(int param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + undefined4 local_4; + + puVar1 = PTR_DAT_00818558; + local_4 = *(undefined4 *)(param_1 + 0x68); + puVar2 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,local_4,0); + if ((puVar2 != (undefined4 *)puVar1) || (puVar2 = puVar2 + -1, puVar2 != (undefined4 *)puVar1)) { + puVar2 = puVar2 + 1; + } + FUN_00414bd0(*puVar2); + return; +} + + + +// --- FUN_00414d80 at 0x00414D80 (size: 112) --- + +undefined4 FUN_00414d80(undefined4 *param_1) + +{ + undefined4 *puVar1; + undefined1 local_c [8]; + int local_4; + + FUN_00414190(local_c,param_1); + if (local_4 != 0) { + return 0; + } + puVar1 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar1 != (undefined4 *)0x0) { + *puVar1 = *param_1; + puVar1[1] = param_1[1]; + puVar1[2] = 0; + FUN_00414a50(puVar1); + return 1; + } + FUN_00414a50(0); + return 1; +} + + + +// --- FUN_00414df0 at 0x00414DF0 (size: 82) --- + +undefined4 * __thiscall FUN_00414df0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795fa0; + FUN_0041a390(); + param_1[1] = &PTR_FUN_00795f94; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00414e90 at 0x00414E90 (size: 160) --- + +void __thiscall FUN_00414e90(int param_1,undefined4 param_2) + +{ + int iVar1; + int iVar2; + undefined4 *puVar3; + undefined1 local_90 [4]; + undefined1 local_8c [12]; + undefined1 local_80 [128]; + + iVar2 = FUN_00414190(local_8c,param_2); + iVar1 = DAT_00837bac; + if ((*(int *)(iVar2 + 8) == 0) && (DAT_00837bac != 0)) { + if (DAT_00837c20 == *(int *)(param_1 + 4)) { + puVar3 = (undefined4 *) + (**(code **)(*(int *)(DAT_00837bac + 4) + 0x14))(local_90,3,param_2,param_1,0); + *(undefined4 *)(param_1 + 4) = *puVar3; + } + else { + FUN_004149f0(0x20); + FUN_0041a4e0(param_2,0); + (**(code **)(*(int *)(iVar1 + 4) + 0x30))(*(undefined4 *)(param_1 + 4),3,local_80); + FUN_0041a410(); + } + FUN_00414d80(param_2); + } + return; +} + + + +// --- FUN_00414f80 at 0x00414F80 (size: 85) --- + +int FUN_00414f80(undefined4 param_1) + +{ + undefined4 local_c; + undefined4 local_8; + int local_4; + + FUN_00414190(&local_c,param_1); + if (local_4 != 0) { + FUN_00540830(local_c,local_8,local_4); + return local_4; + } + return 0; +} + + + +// --- FUN_00415040 at 0x00415040 (size: 105) --- + +void __fastcall FUN_00415040(int *param_1) + +{ + int iVar1; + int *piVar2; + int iVar3; + + (**(code **)(*param_1 + 0x38))(1); + piVar2 = (int *)FUN_0052dcf0(&stack0xfffffff0); + iVar3 = piVar2[2]; + iVar1 = *piVar2; + piVar2 = (int *)piVar2[1]; + while (iVar3 != 0) { + do { + if (*(undefined4 **)(iVar3 + 8) != (undefined4 *)0x0) { + (**(code **)**(undefined4 **)(iVar3 + 8))(1); + } + iVar3 = *(int *)(iVar3 + 4); + } while (iVar3 != 0); + do { + piVar2 = piVar2 + 1; + if (piVar2 == (int *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) goto LAB_00415098; + iVar3 = *piVar2; + } while (iVar3 == 0); + } +LAB_00415098: + FUN_005870f0(); + return; +} + + + +// --- FUN_004150b0 at 0x004150B0 (size: 82) --- + +undefined4 * __thiscall FUN_004150b0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00795f9c; + FUN_005870f0(); + param_1[1] = &PTR_FUN_00795f90; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00415110 at 0x00415110 (size: 148) --- + +void __fastcall FUN_00415110(int param_1) + +{ + *(undefined ***)(param_1 + 0x94) = &PTR_FUN_007963a4; + FUN_005870f0(); + *(undefined ***)(param_1 + 0x98) = &PTR_FUN_00795f8c; + if (*(void **)(param_1 + 0xf8) != (void *)(param_1 + 0x9c)) { + operator_delete__(*(void **)(param_1 + 0xf8)); + } + *(undefined4 *)(param_1 + 0xf8) = 0; + *(undefined4 *)(param_1 + 0xfc) = 0; + *(undefined4 *)(param_1 + 0x100) = 0; + *(undefined4 *)(param_1 + 0x104) = 0; + *(undefined ***)(param_1 + 0x20) = &PTR_FUN_007963a8; + FUN_0041a390(); + *(undefined ***)(param_1 + 0x24) = &PTR_FUN_00795f88; + if (*(void **)(param_1 + 0x84) != (void *)(param_1 + 0x28)) { + operator_delete__(*(void **)(param_1 + 0x84)); + } + *(undefined4 *)(param_1 + 0x84) = 0; + *(undefined4 *)(param_1 + 0x88) = 0; + *(undefined4 *)(param_1 + 0x8c) = 0; + *(undefined4 *)(param_1 + 0x90) = 0; + *(undefined ***)(param_1 + 4) = &PTR_FUN_00795f70; + if (*(void **)(param_1 + 8) != (void *)0x0) { + operator_delete__(*(void **)(param_1 + 8)); + } + return; +} + + + +// --- FUN_004151b0 at 0x004151B0 (size: 94) --- + +void __fastcall FUN_004151b0(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_00796058; + param_1[1] = &PTR_FUN_00795fb0; + FUN_0041c240(); + if (DAT_00837bac != 0) { + (**(code **)(*(int *)(DAT_00837bac + 4) + 0x34))(DAT_00818684); + } + DAT_00818684 = DAT_00837c20; + DAT_00837bac = 0; + DAT_00837ba8 = 0; + param_1[0x45] = &PTR_LAB_00793b6c; + FUN_00415110(); + return; +} + + + +// --- FUN_00415210 at 0x00415210 (size: 86) --- + +void __thiscall FUN_00415210(int *param_1,undefined4 *param_2,int *param_3,undefined4 *param_4) + +{ + if ((((*param_3 == -0x21524111) && (param_3[1] == DAT_00795f50)) && (param_3[2] == DAT_00795f54)) + && ((param_3[3] == DAT_00795f58 && (param_1 != (int *)0x0)))) { + *param_4 = param_1; + (**(code **)(*param_1 + 0x10))(); + *param_2 = 0; + return; + } + *param_2 = 0x80004002; + return; +} + + + +// --- FUN_00415280 at 0x00415280 (size: 39) --- + +int __fastcall FUN_00415280(int *param_1) + +{ + int iVar1; + + iVar1 = FUN_00401ea0(); + if ((iVar1 == 0) && (param_1 != (int *)0x0)) { + (**(code **)(*param_1 + 0x18))(1); + } + return iVar1; +} + + + +// --- FUN_00415320 at 0x00415320 (size: 123) --- + +undefined4 * __fastcall FUN_00415320(undefined4 *param_1) + +{ + FUN_0041a210(); + *param_1 = &PTR_LAB_00796058; + param_1[1] = &PTR_FUN_00795fb0; + param_1[0x45] = &PTR_LAB_00793b6c; + param_1[0x46] = 1; + param_1[0x47] = DAT_00837bb0; + param_1[0x48] = 0; + param_1[0x49] = 0; + *(undefined1 *)(param_1 + 0x4a) = 1; + *(undefined1 *)((int)param_1 + 0x129) = 0; + *(undefined1 *)((int)param_1 + 0x12a) = 0; + param_1[0x4b] = 0; + if (DAT_00837bac != (int *)0x0) { + (**(code **)(*DAT_00837bac + 0x18))(1); + } + DAT_00837bac = param_1; + return param_1; +} + + + +// --- FUN_004153a0 at 0x004153A0 (size: 30) --- + +void * __thiscall FUN_004153a0(void *param_1,byte param_2) + +{ + FUN_004151b0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004153c0 at 0x004153C0 (size: 8) --- + +void __fastcall FUN_004153c0(undefined4 param_1) + +{ + FUN_00413de0(param_1); + return; +} + + + +// --- FUN_004153d0 at 0x004153D0 (size: 33) --- + +int __fastcall FUN_004153d0(int param_1) + +{ + int iVar1; + + if (*(int *)(param_1 + 0x20) != 0) { + FUN_00416f40(*(undefined4 *)(param_1 + 0x28)); + return *(int *)(param_1 + 0x24); + } + iVar1 = *(int *)(param_1 + 0x24) + 1; + *(int *)(param_1 + 0x24) = iVar1; + return iVar1; +} + + + +// --- FUN_00415400 at 0x00415400 (size: 38) --- + +int __fastcall FUN_00415400(int *param_1) + +{ + int iVar1; + + if ((int *)param_1[8] != (int *)0x0) { + iVar1 = (**(code **)(*(int *)param_1[8] + 0x14))(param_1[10]); + return iVar1; + } + iVar1 = param_1[9] + -1; + param_1[9] = iVar1; + if (iVar1 == 0) { + (**(code **)(*param_1 + 0x18))(1); + iVar1 = 0; + } + return iVar1; +} + + + +// --- FUN_00415430 at 0x00415430 (size: 27) --- + +undefined4 FUN_00415430(undefined4 param_1) + +{ + undefined4 uVar1; + + if (DAT_00837bac != 0) { + uVar1 = (*(code *)**(undefined4 **)(DAT_00837bac + 4))(2,param_1); + return uVar1; + } + return 0; +} + + + +// --- thunk_FUN_00413a30 at 0x00415450 (size: 5) --- + +undefined4 thunk_FUN_00413a30(undefined4 param_1) + +{ + undefined4 uVar1; + + if (DAT_00837bac != (int *)0x0) { + uVar1 = (**(code **)(*DAT_00837bac + 0x2c))(param_1); + return uVar1; + } + return 0; +} + + + +// --- FUN_00415460 at 0x00415460 (size: 52) --- + +void __thiscall FUN_00415460(undefined4 *param_1,undefined4 param_2) + +{ + param_1[1] = 0; + *(undefined1 *)(param_1 + 2) = 0; + param_1[4] = 0; + param_1[5] = 0; + param_1[6] = 0; + param_1[7] = 0; + param_1[8] = 0; + *param_1 = &PTR_LAB_007961e0; + param_1[9] = 1; + param_1[10] = param_2; + *(undefined1 *)(param_1 + 0xb) = 1; + return; +} + + + +// --- FUN_004154a0 at 0x004154A0 (size: 3) --- + +undefined1 FUN_004154a0(void) + +{ + return 1; +} + + + +// --- FUN_004154b0 at 0x004154B0 (size: 7) --- + +void __fastcall FUN_004154b0(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_007961e0; + return; +} + + + +// --- FUN_00415520 at 0x00415520 (size: 45) --- + +undefined4 __fastcall FUN_00415520(int *param_1) + +{ + undefined4 uVar1; + int *piVar2; + + if (param_1[10] != 0) { + uVar1 = (**(code **)(*param_1 + 0x48))(); + piVar2 = (int *)FUN_00414590(uVar1); + if (piVar2 != (int *)0x0) { + uVar1 = (**(code **)(*piVar2 + 0x30))(param_1[10]); + return uVar1; + } + } + return 0; +} + + + +// --- FUN_00415550 at 0x00415550 (size: 51) --- + +undefined4 __thiscall FUN_00415550(int *param_1,undefined4 param_2) + +{ + undefined4 uVar1; + int *piVar2; + + if (param_1[10] != 0) { + uVar1 = (**(code **)(*param_1 + 0x48))(); + piVar2 = (int *)FUN_00414590(uVar1); + if (piVar2 != (int *)0x0) { + uVar1 = (**(code **)(*piVar2 + 0x2c))(param_2,param_1); + return uVar1; + } + } + return 0; +} + + + +// --- FUN_00415590 at 0x00415590 (size: 116) --- + +void __thiscall FUN_00415590(int *param_1,int param_2) + +{ + char cVar1; + int *piVar2; + undefined4 uVar3; + + FUN_0040ad10(4); + piVar2 = (int *)FUN_0040acf0(4); + if (piVar2 != (int *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + param_1[10] = *piVar2; + } + else { + *piVar2 = param_1[10]; + } + } + uVar3 = (**(code **)(*param_1 + 0x48))(); + cVar1 = FUN_0041c4e0(uVar3); + if (cVar1 != '\0') { + FUN_0040ad10(4); + piVar2 = (int *)FUN_0040acf0(4); + if (piVar2 != (int *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *piVar2 = param_1[1]; + return; + } + param_1[1] = *piVar2; + } + } + return; +} + + + +// --- FUN_00415610 at 0x00415610 (size: 45) --- + +void FUN_00415610(int *param_1) + +{ + int iVar1; + undefined4 uVar2; + int *piVar3; + + iVar1 = (**(code **)(*param_1 + 0x48))(); + if (iVar1 != 0) { + uVar2 = (**(code **)(*param_1 + 0x48))(); + piVar3 = (int *)FUN_00414590(uVar2); + (**(code **)(*piVar3 + 0x1c))(param_1[10]); + } + return; +} + + + +// --- FUN_00415640 at 0x00415640 (size: 28) --- + +undefined4 FUN_00415640(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + FUN_00413bc0(param_1,param_2,param_3); + return param_1; +} + + + +// --- FUN_00415660 at 0x00415660 (size: 55) --- + +void __fastcall FUN_00415660(int *param_1) + +{ + int iVar1; + int iVar2; + int *piVar3; + + iVar1 = *(int *)(param_1[2] + 8); + param_1[2] = iVar1; + if (iVar1 == 0) { + iVar1 = *(int *)(*param_1 + 0x68); + iVar2 = *(int *)(*param_1 + 0x60); + do { + piVar3 = (int *)(param_1[1] + 4); + param_1[1] = (int)piVar3; + if (piVar3 == (int *)(iVar2 + iVar1 * 4)) { + return; + } + } while (*piVar3 == 0); + param_1[2] = *piVar3; + } + return; +} + + + +// --- FUN_004156a0 at 0x004156A0 (size: 112) --- + +undefined * __thiscall FUN_004156a0(int param_1,int param_2) + +{ + undefined4 *puVar1; + undefined1 local_c [12]; + + if (param_2 == 0) { + puVar1 = (undefined4 *)FUN_0052dcf0(local_c); + *(undefined4 *)(param_1 + 0x70) = *puVar1; + *(undefined4 *)(param_1 + 0x78) = puVar1[2]; + *(undefined4 *)(param_1 + 0x74) = puVar1[1]; + } + else if (param_2 != *(int *)(param_1 + 0x7c)) { + if ((*(int *)(param_1 + 0x78) == 0) || (param_2 != *(int *)(param_1 + 0x7c) + 1)) { + FUN_0041a2a0(param_2); + } + else { + FUN_00415660(); + } + } + if (*(undefined **)(param_1 + 0x78) != (undefined *)0x0) { + *(int *)(param_1 + 0x7c) = param_2; + return *(undefined **)(param_1 + 0x78); + } + return &DAT_00837cbc; +} + + + +// --- FUN_00415730 at 0x00415730 (size: 40) --- + +void FUN_00415730(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + undefined4 local_4; + + FUN_00413bc0(&local_4,param_1,param_2); + FUN_00413b80(local_4,param_3); + return; +} + + + +// --- FUN_00415830 at 0x00415830 (size: 64) --- + +undefined4 * __thiscall FUN_00415830(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00796294; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00415870 at 0x00415870 (size: 64) --- + +undefined4 * __thiscall FUN_00415870(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00796298; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004158b0 at 0x004158B0 (size: 93) --- + +void __fastcall FUN_004158b0(int *param_1) + +{ + int iVar1; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) == 0x80000000) { + if (*param_1 != 0) { + operator_delete__((void *)(*param_1 + -4)); + } + *param_1 = 0; + param_1[1] = 0; + return; + } + if (*param_1 != 0) { + iVar1 = (param_1[1] & 0x7fffffffU) - 1; + while (-1 < iVar1) { + iVar1 = iVar1 + -1; + *(int **)(*param_1 + 4 + iVar1 * 4) = param_1; + } + } + return; +} + + + +// --- FUN_00415910 at 0x00415910 (size: 184) --- + +undefined4 __thiscall FUN_00415910(int *param_1,uint param_2) + +{ + uint *puVar1; + int iVar2; + uint *puVar3; + + if ((uint)param_1[2] <= param_2) { + if (param_2 <= (param_1[1] & 0x7fffffffU)) { + return 1; + } + if (param_2 == 0) { + FUN_004158b0(); + return 1; + } + puVar3 = (uint *)thunk_FUN_005df0f5(param_2 * 4 + 4); + if (puVar3 != (uint *)0x0) { + puVar1 = puVar3 + 1; + *puVar3 = param_2; + FUN_00401000(puVar1,4,param_2,FUN_0050a140); + if (puVar1 != (uint *)0x0) { + if (*param_1 != 0) { + iVar2 = param_1[2] + -1; + while (-1 < iVar2) { + puVar3[iVar2 + 1] = *(uint *)(*param_1 + 4 + (iVar2 + -1) * 4); + iVar2 = iVar2 + -1; + } + if (((param_1[1] & 0x80000000U) == 0x80000000) && (*param_1 != 0)) { + operator_delete__((void *)(*param_1 + -4)); + } + } + *param_1 = (int)puVar1; + param_1[1] = param_2 | 0x80000000; + return 1; + } + } + } + return 0; +} + + + +// --- FUN_004159d0 at 0x004159D0 (size: 291) --- + +undefined4 __thiscall FUN_004159d0(int param_1,undefined4 *param_2,undefined4 *param_3) + +{ + int *piVar1; + int iVar2; + int iVar3; + undefined4 *puVar4; + undefined1 local_c [12]; + + piVar1 = (int *)FUN_0052dcf0(local_c); + puVar4 = (undefined4 *)piVar1[2]; + iVar3 = *piVar1; + piVar1 = (int *)piVar1[1]; + while (puVar4 != (undefined4 *)0x0) { + do { + iVar2 = _stricmp((char *)*param_2,(char *)puVar4[2]); + if (iVar2 == 0) { + *param_3 = *puVar4; + return 1; + } + puVar4 = (undefined4 *)puVar4[1]; + } while (puVar4 != (undefined4 *)0x0); + do { + piVar1 = piVar1 + 1; + if (piVar1 == (int *)(*(int *)(iVar3 + 0x60) + *(int *)(iVar3 + 0x68) * 4)) goto LAB_00415a33; + puVar4 = (undefined4 *)*piVar1; + } while (puVar4 == (undefined4 *)0x0); + } +LAB_00415a33: + piVar1 = *(int **)(param_1 + 500); + do { + if (piVar1 == (int *)(*(int *)(param_1 + 0x1f0) + *(int *)(param_1 + 0x1f8) * 4)) { + piVar1 = (int *)0x0; + puVar4 = (undefined4 *)0x0; +joined_r0x00415a8e: + do { + if (puVar4 == (undefined4 *)0x0) { + return 0; + } + do { + iVar3 = _stricmp((char *)*param_2,(char *)puVar4[2]); + if (iVar3 == 0) { + *param_3 = *puVar4; + return 1; + } + puVar4 = (undefined4 *)puVar4[1]; + } while (puVar4 != (undefined4 *)0x0); + do { + piVar1 = piVar1 + 1; + if (piVar1 == (int *)(*(int *)(param_1 + 0x1f0) + *(int *)(param_1 + 0x1f8) * 4)) { + return 0; + } + puVar4 = (undefined4 *)*piVar1; + } while (puVar4 == (undefined4 *)0x0); + } while( true ); + } + if (**(int **)(param_1 + 500) != 0) { + piVar1 = *(int **)(param_1 + 500); + puVar4 = (undefined4 *)*piVar1; + goto joined_r0x00415a8e; + } + piVar1 = *(int **)(param_1 + 500) + 1; + *(int **)(param_1 + 500) = piVar1; + } while( true ); +} + + + +// --- FUN_00415b00 at 0x00415B00 (size: 265) --- + +void __fastcall FUN_00415b00(int param_1) + +{ + int *piVar1; + undefined4 uVar2; + int iVar3; + undefined4 uVar4; + undefined1 local_20 [12]; + int local_14; + + piVar1 = (int *)FUN_0052dcf0(local_20); + iVar3 = piVar1[2]; + local_14 = *piVar1; + piVar1 = (int *)piVar1[1]; + while (iVar3 != 0) { + do { + uVar4 = 0; + uVar2 = FUN_004220b0(*(undefined4 *)(iVar3 + 8),0); + FUN_0041a4e0(uVar2,uVar4); + iVar3 = *(int *)(iVar3 + 4); + } while (iVar3 != 0); + do { + piVar1 = piVar1 + 1; + if (piVar1 == (int *)(*(int *)(local_14 + 0x60) + *(int *)(local_14 + 0x68) * 4)) + goto LAB_00415b73; + iVar3 = *piVar1; + } while (iVar3 == 0); + } +LAB_00415b73: + piVar1 = *(int **)(param_1 + 0x10c); + do { + if (piVar1 == (int *)(*(int *)(param_1 + 0x108) + *(int *)(param_1 + 0x110) * 4)) { + piVar1 = (int *)0x0; + iVar3 = 0; +joined_r0x00415bba: + do { + if (iVar3 == 0) { + return; + } + do { + uVar4 = 2; + uVar2 = FUN_004220b0(*(undefined4 *)(iVar3 + 8),0); + FUN_0041a4e0(uVar2,uVar4); + iVar3 = *(int *)(iVar3 + 4); + } while (iVar3 != 0); + do { + piVar1 = piVar1 + 1; + if (piVar1 == (int *)(*(int *)(param_1 + 0x108) + *(int *)(param_1 + 0x110) * 4)) { + return; + } + iVar3 = *piVar1; + } while (iVar3 == 0); + } while( true ); + } + if (**(int **)(param_1 + 0x10c) != 0) { + piVar1 = *(int **)(param_1 + 0x10c); + iVar3 = *piVar1; + goto joined_r0x00415bba; + } + piVar1 = *(int **)(param_1 + 0x10c) + 1; + *(int **)(param_1 + 0x10c) = piVar1; + } while( true ); +} + + + +// --- FUN_00415c10 at 0x00415C10 (size: 119) --- + +undefined4 __thiscall FUN_00415c10(int param_1,uint param_2,uint *param_3) + +{ + uint *puVar1; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x94) + (param_2 % *(uint *)(param_1 + 0x9c)) * 4); + do { + if (puVar1 == (uint *)0x0) { +LAB_00415c41: + puVar1 = *(uint **)(*(int *)(param_1 + 0x108) + (param_2 % *(uint *)(param_1 + 0x110)) * 4); + while( true ) { + if (puVar1 == (uint *)0x0) { + return 0; + } + if (*puVar1 == param_2) break; + puVar1 = (uint *)puVar1[1]; + } + if (puVar1 == (uint *)0x0) { + return 0; + } +LAB_00415c75: + *param_3 = puVar1[2]; + return 1; + } + if (*puVar1 == param_2) { + if (puVar1 != (uint *)0x0) goto LAB_00415c75; + goto LAB_00415c41; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_00415c90 at 0x00415C90 (size: 67) --- + +undefined4 FUN_00415c90(undefined4 param_1,undefined4 param_2) + +{ + undefined4 uVar1; + char cVar2; + + uVar1 = param_2; + cVar2 = FUN_0041ae30(¶m_1,param_2); + if (cVar2 == '\0') { + cVar2 = FUN_0041ae30(¶m_1,uVar1); + if (cVar2 == '\0') { + return 0; + } + } + return 1; +} + + + +// --- FUN_00415ce0 at 0x00415CE0 (size: 68) --- + +undefined4 __thiscall FUN_00415ce0(int param_1,uint param_2,uint *param_3) + +{ + uint *puVar1; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x264) + (param_2 % *(uint *)(param_1 + 0x26c)) * 4); + while( true ) { + if (puVar1 == (uint *)0x0) { + return 0; + } + if (*puVar1 == param_2) break; + puVar1 = (uint *)puVar1[1]; + } + if (puVar1 == (uint *)0x0) { + return 0; + } + *param_3 = puVar1[2]; + return CONCAT31((int3)((uint)puVar1 >> 8),1); +} + + + +// --- FUN_00415d30 at 0x00415D30 (size: 143) --- + +undefined4 * __thiscall FUN_00415d30(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00796294; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00415dc0 at 0x00415DC0 (size: 143) --- + +undefined4 * __thiscall FUN_00415dc0(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00796298; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00415e50 at 0x00415E50 (size: 170) --- + +void __fastcall FUN_00415e50(int param_1) + +{ + int iVar1; + void *pvVar2; + void *pvVar3; + LONG LVar4; + int *piVar5; + void *pvVar6; + undefined4 *puVar7; + + iVar1 = *(int *)(param_1 + 0x6c); + do { + if (iVar1 == 0) { + return; + } + piVar5 = *(int **)(param_1 + 100); + while (piVar5 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar5 = *(int **)(param_1 + 100); + pvVar6 = (void *)*piVar5; + goto LAB_00415e94; + } + piVar5 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar5; + } + piVar5 = (int *)0x0; + pvVar6 = (void *)0x0; +LAB_00415e94: + pvVar3 = (void *)*piVar5; + if (pvVar3 == pvVar6) { +LAB_00415ead: + *piVar5 = *(int *)((int)pvVar3 + 4); + } + else { + do { + pvVar2 = pvVar3; + pvVar3 = *(void **)((int)pvVar2 + 4); + } while (pvVar3 != pvVar6); + if (pvVar2 == (void *)0x0) goto LAB_00415ead; + *(undefined4 *)((int)pvVar2 + 4) = *(undefined4 *)((int)pvVar3 + 4); + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + if (pvVar6 != (void *)0x0) { + puVar7 = (undefined4 *)(*(int *)((int)pvVar6 + 8) + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*(int *)((int)pvVar6 + 8) + -0x10)); + if ((LVar4 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + operator_delete(pvVar6); + } + iVar1 = *(int *)(param_1 + 0x6c); + } while( true ); +} + + + +// --- FUN_00415f00 at 0x00415F00 (size: 581) --- + +void FUN_00415f00(undefined4 param_1,int param_2,uint param_3) + +{ + int iVar1; + undefined *puVar2; + undefined *puVar3; + uint uVar4; + char cVar5; + undefined *puVar6; + byte *pbVar7; + int *piVar8; + undefined4 *puVar9; + undefined4 *puVar10; + uint uVar11; + undefined4 *puVar12; + undefined1 local_c [12]; + + uVar4 = param_3; + if ((~*(byte *)(param_3 + 4) & 1) != 0) { + FUN_005c2c80(); + } + puVar3 = PTR_DAT_00818558; + puVar2 = PTR_DAT_00818554; + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x68); + puVar6 = (undefined *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_3,param_3,0); + if (puVar6 == puVar3) { + puVar6 = puVar6 + -4; + } + uVar11 = (int)puVar6 - (int)puVar2 >> 2; + } + else { + uVar11 = param_3 & 0xff; + } + FUN_0040ad10(1); + pbVar7 = (byte *)FUN_0040acf0(1); + if (pbVar7 != (byte *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + uVar11 = (uint)*pbVar7; + } + else { + *pbVar7 = (byte)uVar11; + } + } + if ((*(byte *)(uVar4 + 4) & 5) == 0) { + if ((uVar11 & 0xff) < DAT_007956cc) { + FUN_0042ab60(*(undefined4 *)(PTR_DAT_00818554 + (uVar11 & 0xff) * 4)); + } + else { + FUN_0040aa50(); + } + } + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x6c); + } + FUN_00401a80(¶m_3,¶m_3,uVar4); + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + piVar8 = (int *)FUN_0052dcf0(local_c); + iVar1 = *piVar8; + puVar12 = (undefined4 *)piVar8[1]; + puVar9 = (undefined4 *)piVar8[2]; +LAB_00416006: + puVar10 = puVar9; + if (puVar9 != (undefined4 *)0x0) { + do { + FUN_0040ad10(4); + puVar9 = (undefined4 *)FUN_0040acf0(4); + if (puVar9 != (undefined4 *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + *puVar10 = *puVar9; + } + else { + *puVar9 = *puVar10; + } + } + FUN_0040ad10(4); + puVar9 = (undefined4 *)FUN_0040acf0(4); + if (puVar9 != (undefined4 *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + puVar10[2] = *puVar9; + } + else { + *puVar9 = puVar10[2]; + } + } + puVar10 = (undefined4 *)puVar10[1]; + } while (puVar10 != (undefined4 *)0x0); + do { + puVar12 = puVar12 + 1; + puVar9 = puVar10; + if (puVar12 == (undefined4 *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) break; + puVar9 = (undefined4 *)*puVar12; + } while (puVar9 == (undefined4 *)0x0); + goto LAB_00416006; + } + } + if ((*(byte *)(uVar4 + 4) & 5) == 0) { + uVar11 = FUN_0040a8f0(); + if (uVar11 < param_3) { +LAB_00416136: + FUN_0040aa50(); + } + else { + uVar11 = 0; + puVar12 = (undefined4 *)0x0; + if (param_3 != 0) { + while( true ) { + puVar10 = (undefined4 *)FUN_005df0f5(0xc); + puVar9 = (undefined4 *)0x0; + if (puVar10 != (undefined4 *)0x0) { + puVar10[1] = 0; + puVar9 = puVar10; + } + FUN_0040ad10(4); + puVar10 = (undefined4 *)FUN_0040acf0(4); + if (puVar10 != (undefined4 *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + *puVar9 = *puVar10; + } + else { + *puVar10 = *puVar9; + } + } + FUN_0040ad10(4); + puVar10 = (undefined4 *)FUN_0040acf0(4); + if (puVar10 != (undefined4 *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + puVar9[2] = *puVar10; + } + else { + *puVar10 = puVar9[2]; + } + } + if ((*(uint *)(uVar4 + 4) >> 2 & 1) != 0) break; + cVar5 = FUN_00599310(puVar9,puVar12); + if (cVar5 == '\0') goto LAB_00416136; + uVar11 = uVar11 + 1; + puVar12 = puVar9; + if (param_3 <= uVar11) { + return; + } + } + } + } + } + return; +} + + + +// --- FUN_00416150 at 0x00416150 (size: 45) --- + +void FUN_00416150(void) + +{ + FUN_005870f0(); + FUN_00415e50(); + FUN_005870f0(); + FUN_00415e50(); + return; +} + + + +// --- FUN_004163b0 at 0x004163B0 (size: 82) --- + +undefined4 * __thiscall FUN_004163b0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079629c; + FUN_00415e50(); + param_1[1] = &PTR_FUN_00796294; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00416410 at 0x00416410 (size: 82) --- + +undefined4 * __thiscall FUN_00416410(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007962a0; + FUN_005870f0(); + param_1[1] = &PTR_FUN_00796298; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00416470 at 0x00416470 (size: 542) --- + +void FUN_00416470(undefined4 param_1,int param_2,uint param_3) + +{ + int iVar1; + undefined *puVar2; + undefined *puVar3; + uint uVar4; + char cVar5; + undefined *puVar6; + byte *pbVar7; + int *piVar8; + undefined4 *puVar9; + LONG *lpAddend; + undefined4 *puVar10; + uint uVar11; + undefined4 *puVar12; + undefined1 local_c [12]; + + uVar4 = param_3; + if ((~*(byte *)(param_3 + 4) & 1) != 0) { + FUN_005c2c80(); + } + puVar3 = PTR_DAT_00818558; + puVar2 = PTR_DAT_00818554; + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x68); + puVar6 = (undefined *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_3,param_3,0); + if (puVar6 == puVar3) { + puVar6 = puVar6 + -4; + } + uVar11 = (int)puVar6 - (int)puVar2 >> 2; + } + else { + uVar11 = param_3 & 0xff; + } + FUN_0040ad10(1); + pbVar7 = (byte *)FUN_0040acf0(1); + if (pbVar7 != (byte *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + uVar11 = (uint)*pbVar7; + } + else { + *pbVar7 = (byte)uVar11; + } + } + if ((*(byte *)(uVar4 + 4) & 5) == 0) { + if ((uVar11 & 0xff) < DAT_007956cc) { + FUN_0042ab60(*(undefined4 *)(PTR_DAT_00818554 + (uVar11 & 0xff) * 4)); + } + else { + FUN_0040aa50(); + } + } + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x6c); + } + FUN_00401a80(¶m_3,¶m_3,uVar4); + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + piVar8 = (int *)FUN_0052dcf0(local_c); + iVar1 = *piVar8; + puVar12 = (undefined4 *)piVar8[1]; + puVar9 = (undefined4 *)piVar8[2]; +LAB_00416572: + puVar10 = puVar9; + if (puVar9 != (undefined4 *)0x0) { + do { + FUN_0040ad10(4); + puVar9 = (undefined4 *)FUN_0040acf0(4); + if (puVar9 != (undefined4 *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + *puVar10 = *puVar9; + } + else { + *puVar9 = *puVar10; + } + } + FUN_00402400(uVar4); + puVar10 = (undefined4 *)puVar10[1]; + } while (puVar10 != (undefined4 *)0x0); + do { + puVar12 = puVar12 + 1; + puVar9 = puVar10; + if (puVar12 == (undefined4 *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) break; + puVar9 = (undefined4 *)*puVar12; + } while (puVar9 == (undefined4 *)0x0); + goto LAB_00416572; + } + } + if ((*(byte *)(uVar4 + 4) & 5) == 0) { + uVar11 = FUN_0040a8f0(); + if (uVar11 < param_3) { +LAB_0041667f: + FUN_0040aa50(); + } + else { + uVar11 = 0; + puVar12 = (undefined4 *)0x0; + if (param_3 != 0) { + while( true ) { + puVar9 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar9 == (undefined4 *)0x0) { + puVar9 = (undefined4 *)0x0; + } + else { + puVar9[1] = 0; + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + puVar9[2] = PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + FUN_0040ad10(4); + puVar10 = (undefined4 *)FUN_0040acf0(4); + if (puVar10 != (undefined4 *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + *puVar9 = *puVar10; + } + else { + *puVar10 = *puVar9; + } + } + FUN_00402400(uVar4); + if ((*(uint *)(uVar4 + 4) >> 2 & 1) != 0) break; + cVar5 = FUN_00599310(puVar9,puVar12); + if (cVar5 == '\0') goto LAB_0041667f; + uVar11 = uVar11 + 1; + puVar12 = puVar9; + if (param_3 <= uVar11) { + return; + } + } + } + } + } + return; +} + + + +// --- FUN_00416690 at 0x00416690 (size: 110) --- + +undefined4 * __fastcall FUN_00416690(undefined4 *param_1) + +{ + FUN_00415460(DAT_00837c40); + *param_1 = &PTR_LAB_007962c8; + param_1[0xc] = &PTR_FUN_007962a0; + FUN_00415dc0(0x10); + param_1[0x29] = &PTR_FUN_007962a0; + FUN_00415dc0(0x10); + param_1[0x46] = &PTR_FUN_0079629c; + FUN_00415d30(0x10); + param_1[99] = &PTR_FUN_0079629c; + FUN_00415d30(0x10); + return param_1; +} + + + +// --- FUN_00416710 at 0x00416710 (size: 298) --- + +void __fastcall FUN_00416710(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_007962c8; + FUN_005870f0(); + FUN_00415e50(); + FUN_005870f0(); + FUN_00415e50(); + param_1[99] = &PTR_FUN_0079629c; + FUN_00415e50(); + param_1[100] = &PTR_FUN_00796294; + if ((undefined4 *)param_1[0x7c] != param_1 + 0x65) { + operator_delete__((undefined4 *)param_1[0x7c]); + } + param_1[0x7c] = 0; + param_1[0x7d] = 0; + param_1[0x7e] = 0; + param_1[0x7f] = 0; + param_1[0x46] = &PTR_FUN_0079629c; + FUN_00415e50(); + param_1[0x47] = &PTR_FUN_00796294; + if ((undefined4 *)param_1[0x5f] != param_1 + 0x48) { + operator_delete__((undefined4 *)param_1[0x5f]); + } + param_1[0x5f] = 0; + param_1[0x60] = 0; + param_1[0x61] = 0; + param_1[0x62] = 0; + param_1[0x29] = &PTR_FUN_007962a0; + FUN_005870f0(); + param_1[0x2a] = &PTR_FUN_00796298; + if ((undefined4 *)param_1[0x42] != param_1 + 0x2b) { + operator_delete__((undefined4 *)param_1[0x42]); + } + param_1[0x42] = 0; + param_1[0x43] = 0; + param_1[0x44] = 0; + param_1[0x45] = 0; + param_1[0xc] = &PTR_FUN_007962a0; + FUN_005870f0(); + param_1[0xd] = &PTR_FUN_00796298; + if ((undefined4 *)param_1[0x25] != param_1 + 0xe) { + operator_delete__((undefined4 *)param_1[0x25]); + } + param_1[0x25] = 0; + param_1[0x26] = 0; + param_1[0x27] = 0; + param_1[0x28] = 0; + FUN_004154b0(); + return; +} + + + +// --- FUN_00416870 at 0x00416870 (size: 30) --- + +void * __thiscall FUN_00416870(void *param_1,byte param_2) + +{ + FUN_00416710(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00416890 at 0x00416890 (size: 177) --- + +void __thiscall FUN_00416890(int param_1,int param_2) + +{ + int iVar1; + + iVar1 = param_2; + FUN_00415590(param_2); + if ((~*(byte *)(iVar1 + 4) & 1) != 0) { + FUN_005870f0(); + } + FUN_00415f00(¶m_2,param_1 + 0x34,iVar1); + if ((~*(byte *)(iVar1 + 4) & 1) != 0) { + FUN_00415e50(); + } + FUN_00416470(¶m_2,param_1 + 0x11c,iVar1); + if ((~*(byte *)(iVar1 + 4) & 1) != 0) { + FUN_005870f0(); + } + FUN_00415f00(¶m_2,param_1 + 0xa8,iVar1); + if ((~*(byte *)(iVar1 + 4) & 1) != 0) { + FUN_00415e50(); + } + FUN_00416470(¶m_2,param_1 + 400,iVar1); + return; +} + + + +// --- FUN_00416970 at 0x00416970 (size: 46) --- + +undefined4 __thiscall FUN_00416970(int *param_1,char param_2) + +{ + char cVar1; + undefined4 in_EAX; + undefined3 uVar2; + undefined3 extraout_var; + + uVar2 = (undefined3)((uint)in_EAX >> 8); + cVar1 = *(char *)((int)param_1 + 0xf1); + if ((char)param_1[0x3c] != '\0') { + *(char *)((int)param_1 + 0xf1) = param_2; + if ((cVar1 != '\0') && (param_2 == '\0')) { + (**(code **)(*param_1 + 0x28))(); + uVar2 = extraout_var; + } + } + return CONCAT31(uVar2,cVar1); +} + + + +// --- FUN_004169a0 at 0x004169A0 (size: 76) --- + +void __thiscall FUN_004169a0(int *param_1,int *param_2) + +{ + if (param_2 != (int *)0x0) { + (**(code **)(*param_2 + 0x2c))(); + *(undefined1 *)(param_2 + 2) = 0; + if ((*(char *)((int)param_1 + 0xf1) == '\0') || ((char)param_2[0xb] == '\0')) { + (**(code **)(*param_1 + 0x44))(param_2); + } + else if (*(char *)((int)param_1 + 0xf2) != '\0') { + (**(code **)(*param_1 + 0x48))(param_2); + return; + } + } + return; +} + + + +// --- FUN_00416a70 at 0x00416A70 (size: 70) --- + +int * __fastcall FUN_00416a70(int *param_1) + +{ + int *piVar1; + + if (((char)param_1[0x3d] != '\0') && ((uint)param_1[0x3e] < (uint)param_1[0x42])) { + piVar1 = (int *)(**(code **)(*param_1 + 0x50))(); + if (piVar1 != (int *)0x0) { + (**(code **)(*param_1 + 0x3c))(piVar1); + (**(code **)(*piVar1 + 0x3c))(); + return piVar1; + } + } + piVar1 = (int *)(*(code *)param_1[0x44])(); + return piVar1; +} + + + +// --- FUN_00416ac0 at 0x00416AC0 (size: 69) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __fastcall FUN_00416ac0(int *param_1) + +{ + int iVar1; + + if ((((uint)param_1[0x3e] < (uint)param_1[0x42]) && (iVar1 = param_1[0x40], iVar1 != 0)) && + (*(double *)(iVar1 + 0x10) + _DAT_00796330 < _DAT_008379a8)) { + (**(code **)(*param_1 + 0x4c))(iVar1); + (**(code **)(*param_1 + 0x44))(iVar1); + } + return; +} + + + +// --- FUN_00416b10 at 0x00416B10 (size: 32) --- + +void __fastcall FUN_00416b10(int *param_1) + +{ + undefined4 uVar1; + + while (param_1[0x42] != 0) { + uVar1 = (**(code **)(*param_1 + 0x50))(); + (**(code **)(*param_1 + 0x44))(uVar1); + } + return; +} + + + +// --- FUN_00416bd0 at 0x00416BD0 (size: 64) --- + +undefined4 * __thiscall FUN_00416bd0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00796338; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00416c10 at 0x00416C10 (size: 64) --- + +undefined4 * __thiscall FUN_00416c10(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079633c; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00416c50 at 0x00416C50 (size: 44) --- + +undefined4 __thiscall FUN_00416c50(int param_1,uint param_2) + +{ + uint *puVar1; + bool bVar2; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x68) + (param_2 % *(uint *)(param_1 + 0x70)) * 4); + bVar2 = puVar1 == (uint *)0x0; + if (!bVar2) { + do { + if (*puVar1 == param_2) break; + puVar1 = (uint *)puVar1[1]; + } while (puVar1 != (uint *)0x0); + bVar2 = puVar1 == (uint *)0x0; + } + return CONCAT31((int3)((uint)puVar1 >> 8),!bVar2); +} + + + +// --- FUN_00416cd0 at 0x00416CD0 (size: 143) --- + +undefined4 * __thiscall FUN_00416cd0(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_0079633c; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00416d60 at 0x00416D60 (size: 143) --- + +undefined4 * __thiscall FUN_00416d60(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00796338; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00416df0 at 0x00416DF0 (size: 73) --- + +void __fastcall FUN_00416df0(int param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + undefined4 local_4; + + puVar1 = PTR_DAT_00818558; + local_4 = *(undefined4 *)(param_1 + 0x68); + puVar2 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,local_4,0); + if ((puVar2 != (undefined4 *)puVar1) || (puVar2 = puVar2 + -1, puVar2 != (undefined4 *)puVar1)) { + puVar2 = puVar2 + 1; + } + FUN_00417020(*puVar2); + return; +} + + + +// --- FUN_00416e40 at 0x00416E40 (size: 100) --- + +bool __thiscall FUN_00416e40(int *param_1,uint param_2) + +{ + int *piVar1; + uint *puVar2; + int *piVar3; + + piVar3 = (int *)0x0; + puVar2 = *(uint **)(param_1[0x1a] + (param_2 % (uint)param_1[0x1c]) * 4); + if (puVar2 != (uint *)0x0) { + while (*puVar2 != param_2) { + puVar2 = (uint *)puVar2[1]; + if (puVar2 == (uint *)0x0) { + return false; + } + } + if (puVar2 != (uint *)0x0) { + piVar3 = (int *)puVar2[2]; + (**(code **)(*param_1 + 0x4c))(piVar3); + (**(code **)(*param_1 + 0x3c))(piVar3); + piVar1 = piVar3 + 9; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)(*piVar3 + 0x18))(1); + } + } + } + return piVar3 != (int *)0x0; +} + + + +// --- FUN_00416eb0 at 0x00416EB0 (size: 133) --- + +int * __thiscall FUN_00416eb0(int *param_1,uint param_2,char param_3) + +{ + uint *puVar1; + int *piVar2; + char cVar3; + + puVar1 = *(uint **)(param_1[0x1a] + (param_2 % (uint)param_1[0x1c]) * 4); + while( true ) { + if (puVar1 == (uint *)0x0) { + return (int *)0x0; + } + if (*puVar1 == param_2) break; + puVar1 = (uint *)puVar1[1]; + } + if (puVar1 == (uint *)0x0) { + return (int *)0x0; + } + piVar2 = (int *)puVar1[2]; + if ((piVar2 == (int *)0x0) || (piVar2[9] < 2)) { + (**(code **)(*param_1 + 0x4c))(piVar2); + } + piVar2[9] = piVar2[9] + 1; + if (((char)piVar2[2] == '\0') && (param_3 != '\0')) { + cVar3 = (**(code **)(*piVar2 + 0x28))(); + if (cVar3 == '\0') { + (**(code **)(*piVar2 + 0x14))(); + return (int *)0x0; + } + *(undefined1 *)(piVar2 + 2) = 1; + } + return piVar2; +} + + + +// --- FUN_00416f40 at 0x00416F40 (size: 87) --- + +uint __thiscall FUN_00416f40(int param_1,uint param_2) + +{ + uint *puVar1; + uint uVar2; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x68) + (param_2 % *(uint *)(param_1 + 0x70)) * 4); + while( true ) { + if (puVar1 == (uint *)0x0) { + return 0; + } + if (*puVar1 == param_2) break; + puVar1 = (uint *)puVar1[1]; + } + if (puVar1 == (uint *)0x0) { + return 0; + } + uVar2 = puVar1[2]; + if ((uVar2 != 0) && (1 < *(int *)(uVar2 + 0x24))) { + *(int *)(uVar2 + 0x24) = *(int *)(uVar2 + 0x24) + 1; + return uVar2; + } + return 0; +} + + + +// --- FUN_00417020 at 0x00417020 (size: 310) --- + +undefined4 __thiscall FUN_00417020(int param_1,int param_2) + +{ + int iVar1; + int iVar2; + uint *puVar3; + undefined4 *puVar4; + int *piVar5; + uint *puVar6; + uint *puVar7; + undefined4 *puVar8; + uint *puVar9; + uint uVar10; + uint *puVar11; + + iVar2 = param_2; + if (param_2 == *(int *)(param_1 + 0x68)) { + return 0; + } + iVar1 = *(int *)(param_1 + 0x6c); + puVar3 = (uint *)0x0; + do { + if (iVar1 == 0) { + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_00693b20(iVar2); + puVar4 = (undefined4 *)PTR_DAT_00818558; + while (puVar3 != (uint *)0x0) { + param_2 = *(int *)(param_1 + 0x68); + puVar11 = (uint *)puVar3[1]; + PTR_DAT_00818558 = (undefined *)puVar4; + if (param_2 * 2 < *(int *)(param_1 + 0x6c) + 1) { + puVar8 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,puVar4,¶m_2,param_2,0); + if ((puVar8 != puVar4) || (puVar8 = puVar8 + -1, puVar8 != puVar4)) { + puVar8 = puVar8 + 1; + } + FUN_00417020(*puVar8); + } + uVar10 = *puVar3 % *(uint *)(param_1 + 0x68); + iVar2 = *(int *)(param_1 + 0x60); + puVar3[1] = *(uint *)(iVar2 + uVar10 * 4); + *(uint **)(iVar2 + uVar10 * 4) = puVar3; + uVar10 = iVar2 + uVar10 * 4; + if (uVar10 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar10; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + puVar4 = (undefined4 *)PTR_DAT_00818558; + puVar3 = puVar11; + } + PTR_DAT_00818558 = (undefined *)puVar4; + return 1; + } + piVar5 = *(int **)(param_1 + 100); + while (piVar5 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + puVar11 = *(uint **)(param_1 + 100); + puVar9 = (uint *)*puVar11; + goto LAB_0041706f; + } + piVar5 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar5; + } + puVar11 = (uint *)0x0; + puVar9 = (uint *)0x0; +LAB_0041706f: + puVar7 = (uint *)*puVar11; + if (puVar7 == puVar9) { +LAB_00417082: + *puVar11 = puVar7[1]; + } + else { + do { + puVar6 = puVar7; + puVar7 = (uint *)puVar6[1]; + } while (puVar7 != puVar9); + if (puVar6 == (uint *)0x0) goto LAB_00417082; + puVar6[1] = puVar7[1]; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + puVar9[1] = (uint)puVar3; + iVar1 = *(int *)(param_1 + 0x6c); + puVar3 = puVar9; + } while( true ); +} + + + +// --- FUN_00417160 at 0x00417160 (size: 120) --- + +uint __thiscall FUN_00417160(int param_1,uint *param_2) + +{ + uint *puVar1; + int iVar2; + uint uVar3; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + do { + if (puVar1 == (uint *)0x0) { +LAB_0041718b: + if ((int)(*(uint *)(param_1 + 0x68) * 2) < *(int *)(param_1 + 0x6c) + 1) { + FUN_00416df0(); + } + uVar3 = *param_2 % *(uint *)(param_1 + 0x68); + iVar2 = *(int *)(param_1 + 0x60); + param_2[1] = *(uint *)(iVar2 + uVar3 * 4); + *(uint **)(iVar2 + uVar3 * 4) = param_2; + uVar3 = iVar2 + uVar3 * 4; + if (uVar3 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar3; + } + iVar2 = *(int *)(param_1 + 0x6c) + 1; + *(int *)(param_1 + 0x6c) = iVar2; + return CONCAT31((int3)((uint)iVar2 >> 8),1); + } + if (*puVar1 == *param_2) { + if (puVar1 != (uint *)0x0) { + return (uint)puVar1 & 0xffffff00; + } + goto LAB_0041718b; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_004171e0 at 0x004171E0 (size: 81) --- + +uint * __thiscall FUN_004171e0(int param_1,uint *param_2) + +{ + uint *puVar1; + uint uVar2; + + uVar2 = *param_2 % *(uint *)(param_1 + 0x68); + puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + uVar2 * 4); + while( true ) { + if (puVar1 == (uint *)0x0) { + return (uint *)0x0; + } + if (*puVar1 == *param_2) break; + puVar1 = (uint *)puVar1[1]; + } + if (puVar1 == (uint *)0x0) { + return (uint *)0x0; + } + FUN_00428ba0(param_1,*(int *)(param_1 + 0x60) + uVar2 * 4,puVar1); + return puVar1; +} + + + +// --- FUN_00417240 at 0x00417240 (size: 88) --- + +undefined4 FUN_00417240(undefined4 *param_1,undefined4 *param_2) + +{ + char cVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar2 == (undefined4 *)0x0) { + puVar2 = (undefined4 *)0x0; + } + else { + *puVar2 = *param_1; + puVar2[1] = 0; + puVar2[2] = *param_2; + } + cVar1 = FUN_00417160(puVar2); + if (cVar1 == '\0') { + if (puVar2 != (undefined4 *)0x0) { + operator_delete(puVar2); + } + return 0; + } + return 1; +} + + + +// --- FUN_004172a0 at 0x004172A0 (size: 82) --- + +undefined4 * __thiscall FUN_004172a0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00796348; + FUN_005870f0(); + param_1[1] = &PTR_FUN_00796338; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00417300 at 0x00417300 (size: 82) --- + +undefined4 * __thiscall FUN_00417300(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00796340; + FUN_005870f0(); + param_1[1] = &PTR_FUN_0079633c; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00417360 at 0x00417360 (size: 212) --- + +void __fastcall FUN_00417360(undefined4 *param_1) + +{ + int iVar1; + int *piVar2; + undefined4 *puVar3; + undefined1 local_c [12]; + + *param_1 = &PTR_FUN_007c6a98; + iVar1 = FUN_0052dcf0(local_c); + puVar3 = *(undefined4 **)(iVar1 + 8); +joined_r0x00417384: + do { + if (puVar3 == (undefined4 *)0x0) { + param_1[0x1f] = &PTR_FUN_00796340; + FUN_005870f0(); + param_1[0x20] = &PTR_FUN_0079633c; + if ((undefined4 *)param_1[0x38] != param_1 + 0x21) { + operator_delete__((undefined4 *)param_1[0x38]); + } + param_1[0x38] = 0; + param_1[0x39] = 0; + param_1[0x3a] = 0; + param_1[0x3b] = 0; + param_1[1] = &PTR_FUN_00796348; + FUN_005870f0(); + param_1[2] = &PTR_FUN_00796338; + if ((undefined4 *)param_1[0x1a] != param_1 + 3) { + operator_delete__((undefined4 *)param_1[0x1a]); + } + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + param_1[0x1d] = 0; + return; + } + FUN_00416e40(*puVar3); + piVar2 = (int *)param_1[0x1b]; + while (piVar2 != (int *)(param_1[0x1a] + param_1[0x1c] * 4)) { + if (*(int *)param_1[0x1b] != 0) { + puVar3 = *(undefined4 **)param_1[0x1b]; + goto joined_r0x00417384; + } + piVar2 = (int *)param_1[0x1b] + 1; + param_1[0x1b] = piVar2; + } + puVar3 = (undefined4 *)0x0; + } while( true ); +} + + + +// --- FUN_00417510 at 0x00417510 (size: 192) --- + +undefined4 * __thiscall FUN_00417510(undefined4 *param_1,undefined4 param_2,undefined4 param_3) + +{ + undefined4 *puVar1; + + *param_1 = &PTR_FUN_007c6a98; + param_1[1] = &PTR_FUN_00796348; + FUN_00416d60(0x80); + param_1[1] = &PTR_FUN_00796348; + param_1[0x1e] = param_3; + param_1[0x1f] = &PTR_FUN_00796340; + FUN_00416cd0(0x17); + *(undefined1 *)(param_1 + 0x3c) = 1; + *(undefined1 *)((int)param_1 + 0xf1) = 1; + *(undefined1 *)((int)param_1 + 0xf2) = 1; + *(undefined1 *)(param_1 + 0x3d) = 0; + *(undefined1 *)((int)param_1 + 0xf5) = 0; + param_1[0x3e] = 0x10; + param_1[0x3f] = 0x10; + param_1[0x40] = 0; + param_1[0x41] = 0; + param_1[0x42] = 0; + param_1[0x43] = 0; + param_1[0x44] = param_2; + puVar1 = (undefined4 *)FUN_0041c500(param_1[0x1e]); + param_1[0x3d] = *puVar1; + param_1[0x3e] = puVar1[1]; + param_1[0x3f] = puVar1[2]; + return param_1; +} + + + +// --- FUN_004175d0 at 0x004175D0 (size: 30) --- + +void * __thiscall FUN_004175d0(void *param_1,byte param_2) + +{ + FUN_00417360(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00417600 at 0x00417600 (size: 28) --- + +undefined4 * __fastcall FUN_00417600(undefined4 *param_1) + +{ + *param_1 = 0; + param_1[1] = 0; + FUN_00406d60(); + return param_1; +} + + + +// --- FUN_00417620 at 0x00417620 (size: 27) --- + +int FUN_00417620(void) + +{ + int iVar1; + + FUN_004074b0(4,1); + iVar1 = FUN_00406d80(); + return iVar1 + 4; +} + + + +// --- FUN_00417640 at 0x00417640 (size: 32) --- + +int FUN_00417640(void) + +{ + uint uVar1; + int iVar2; + + uVar1 = FUN_00406db0(); + if (4 < uVar1) { + iVar2 = FUN_00406db0(); + return iVar2 + -4; + } + return 0; +} + + + +// --- FUN_00417660 at 0x00417660 (size: 19) --- + +void __thiscall FUN_00417660(int *param_1,int param_2) + +{ + (**(code **)(*param_1 + 0xc))(); + param_1[9] = param_2; + return; +} + + + +// --- FUN_00417680 at 0x00417680 (size: 24) --- + +void __fastcall FUN_00417680(int param_1) + +{ + if (*(int **)(param_1 + 0x24) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x24) + 0x14))(); + *(undefined4 *)(param_1 + 0x24) = 0; + } + return; +} + + + +// --- FUN_004176a0 at 0x004176A0 (size: 35) --- + +undefined4 * __thiscall FUN_004176a0(undefined4 *param_1,undefined4 *param_2) + +{ + *param_1 = *param_2; + param_1[1] = param_2[1]; + FUN_004070d0(param_2 + 2); + return param_1; +} + + + +// --- FUN_004176d0 at 0x004176D0 (size: 48) --- + +void __thiscall FUN_004176d0(int *param_1,int param_2) + +{ + int iVar1; + + iVar1 = *(int *)(param_2 + 0xc); + if (iVar1 == 0) { + /* WARNING: Could not recover jumptable at 0x004176fa. Too many branches */ + /* WARNING: Treating indirect jump as call */ + (**(code **)(*param_1 + 0x60))(); + return; + } + if (iVar1 != 1) { + if (iVar1 == 2) { + /* WARNING: Could not recover jumptable at 0x004176e8. Too many branches */ + /* WARNING: Treating indirect jump as call */ + (**(code **)(*param_1 + 100))(); + return; + } + return; + } + /* WARNING: Could not recover jumptable at 0x004176f1. Too many branches */ + /* WARNING: Treating indirect jump as call */ + (**(code **)(*param_1 + 0x68))(); + return; +} + + + +// --- FUN_00417710 at 0x00417710 (size: 5) --- + +void __fastcall FUN_00417710(int *param_1) + +{ + /* WARNING: Could not recover jumptable at 0x00417712. Too many branches */ + /* WARNING: Treating indirect jump as call */ + (**(code **)(*param_1 + 0x74))(); + return; +} + + + +// --- FUN_004178a0 at 0x004178A0 (size: 19) --- + +void FUN_004178a0(void) + +{ + FUN_00406f90(); + FUN_00406f90(); + return; +} + + + +// --- FUN_004178c0 at 0x004178C0 (size: 79) --- + +undefined4 __fastcall FUN_004178c0(int param_1) + +{ + undefined4 *puVar1; + uint uVar2; + LONG LVar3; + uint uVar4; + + uVar4 = 0; + if (*(int *)(param_1 + 0x20) == 0) { + *(undefined4 *)(param_1 + 0x20) = 0; + return 1; + } + do { + puVar1 = *(undefined4 **)(*(int *)(param_1 + 0x18) + uVar4 * 8); + LVar3 = InterlockedDecrement(puVar1 + 1); + if ((LVar3 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + uVar2 = *(uint *)(param_1 + 0x20); + uVar4 = uVar4 + 1; + } while (uVar4 < uVar2); + *(undefined4 *)(param_1 + 0x20) = 0; + return CONCAT31((int3)(uVar2 >> 8),1); +} + + + +// --- FUN_00417910 at 0x00417910 (size: 78) --- + +void __fastcall FUN_00417910(int param_1) + +{ + char cVar1; + undefined4 uVar2; + int *piVar3; + + if (*(int **)(param_1 + 0x24) != (int *)0x0) { + if ((*(byte *)(param_1 + 0x60) & 4) == 0) { + cVar1 = (**(code **)(**(int **)(param_1 + 0x24) + 0x24))(); + if (cVar1 == '\0') goto LAB_00417949; + } + uVar2 = (**(code **)(**(int **)(param_1 + 0x24) + 0x48))(); + piVar3 = (int *)FUN_00414590(uVar2); + if (piVar3 != (int *)0x0) { + (**(code **)(*piVar3 + 0x18))(*(undefined4 *)(param_1 + 0x24)); + } + } +LAB_00417949: + if (*(int **)(param_1 + 0x24) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x24) + 0x14))(); + *(undefined4 *)(param_1 + 0x24) = 0; + } + return; +} + + + +// --- FUN_00417960 at 0x00417960 (size: 202) --- + +void __thiscall FUN_00417960(int *param_1,int *param_2) + +{ + char cVar1; + int iVar2; + + if (param_2[5] == DAT_00837c50) { + param_2[2] = 3; + } + else { + iVar2 = param_2[3]; + if (iVar2 == 0) { + iVar2 = (**(code **)*param_1)(param_2[10],param_2 + 4); + (**(code **)(*param_2 + 0xc))(); + param_2[9] = iVar2; + param_2[2] = 3; + if (iVar2 != 0) { + param_2[2] = 1; + param_2[0x18] = param_2[0x18] | 4; + (**(code **)(*param_1 + 0x5c))(param_2); + return; + } + } + else { + if (iVar2 == 1) { + cVar1 = (**(code **)(*param_1 + 4))(param_2 + 4); + param_2[2] = (-(uint)(cVar1 != '\0') & 0xfffffffe) + 3; + (**(code **)(*param_1 + 0x5c))(param_2); + return; + } + if (iVar2 == 2) { + cVar1 = (**(code **)(*param_1 + 8))(param_2 + 4,param_2 + 10); + param_2[2] = (-(uint)(cVar1 != '\0') & 0xfffffffe) + 3; + (**(code **)(*param_1 + 0x5c))(param_2); + return; + } + } + } + (**(code **)(*param_1 + 0x5c))(param_2); + return; +} + + + +// --- FUN_00417cf0 at 0x00417CF0 (size: 109) --- + +int * __thiscall FUN_00417cf0(int *param_1,int param_2,undefined4 param_3) + +{ + char cVar1; + int *piVar2; + + piVar2 = (int *)0x0; + if (*(int *)(param_2 + 4) != DAT_00837c50) { + piVar2 = (int *)(**(code **)(*param_1 + 0x88))(param_2,param_3); + } + cVar1 = (**(code **)(*param_1 + 0x7c))(piVar2,param_2,param_3); + if ((cVar1 != '\0') && (cVar1 = (**(code **)(*piVar2 + 0x24))(), cVar1 != '\0')) { + (**(code **)(*param_1 + 0x94))(piVar2,param_3); + return piVar2; + } + if (piVar2 == (int *)0x0) { + return (int *)0x0; + } + (**(code **)(*piVar2 + 0x14))(); + return (int *)0x0; +} + + + +// --- FUN_00417d60 at 0x00417D60 (size: 80) --- + +void __fastcall FUN_00417d60(int *param_1) + +{ + int iVar1; + int iVar2; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + *param_1 = 0; + param_1[1] = 0; + return; + } + if (*param_1 != 0) { + iVar2 = (param_1[1] & 0x7fffffffU) - 1; + while (-1 < iVar2) { + iVar2 = iVar2 + -1; + iVar1 = *param_1; + *(undefined4 *)(iVar1 + 8 + iVar2 * 8) = 0; + *(undefined4 *)(iVar1 + 0xc + iVar2 * 8) = 0; + } + } + return; +} + + + +// --- FUN_00417db0 at 0x00417DB0 (size: 124) --- + +undefined4 __thiscall FUN_00417db0(int param_1,undefined4 *param_2) + +{ + uint uVar1; + int iVar2; + int iVar3; + uint uVar4; + LONG LVar5; + int *piVar6; + + uVar4 = 0; + if (*(uint *)(param_1 + 0x20) != 0) { + piVar6 = *(int **)(param_1 + 0x18); + do { + if ((undefined4 *)*piVar6 == param_2) { + if (uVar4 < *(uint *)(param_1 + 0x20)) { + uVar1 = *(uint *)(param_1 + 0x20) - 1; + *(uint *)(param_1 + 0x20) = uVar1; + if (uVar4 != uVar1) { + iVar2 = *(int *)(param_1 + 0x18); + *(undefined4 *)(iVar2 + uVar4 * 8) = *(undefined4 *)(iVar2 + uVar1 * 8); + *(undefined4 *)(iVar2 + 4 + uVar4 * 8) = *(undefined4 *)(iVar2 + 4 + uVar1 * 8); + iVar2 = *(int *)(param_1 + 0x20); + iVar3 = *(int *)(param_1 + 0x18); + *(undefined4 *)(iVar3 + iVar2 * 8) = 0; + *(undefined4 *)(iVar3 + 4 + iVar2 * 8) = 0; + } + } + LVar5 = InterlockedDecrement(param_2 + 1); + if ((LVar5 == 0) && (param_2 != (undefined4 *)0x0)) { + (**(code **)*param_2)(1); + } + return 1; + } + uVar4 = uVar4 + 1; + piVar6 = piVar6 + 2; + } while (uVar4 < *(uint *)(param_1 + 0x20)); + } + return 0; +} + + + +// --- FUN_00417e30 at 0x00417E30 (size: 109) --- + +void __fastcall FUN_00417e30(int param_1) + +{ + undefined4 *puVar1; + LONG LVar2; + uint uVar3; + + uVar3 = 0; + if (*(int *)(param_1 + 0x20) != 0) { + do { + FUN_00417db0(param_1); + puVar1 = *(undefined4 **)(*(int *)(param_1 + 0x18) + uVar3 * 4); + if (puVar1 != (undefined4 *)0x0) { + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + *(undefined4 *)(*(int *)(param_1 + 0x18) + uVar3 * 4) = 0; + } + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 0x20)); + } + *(undefined4 *)(param_1 + 0x20) = 0; + *(undefined4 *)(param_1 + 0xc) = 0; + *(undefined4 *)(param_1 + 0x24) = DAT_00837c54; + return; +} + + + +// --- FUN_00417ea0 at 0x00417EA0 (size: 185) --- + +void __thiscall +FUN_00417ea0(int *param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4,uint param_5, + undefined4 param_6) + +{ + uint uVar1; + int iVar2; + int *piVar3; + undefined4 *puVar4; + LONG LVar5; + int *unaff_ESI; + uint uVar6; + + uVar1 = param_1[5]; + piVar3 = (int *)(**(code **)(*param_1 + 0x10))(¶m_6,param_3,param_4,param_5,param_6); + iVar2 = *piVar3; + *unaff_ESI = iVar2; + if (((char)param_1[0x43] == '\0') && (uVar6 = param_1[5], uVar1 < uVar6)) { + while (uVar6 = uVar6 - 1, + *(int *)(*(int *)(param_1[2] + ((param_1[3] + uVar6) % (uint)param_1[6]) * 4) + 0x24) != + iVar2) { + if (uVar6 <= param_5) { + return; + } + } + puVar4 = (undefined4 *)(**(code **)(param_1[1] + 0xc))(uVar6); + if (((undefined4 *)puVar4[3] != (undefined4 *)0x0) && (puVar4[9] != DAT_00837c54)) { + (*(code *)**(undefined4 **)puVar4[3])(puVar4[9],puVar4[4],puVar4[5]); + } + LVar5 = InterlockedDecrement(puVar4 + 1); + if (LVar5 == 0) { + (**(code **)*puVar4)(1); + } + } + return; +} + + + +// --- FUN_00417ff0 at 0x00417FF0 (size: 172) --- + +undefined4 __thiscall FUN_00417ff0(int *param_1,uint param_2) + +{ + int iVar1; + int iVar2; + int iVar3; + + if (param_2 < (uint)param_1[2]) { + return 0; + } + if ((param_1[1] & 0x7fffffffU) < param_2) { + if (param_2 == 0) { + FUN_00417d60(); + return 1; + } + iVar2 = thunk_FUN_005df0f5(param_2 * 8); + if (iVar2 == 0) { + return 0; + } + FUN_00401000(iVar2,8,param_2,&LAB_004175f0); + if (*param_1 != 0) { + iVar3 = param_1[2] + -1; + while (-1 < iVar3) { + iVar3 = iVar3 + -1; + iVar1 = *param_1; + *(undefined4 *)(iVar2 + 8 + iVar3 * 8) = *(undefined4 *)(iVar1 + 8 + iVar3 * 8); + *(undefined4 *)(iVar2 + 0xc + iVar3 * 8) = *(undefined4 *)(iVar1 + 0xc + iVar3 * 8); + } + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + } + } + *param_1 = iVar2; + param_1[1] = param_2 | 0x80000000; + } + return 1; +} + + + +// --- FUN_004180a0 at 0x004180A0 (size: 148) --- + +undefined4 __thiscall FUN_004180a0(int *param_1,uint param_2) + +{ + int iVar1; + int iVar2; + + if (param_2 < (uint)param_1[2]) { + return 0; + } + if ((param_1[1] & 0x7fffffffU) < param_2) { + if (param_2 == 0) { + FUN_0044dcb0(); + return 1; + } + iVar1 = thunk_FUN_005df0f5(param_2 * 4); + if (iVar1 == 0) { + return 0; + } + if (*param_1 != 0) { + iVar2 = param_1[2] + -1; + while (-1 < iVar2) { + iVar2 = iVar2 + -1; + *(undefined4 *)(iVar1 + 4 + iVar2 * 4) = *(undefined4 *)(*param_1 + 4 + iVar2 * 4); + } + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + } + } + *param_1 = iVar1; + param_1[1] = param_2 | 0x80000000; + } + return 1; +} + + + +// --- FUN_00418150 at 0x00418150 (size: 65) --- + +void __fastcall FUN_00418150(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_00796360; + if ((int *)param_1[9] != (int *)0x0) { + (**(code **)(*(int *)param_1[9] + 0x14))(); + param_1[9] = 0; + } + if ((param_1[7] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[6]); + } + *param_1 = &PTR_FUN_007952f4; + return; +} + + + +// --- FUN_004181a0 at 0x004181A0 (size: 322) --- + +void __fastcall FUN_004181a0(undefined4 *param_1) + +{ + undefined4 *puVar1; + char cVar2; + LONG LVar3; + undefined4 uVar4; + int *piVar5; + uint uVar6; + + uVar6 = 0; + *param_1 = &PTR_FUN_00796374; + if (param_1[0x10] != 0) { + do { + puVar1 = *(undefined4 **)(param_1[0xe] + uVar6 * 4); + LVar3 = InterlockedDecrement(puVar1 + 1); + if ((LVar3 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + uVar6 = uVar6 + 1; + } while (uVar6 < (uint)param_1[0x10]); + } + uVar6 = 0; + if (param_1[0xd] != 0) { + do { + puVar1 = *(undefined4 **)(param_1[0xb] + uVar6 * 4); + LVar3 = InterlockedDecrement(puVar1 + 1); + if ((LVar3 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + uVar6 = uVar6 + 1; + } while (uVar6 < (uint)param_1[0xd]); + } + if (((int *)param_1[9] != (int *)0x0) && + (((*(byte *)(param_1 + 0x18) & 4) != 0 || + (cVar2 = (**(code **)(*(int *)param_1[9] + 0x24))(), cVar2 != '\0')))) { + uVar4 = (**(code **)(*(int *)param_1[9] + 0x48))(); + piVar5 = (int *)FUN_00414590(uVar4); + if (piVar5 != (int *)0x0) { + (**(code **)(*piVar5 + 0x18))(param_1[9]); + } + } + if ((int *)param_1[9] != (int *)0x0) { + (**(code **)(*(int *)param_1[9] + 0x14))(); + param_1[9] = 0; + } + FUN_00406f90(); + FUN_00406f90(); + if ((param_1[0xf] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0xe]); + } + if ((param_1[0xc] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0xb]); + } + *param_1 = &PTR_FUN_00796360; + if ((int *)param_1[9] != (int *)0x0) { + (**(code **)(*(int *)param_1[9] + 0x14))(); + param_1[9] = 0; + } + if ((param_1[7] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[6]); + } + *param_1 = &PTR_FUN_007952f4; + return; +} + + + +// --- FUN_00418300 at 0x00418300 (size: 131) --- + +void __fastcall FUN_00418300(undefined4 *param_1) + +{ + undefined4 *puVar1; + LONG LVar2; + uint uVar3; + + uVar3 = 0; + *param_1 = &PTR_FUN_00796370; + if (param_1[8] != 0) { + do { + FUN_00417db0(param_1); + puVar1 = *(undefined4 **)(param_1[6] + uVar3 * 4); + if (puVar1 != (undefined4 *)0x0) { + LVar2 = InterlockedDecrement(puVar1 + 1); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + *(undefined4 *)(param_1[6] + uVar3 * 4) = 0; + } + uVar3 = uVar3 + 1; + } while (uVar3 < (uint)param_1[8]); + } + if ((param_1[7] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[6]); + } + *param_1 = &PTR_FUN_007952f4; + return; +} + + + +// --- FUN_00418390 at 0x00418390 (size: 85) --- + +undefined4 * __thiscall FUN_00418390(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00796360; + if ((int *)param_1[9] != (int *)0x0) { + (**(code **)(*(int *)param_1[9] + 0x14))(); + param_1[9] = 0; + } + if ((param_1[7] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[6]); + } + *param_1 = &PTR_FUN_007952f4; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004183f0 at 0x004183F0 (size: 30) --- + +void * __thiscall FUN_004183f0(void *param_1,byte param_2) + +{ + FUN_00418300(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00418410 at 0x00418410 (size: 74) --- + +undefined4 * __fastcall FUN_00418410(undefined4 *param_1) + +{ + param_1[1] = 1; + param_1[2] = 0; + param_1[6] = 0; + param_1[7] = 0; + param_1[8] = 0; + param_1[9] = 0; + *param_1 = &PTR_FUN_00796374; + param_1[0xb] = 0; + param_1[0xc] = 0; + param_1[0xd] = 0; + param_1[0xe] = 0; + param_1[0xf] = 0; + param_1[0x10] = 0; + param_1[0x11] = 0; + param_1[0x12] = 0; + FUN_00406d60(); + param_1[0x18] = 0; + return param_1; +} + + + +// --- FUN_00418460 at 0x00418460 (size: 30) --- + +void * __thiscall FUN_00418460(void *param_1,byte param_2) + +{ + FUN_004181a0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00418480 at 0x00418480 (size: 30) --- + +void * __thiscall FUN_00418480(void *param_1,byte param_2) + +{ + FUN_00418150(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004184a0 at 0x004184A0 (size: 40) --- + +void * __thiscall FUN_004184a0(void *param_1,byte param_2) + +{ + FUN_004178a0(); + FUN_00418150(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004184d0 at 0x004184D0 (size: 61) --- + +undefined4 FUN_004184d0(undefined4 param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + bool bVar3; + + puVar1 = PTR_DAT_00818558; + puVar2 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_1,param_1,0); + bVar3 = false; + if (puVar2 == (undefined4 *)puVar1) { + puVar2 = puVar2 + -1; + bVar3 = puVar2 == (undefined4 *)puVar1; + } + if (!bVar3) { + return puVar2[1]; + } + return *puVar2; +} + + + +// --- FUN_00418510 at 0x00418510 (size: 335) --- + +void __thiscall FUN_00418510(int param_1,int *param_2) + +{ + int *piVar1; + int iVar2; + uint *puVar3; + int *piVar4; + char cVar5; + uint uVar6; + + piVar4 = param_2; + if ((param_2[3] == 0) && (uVar6 = 0, param_2[8] != 0)) { + do { + piVar1 = (int *)(piVar4[6] + uVar6 * 8); + iVar2 = *piVar1; + if ((iVar2 != 0) && (*(char *)(iVar2 + 0x28) == '\0')) { + piVar1 = piVar1 + 1; + *piVar1 = *piVar1 + 1; + if (*(int **)(iVar2 + 0xc) != (int *)0x0) { + (**(code **)(**(int **)(iVar2 + 0xc) + 4)) + (*(undefined4 *)(iVar2 + 0x24),piVar4[4],piVar4[5],piVar4[2], + *(undefined4 *)(iVar2 + 0x14),*(undefined4 *)(piVar4[6] + 4 + uVar6 * 8),piVar4 + ); + } + } + uVar6 = uVar6 + 1; + } while (uVar6 < (uint)piVar4[8]); + } + cVar5 = (**(code **)(*piVar4 + 4))(); + if (cVar5 != '\0') { + uVar6 = 0; + if (piVar4[8] != 0) { + do { + param_2 = *(int **)(piVar4[6] + uVar6 * 8); + if (param_2 != (int *)0x0) { + param_2[2] = param_2[2] + -1; + if (piVar4[2] == 1) { + if (param_2[4] == 3) { + param_2[4] = 2; + } + else if (param_2[4] == 0) { + param_2[4] = 1; + } + } + else if (param_2[4] == 1) { + param_2[4] = 2; + } + else if (param_2[4] == 0) { + param_2[4] = piVar4[2]; + } + if ((param_2[2] == 0) && ((char)param_2[10] == '\0')) { + for (puVar3 = *(uint **)(*(int *)(param_1 + 0xf8) + + ((uint)param_2[9] % *(uint *)(param_1 + 0x100)) * 4); + puVar3 != (uint *)0x0; puVar3 = (uint *)puVar3[1]) { + if (*puVar3 == param_2[9]) { + if (puVar3 != (uint *)0x0) { + InterlockedIncrement(param_2 + 1); + *(undefined1 *)(param_2 + 10) = 1; + (**(code **)(*(int *)(param_1 + 4) + 4))(¶m_2); + } + break; + } + } + } + } + uVar6 = uVar6 + 1; + } while (uVar6 < (uint)piVar4[8]); + } + FUN_004178c0(); + } + return; +} + + + +// --- FUN_00418660 at 0x00418660 (size: 54) --- + +undefined4 FUN_00418660(undefined4 param_1,undefined4 *param_2) + +{ + undefined4 uVar1; + undefined1 local_c [8]; + int local_4; + + FUN_00414190(local_c,param_1); + if (local_4 != 0) { + uVar1 = *(undefined4 *)(local_4 + 0xc); + *param_2 = uVar1; + return CONCAT31((int3)((uint)uVar1 >> 8),1); + } + return 0; +} + + + +// --- FUN_004186a0 at 0x004186A0 (size: 81) --- + +void __thiscall FUN_004186a0(int param_1,int param_2) + +{ + int iVar1; + int iVar2; + char cVar3; + uint uVar4; + undefined4 uVar5; + + InterlockedIncrement((LONG *)(param_2 + 4)); + uVar4 = *(uint *)(param_1 + 0x1c) & 0x7fffffff; + if (uVar4 <= *(uint *)(param_1 + 0x20)) { + uVar5 = FUN_00453850(uVar4 + 1); + cVar3 = FUN_00417ff0(uVar5); + if (cVar3 == '\0') { + return; + } + } + iVar1 = *(int *)(param_1 + 0x20); + iVar2 = *(int *)(param_1 + 0x18); + *(int *)(iVar2 + iVar1 * 8) = param_2; + *(undefined4 *)(iVar2 + 4 + iVar1 * 8) = 0; + *(int *)(param_1 + 0x20) = *(int *)(param_1 + 0x20) + 1; + return; +} + + + +// --- FUN_00418700 at 0x00418700 (size: 146) --- + +int __thiscall FUN_00418700(int *param_1,undefined4 param_2,undefined4 param_3,undefined4 *param_4) + +{ + int iVar1; + undefined4 uVar2; + undefined1 local_c [8]; + int local_4; + + FUN_00414190(local_c,param_4); + if (local_4 != 0) { + iVar1 = *(int *)(local_4 + 0xc); + InterlockedIncrement((LONG *)(iVar1 + 4)); + return iVar1; + } + iVar1 = FUN_005df0f5(100); + if (iVar1 == 0) { + iVar1 = 0; + } + else { + iVar1 = FUN_00418410(); + } + uVar2 = (**(code **)(*param_1 + 0x38))(param_4); + *(undefined4 *)(iVar1 + 0x5c) = uVar2; + *(undefined4 *)(iVar1 + 0x28) = param_2; + *(undefined4 *)(iVar1 + 0xc) = 0; + *(undefined4 *)(iVar1 + 0x10) = *param_4; + *(undefined4 *)(iVar1 + 0x14) = param_4[1]; + *(undefined4 *)(iVar1 + 0x58) = 1; + *(undefined4 *)(iVar1 + 8) = 0; + return iVar1; +} + + + +// --- FUN_004187a0 at 0x004187A0 (size: 152) --- + +void __thiscall FUN_004187a0(int *param_1,int param_2) + +{ + int iVar1; + int iVar2; + undefined1 local_c [8]; + int local_4; + + FUN_00414190(local_c,param_2 + 0x10); + if (((local_4 != 0) && (iVar1 = *(int *)(local_4 + 0xc), *(int *)(iVar1 + 8) == 0)) && + ((*(byte *)(iVar1 + 0x60) & 2) == 0)) { + *(undefined4 *)(iVar1 + 8) = *(undefined4 *)(param_2 + 8); + if (*(int *)(param_2 + 8) == 1) { + iVar2 = FUN_00417620(); + if ((iVar2 == 0) || (iVar2 = FUN_00417640(), iVar2 == 0)) { + (**(code **)(*param_1 + 0x9c))(param_2 + 0x10,param_2 + 0x28,0,0); + } + FUN_004176a0(param_2 + 0x28); + } + (**(code **)(*param_1 + 0x60))(iVar1); + } + (**(code **)(*param_1 + 0x6c))(param_2); + return; +} + + + +// --- FUN_004188d0 at 0x004188D0 (size: 250) --- + +int * __thiscall FUN_004188d0(int *param_1,undefined4 param_2,int param_3) + +{ + char cVar1; + int *piVar2; + int *piVar3; + int *piVar4; + int unaff_EDI; + bool bVar5; + + if (*(int *)(param_3 + 4) == DAT_00837c50) { + return (int *)0x0; + } + piVar2 = (int *)(**(code **)(*param_1 + 0x38))(param_3); + if (piVar2 == (int *)0x0) { + return (int *)0x0; + } + piVar3 = (int *)(**(code **)(*param_1 + 0x84))(param_3,piVar2); + bVar5 = false; + piVar4 = piVar3; + if (piVar3 == (int *)0x0) { + cVar1 = FUN_00418660(param_3,&stack0xfffffffc); + piVar4 = piRam00000024; + if ((cVar1 == '\0') || (piVar3 = piRam00000024, piRam00000024 == (int *)0x0)) { + piVar4 = piVar3; + cVar1 = (**(code **)(*piVar2 + 0x20))(); + if (cVar1 != '\0') { + piVar4 = (int *)(**(code **)(*param_1 + 0x78))(param_3,piVar2); + } + } + else { + if (((uRam00000060 & 4) == 0) && + (cVar1 = (**(code **)(*piRam00000024 + 0x24))(), cVar1 == '\0')) { + return (int *)0x0; + } + uRam00000060 = uRam00000060 | 4; + (**(code **)(*param_1 + 0x94))(piVar4,piVar2); + (**(code **)(*piVar4 + 0x10))(); + } + bVar5 = piVar4 == (int *)0x0; + } + if (!bVar5) { + if ((char)piVar4[2] != '\0') { + return piVar4; + } + if (unaff_EDI == 1) { + return piVar4; + } + cVar1 = (**(code **)(*piVar4 + 0x28))(); + if (cVar1 != '\0') { + *(undefined1 *)(piVar4 + 2) = 1; + return piVar4; + } + } + if (piVar4 != (int *)0x0) { + (**(code **)(*piVar4 + 0x14))(); + } + return (int *)0x0; +} + + + +// --- FUN_00418a10 at 0x00418A10 (size: 143) --- + +undefined4 * __thiscall FUN_00418a10(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00795f88; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00418aa0 at 0x00418AA0 (size: 143) --- + +undefined4 * __thiscall FUN_00418aa0(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00795f8c; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00418b30 at 0x00418B30 (size: 269) --- + +undefined4 __thiscall FUN_00418b30(int param_1,int param_2) + +{ + int iVar1; + int *piVar2; + int *piVar3; + int *piVar4; + undefined4 uVar5; + int *piVar6; + uint uVar7; + int *piVar8; + + if (param_2 == *(int *)(param_1 + 0x68)) { + return 0; + } + iVar1 = *(int *)(param_1 + 0x6c); + piVar2 = (int *)0x0; + do { + if (iVar1 == 0) { + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_00693b20(param_2); + while (piVar2 != (int *)0x0) { + piVar8 = (int *)piVar2[2]; + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + uVar5 = FUN_004184d0(*(int *)(param_1 + 0x68)); + FUN_00418b30(uVar5); + } + uVar7 = (uint)(piVar2[1] + *piVar2) % *(uint *)(param_1 + 0x68); + iVar1 = *(int *)(param_1 + 0x60); + piVar2[2] = *(int *)(iVar1 + uVar7 * 4); + *(int **)(iVar1 + uVar7 * 4) = piVar2; + uVar7 = iVar1 + uVar7 * 4; + if (uVar7 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar7; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + piVar2 = piVar8; + } + return 1; + } + piVar8 = *(int **)(param_1 + 100); + while (piVar8 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar8 = *(int **)(param_1 + 100); + piVar6 = (int *)*piVar8; + goto LAB_00418b7e; + } + piVar8 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar8; + } + piVar8 = (int *)0x0; + piVar6 = (int *)0x0; +LAB_00418b7e: + piVar4 = (int *)*piVar8; + if (piVar4 == piVar6) { +LAB_00418b91: + *piVar8 = piVar4[2]; + } + else { + do { + piVar3 = piVar4; + piVar4 = (int *)piVar3[2]; + } while (piVar4 != piVar6); + if (piVar3 == (int *)0x0) goto LAB_00418b91; + piVar3[2] = piVar4[2]; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + piVar6[2] = (int)piVar2; + iVar1 = *(int *)(param_1 + 0x6c); + piVar2 = piVar6; + } while( true ); +} + + + +// --- FUN_00418c40 at 0x00418C40 (size: 73) --- + +void __fastcall FUN_00418c40(int param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + undefined4 local_4; + + puVar1 = PTR_DAT_00818558; + local_4 = *(undefined4 *)(param_1 + 0x68); + puVar2 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,local_4,0); + if ((puVar2 != (undefined4 *)puVar1) || (puVar2 = puVar2 + -1, puVar2 != (undefined4 *)puVar1)) { + puVar2 = puVar2 + 1; + } + FUN_00418b30(*puVar2); + return; +} + + + +// --- FUN_00418c90 at 0x00418C90 (size: 83) --- + +void __thiscall FUN_00418c90(int param_1,int param_2) + +{ + char cVar1; + uint uVar2; + undefined4 uVar3; + + InterlockedIncrement((LONG *)(param_2 + 4)); + uVar2 = *(uint *)(param_1 + 0x1c) & 0x7fffffff; + if (uVar2 <= *(uint *)(param_1 + 0x20)) { + uVar3 = FUN_00453850(uVar2 + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 == '\0') goto LAB_00418cd5; + } + *(int *)(*(int *)(param_1 + 0x18) + *(int *)(param_1 + 0x20) * 4) = param_2; + *(int *)(param_1 + 0x20) = *(int *)(param_1 + 0x20) + 1; +LAB_00418cd5: + FUN_004186a0(param_1); + return; +} + + + +// --- FUN_00419170 at 0x00419170 (size: 207) --- + +void FUN_00419170(undefined4 param_1,int param_2) + +{ + int iVar1; + int iVar2; + int *piVar3; + int iVar4; + int local_c; + int *local_8; + int local_4; + + FUN_0052dcf0(&local_c); +joined_r0x00419187: + do { + if (local_4 == 0) { + return; + } + do { + if ((param_2 == 1) || + ((param_2 != 2 && ((param_2 != 3 || ((~(byte)(*(uint *)(local_4 + 0xc) >> 3) & 1) == 0))))) + ) { + iVar2 = *(int *)(local_4 + 8); + piVar3 = local_8; + iVar4 = iVar2; + if (iVar2 != 0) goto LAB_004191df; + goto LAB_004191d0; + } + local_4 = *(int *)(local_4 + 8); + } while (local_4 != 0); + do { + local_8 = local_8 + 1; + if (local_8 == (int *)(*(int *)(local_c + 0x60) + *(int *)(local_c + 0x68) * 4)) { + return; + } + local_4 = *local_8; + } while (local_4 == 0); + } while( true ); + while (iVar4 = *piVar3, iVar4 == 0) { +LAB_004191d0: + piVar3 = piVar3 + 1; + iVar4 = iVar2; + if (piVar3 == (int *)(*(int *)(local_c + 0x60) + *(int *)(local_c + 0x68) * 4)) break; + } +LAB_004191df: + iVar2 = *local_8; + if (iVar2 != local_4) { + do { + iVar1 = iVar2; + iVar2 = *(int *)(iVar1 + 8); + } while (iVar2 != local_4); + if (iVar1 != 0) { + *(undefined4 *)(iVar1 + 8) = *(undefined4 *)(iVar2 + 8); + *(int *)(local_c + 0x6c) = *(int *)(local_c + 0x6c) + -1; + local_8 = piVar3; + local_4 = iVar4; + goto joined_r0x00419187; + } + } + *local_8 = *(int *)(iVar2 + 8); + *(int *)(local_c + 0x6c) = *(int *)(local_c + 0x6c) + -1; + local_8 = piVar3; + local_4 = iVar4; + goto joined_r0x00419187; +} + + + +// --- FUN_00419240 at 0x00419240 (size: 110) --- + +uint __thiscall FUN_00419240(int param_1,int *param_2) + +{ + int iVar1; + uint uVar2; + undefined1 local_c [8]; + uint local_4; + + FUN_00414190(local_c,param_2); + if (local_4 != 0) { + return local_4 & 0xffffff00; + } + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + FUN_00414ce0(); + } + uVar2 = (uint)(param_2[1] + *param_2) % *(uint *)(param_1 + 0x68); + iVar1 = *(int *)(param_1 + 0x60); + param_2[2] = *(int *)(iVar1 + uVar2 * 4); + *(int **)(iVar1 + uVar2 * 4) = param_2; + uVar2 = iVar1 + uVar2 * 4; + if (uVar2 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar2; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + return CONCAT31((int3)(uVar2 >> 8),1); +} + + + +// --- FUN_004192b0 at 0x004192B0 (size: 120) --- + +uint __thiscall FUN_004192b0(int param_1,uint *param_2) + +{ + uint *puVar1; + int iVar2; + uint uVar3; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + do { + if (puVar1 == (uint *)0x0) { +LAB_004192db: + if ((int)(*(uint *)(param_1 + 0x68) * 2) < *(int *)(param_1 + 0x6c) + 1) { + FUN_00414d30(); + } + uVar3 = *param_2 % *(uint *)(param_1 + 0x68); + iVar2 = *(int *)(param_1 + 0x60); + param_2[1] = *(uint *)(iVar2 + uVar3 * 4); + *(uint **)(iVar2 + uVar3 * 4) = param_2; + uVar3 = iVar2 + uVar3 * 4; + if (uVar3 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar3; + } + iVar2 = *(int *)(param_1 + 0x6c) + 1; + *(int *)(param_1 + 0x6c) = iVar2; + return CONCAT31((int3)((uint)iVar2 >> 8),1); + } + if (*puVar1 == *param_2) { + if (puVar1 != (uint *)0x0) { + return (uint)puVar1 & 0xffffff00; + } + goto LAB_004192db; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_00419470 at 0x00419470 (size: 94) --- + +undefined4 FUN_00419470(undefined4 *param_1,undefined4 *param_2) + +{ + char cVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)FUN_005df0f5(0x10); + if (puVar2 == (undefined4 *)0x0) { + puVar2 = (undefined4 *)0x0; + } + else { + *puVar2 = *param_1; + puVar2[1] = param_1[1]; + puVar2[2] = 0; + puVar2[3] = *param_2; + } + cVar1 = FUN_00419240(puVar2); + if (cVar1 == '\0') { + if (puVar2 != (undefined4 *)0x0) { + operator_delete(puVar2); + } + return 0; + } + return 1; +} + + + +// --- FUN_004194d0 at 0x004194D0 (size: 88) --- + +undefined4 FUN_004194d0(undefined4 *param_1,undefined4 *param_2) + +{ + char cVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar2 == (undefined4 *)0x0) { + puVar2 = (undefined4 *)0x0; + } + else { + *puVar2 = *param_1; + puVar2[1] = 0; + puVar2[2] = *param_2; + } + cVar1 = FUN_004192b0(puVar2); + if (cVar1 == '\0') { + if (puVar2 != (undefined4 *)0x0) { + operator_delete(puVar2); + } + return 0; + } + return 1; +} + + + +// --- FUN_00419530 at 0x00419530 (size: 188) --- + +undefined4 * __thiscall FUN_00419530(int param_1,undefined4 *param_2,undefined4 param_3,int param_4) + +{ + int iVar1; + int iVar2; + undefined4 *puVar3; + + iVar2 = (int)param_2; + if (param_2 != (undefined4 *)0x0) { + if (*(int *)(param_1 + 0x108) == 0) { + *(undefined4 *)(param_1 + 0x108) = 1; + } + iVar1 = *(int *)(param_1 + 0x108); + *(int *)(param_1 + 0x108) = iVar1 + 1; + puVar3 = (undefined4 *)FUN_005df0f5(0x2c); + if (puVar3 == (undefined4 *)0x0) { + puVar3 = (undefined4 *)0x0; + } + else { + puVar3[1] = 1; + *puVar3 = &PTR_FUN_00796370; + puVar3[2] = 0; + puVar3[3] = iVar2; + puVar3[4] = 0; + puVar3[5] = param_3; + puVar3[6] = 0; + puVar3[7] = 0; + puVar3[8] = 0; + puVar3[9] = iVar1; + *(undefined1 *)(puVar3 + 10) = 0; + } + puVar3[2] = puVar3[2] + param_4; + param_2 = puVar3; + InterlockedIncrement(puVar3 + 1); + param_3 = puVar3[9]; + FUN_004194d0(¶m_3,¶m_2); + return puVar3; + } + return (undefined4 *)0x0; +} + + + +// --- FUN_00419aa0 at 0x00419AA0 (size: 69) --- + +void __thiscall FUN_00419aa0(int *param_1,int param_2) + +{ + uint uVar1; + int iVar2; + char cVar3; + + iVar2 = param_2; + cVar3 = FUN_00419470(param_2 + 0x10,¶m_2); + if (cVar3 != '\0') { + InterlockedIncrement((LONG *)(iVar2 + 4)); + uVar1 = *(uint *)(iVar2 + 0x60); + *(uint *)(iVar2 + 0x60) = uVar1 | 1; + *(uint *)(iVar2 + 0x60) = uVar1 | 3; + (**(code **)(*param_1 + 0x50))(iVar2); + } + return; +} + + + +// --- FUN_00419d10 at 0x00419D10 (size: 633) --- + +/* WARNING: Removing unreachable block (ram,0x00419edd) */ +/* WARNING: Removing unreachable block (ram,0x00419e3a) */ +/* WARNING: Removing unreachable block (ram,0x00419e56) */ +/* WARNING: Removing unreachable block (ram,0x00419e5f) */ +/* WARNING: Removing unreachable block (ram,0x00419e71) */ +/* WARNING: Removing unreachable block (ram,0x00419e42) */ +/* WARNING: Removing unreachable block (ram,0x00419e4b) */ +/* WARNING: Removing unreachable block (ram,0x00419f3c) */ + +undefined4 FUN_00419d10(int param_1,int param_2) + +{ + int *piVar1; + int iVar2; + int iVar3; + int *piVar4; + char cVar5; + undefined4 uVar6; + uint uVar7; + uint local_80; + undefined1 local_6c [92]; + undefined1 *local_10; + uint local_8; + + FUN_00414820(0x17); + uVar6 = FUN_00453850(1); + cVar5 = FUN_004180a0(uVar6); + if (cVar5 != '\0') { + iRam00000000 = param_1; + } + local_80 = (uint)(cVar5 != '\0'); + FUN_00414d80(param_1 + 0x10); + do { + do { + if (local_80 == 0) { + FUN_0041a390(); + if (local_10 != local_6c) { + operator_delete__(local_10); + } + return 0; + } + uVar7 = 0; + local_80 = local_80 - 1; + iVar2 = *(int *)(local_80 * 4); + *(undefined4 *)(local_80 * 4) = 0; + } while (*(int *)(iVar2 + 0x40) == 0); + do { + piVar1 = (int *)(*(int *)(iVar2 + 0x38) + uVar7 * 4); + iVar3 = *piVar1; + if ((iVar3 == param_2) || + ((*(int *)(param_2 + 0x10) == *(int *)(iVar3 + 0x10) && + (*(int *)(param_2 + 0x14) == *(int *)(iVar3 + 0x14))))) { + FUN_0041a390(); + if (local_10 != local_6c) { + operator_delete__(local_10); + } + return 1; + } + for (piVar4 = *(int **)(local_10 + + ((uint)(*(int *)(iVar3 + 0x10) + *(int *)(iVar3 + 0x14)) % local_8) * 4 + ); piVar4 != (int *)0x0; piVar4 = (int *)piVar4[2]) { + if ((*piVar4 == *(int *)(iVar3 + 0x10)) && (piVar4[1] == *(int *)(iVar3 + 0x14))) { + if (piVar4 != (int *)0x0) goto LAB_00419eb1; + break; + } + } + cVar5 = FUN_004180a0(8); + if (cVar5 != '\0') { + *(int *)(local_80 * 4) = *piVar1; + local_80 = local_80 + 1; + } + FUN_00414d80(*(int *)(*(int *)(iVar2 + 0x38) + uVar7 * 4) + 0x10); +LAB_00419eb1: + uVar7 = uVar7 + 1; + } while (uVar7 < *(uint *)(iVar2 + 0x40)); + } while( true ); +} + + + +// --- FUN_00419f90 at 0x00419F90 (size: 82) --- + +undefined4 * __thiscall FUN_00419f90(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007963a4; + FUN_005870f0(); + param_1[1] = &PTR_FUN_00795f8c; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0041a1b0 at 0x0041A1B0 (size: 82) --- + +undefined4 * __thiscall FUN_0041a1b0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007963a8; + FUN_0041a390(); + param_1[1] = &PTR_FUN_00795f88; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0041a210 at 0x0041A210 (size: 137) --- + +undefined4 * __fastcall FUN_0041a210(undefined4 *param_1) + +{ + undefined4 uVar1; + + *param_1 = &PTR_FUN_007963b0; + param_1[1] = &PTR_FUN_00795f70; + param_1[3] = 0; + param_1[4] = 0; + param_1[5] = 0; + param_1[6] = 0; + param_1[7] = 0x100; + uVar1 = thunk_FUN_005df0f5(0x4000); + param_1[2] = uVar1; + param_1[6] = 0x1000; + param_1[8] = &PTR_FUN_007963a8; + FUN_00418a10(0); + param_1[8] = &PTR_FUN_007963a8; + param_1[0x25] = &PTR_FUN_007963a4; + FUN_00418aa0(0); + param_1[0x25] = &PTR_FUN_007963a4; + *(undefined1 *)(param_1 + 0x43) = 0; + param_1[0x42] = 1; + return param_1; +} + + + +// --- FUN_0041a2a0 at 0x0041A2A0 (size: 120) --- + +void __thiscall FUN_0041a2a0(int param_1,int param_2) + +{ + int iVar1; + int iVar2; + undefined4 *puVar3; + int *piVar4; + undefined1 local_c [12]; + + puVar3 = (undefined4 *)FUN_0052dcf0(local_c); + *(undefined4 *)(param_1 + 0x70) = *puVar3; + iVar1 = puVar3[2]; + *(int *)(param_1 + 0x78) = iVar1; + *(undefined4 *)(param_1 + 0x74) = puVar3[1]; + do { + if ((iVar1 == 0) || (param_2 == 0)) { + return; + } + iVar1 = *(int *)(*(int *)(param_1 + 0x78) + 8); + *(int *)(param_1 + 0x78) = iVar1; + if (iVar1 == 0) { + iVar1 = *(int *)(*(int *)(param_1 + 0x70) + 0x68); + iVar2 = *(int *)(*(int *)(param_1 + 0x70) + 0x60); + do { + piVar4 = (int *)(*(int *)(param_1 + 0x74) + 4); + *(int **)(param_1 + 0x74) = piVar4; + if (piVar4 == (int *)(iVar2 + iVar1 * 4)) goto LAB_0041a307; + } while (*piVar4 == 0); + *(int *)(param_1 + 0x78) = *piVar4; + } +LAB_0041a307: + iVar1 = *(int *)(param_1 + 0x78); + param_2 = param_2 + -1; + } while( true ); +} + + + +// --- FUN_0041a320 at 0x0041A320 (size: 110) --- + +uint __thiscall FUN_0041a320(int param_1,int *param_2) + +{ + int iVar1; + uint uVar2; + undefined1 local_c [8]; + uint local_4; + + FUN_00414190(local_c,param_2); + if (local_4 != 0) { + return local_4 & 0xffffff00; + } + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + FUN_00418c40(); + } + uVar2 = (uint)(param_2[1] + *param_2) % *(uint *)(param_1 + 0x68); + iVar1 = *(int *)(param_1 + 0x60); + param_2[2] = *(int *)(iVar1 + uVar2 * 4); + *(int **)(iVar1 + uVar2 * 4) = param_2; + uVar2 = iVar1 + uVar2 * 4; + if (uVar2 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar2; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + return CONCAT31((int3)(uVar2 >> 8),1); +} + + + +// --- FUN_0041a390 at 0x0041A390 (size: 122) --- + +void __fastcall FUN_0041a390(int param_1) + +{ + int iVar1; + void *pvVar2; + void *pvVar3; + void *pvVar4; + int *piVar5; + + iVar1 = *(int *)(param_1 + 0x6c); + do { + if (iVar1 == 0) { + return; + } + piVar5 = *(int **)(param_1 + 100); + while (piVar5 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar5 = *(int **)(param_1 + 100); + pvVar4 = (void *)*piVar5; + goto LAB_0041a3cf; + } + piVar5 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar5; + } + piVar5 = (int *)0x0; + pvVar4 = (void *)0x0; +LAB_0041a3cf: + pvVar3 = (void *)*piVar5; + if (pvVar3 == pvVar4) { +LAB_0041a3e2: + *piVar5 = *(int *)((int)pvVar3 + 8); + } + else { + do { + pvVar2 = pvVar3; + pvVar3 = *(void **)((int)pvVar2 + 8); + } while (pvVar3 != pvVar4); + if (pvVar2 == (void *)0x0) goto LAB_0041a3e2; + *(undefined4 *)((int)pvVar2 + 8) = *(undefined4 *)((int)pvVar3 + 8); + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + if (pvVar4 != (void *)0x0) { + operator_delete(pvVar4); + } + iVar1 = *(int *)(param_1 + 0x6c); + } while( true ); +} + + + +// --- FUN_0041a410 at 0x0041A410 (size: 55) --- + +void __fastcall FUN_0041a410(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_00795f98; + FUN_0041a390(); + *param_1 = &PTR_FUN_00795f84; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + return; +} + + + +// --- FUN_0041a450 at 0x0041A450 (size: 131) --- + +char __thiscall FUN_0041a450(int param_1,void *param_2) + +{ + uint uVar1; + char cVar2; + uint uVar3; + undefined1 local_c [8]; + int local_4; + + cVar2 = '\0'; + if ((*(int *)((int)param_2 + 4) == DAT_00837c5c) || (cVar2 = FUN_0041a320(param_2), cVar2 == '\0') + ) { + FUN_00414190(local_c,param_2); + if (local_4 != 0) { + uVar1 = *(uint *)(local_4 + 0xc); + uVar3 = (uVar1 | *(uint *)((int)param_2 + 0xc)) & DAT_00837c58 | + uVar1 & *(uint *)((int)param_2 + 0xc); + cVar2 = uVar3 != uVar1; + *(uint *)(local_4 + 0xc) = uVar3; + } + operator_delete(param_2); + if (cVar2 == '\0') { + return '\0'; + } + } + *(int *)(param_1 + 0x70) = param_1; + *(undefined4 *)(param_1 + 0x78) = 0; + *(undefined4 *)(param_1 + 0x74) = 0; + return cVar2; +} + + + +// --- FUN_0041a4e0 at 0x0041A4E0 (size: 170) --- + +uint FUN_0041a4e0(undefined4 *param_1,uint param_2) + +{ + undefined4 uVar1; + uint uVar2; + undefined4 *puVar3; + uint uVar4; + undefined1 local_c [8]; + int local_4; + + if (param_1[1] == DAT_00837c5c) { + return param_1[1] & 0xffffff00; + } + FUN_00414190(local_c,param_1); + if (local_4 != 0) { + uVar4 = *(uint *)(local_4 + 0xc); + uVar2 = (uVar4 | param_2) & DAT_00837c58 | uVar4 & param_2; + *(uint *)(local_4 + 0xc) = uVar2; + return CONCAT31((int3)(uVar2 >> 8),uVar2 != uVar4); + } + puVar3 = (undefined4 *)FUN_005df0f5(0x10); + if (puVar3 != (undefined4 *)0x0) { + *puVar3 = *param_1; + uVar1 = param_1[1]; + puVar3[3] = param_2; + puVar3[1] = uVar1; + puVar3[2] = 0; + uVar4 = FUN_0041a450(puVar3); + return uVar4; + } + uVar4 = FUN_0041a450(0); + return uVar4; +} + + + +// --- FUN_0041a590 at 0x0041A590 (size: 78) --- + +undefined4 FUN_0041a590(int *param_1,undefined4 param_2) + +{ + byte bVar1; + undefined4 uVar2; + uint uVar3; + byte bVar4; + uint uVar5; + undefined4 uVar6; + + bVar4 = 0; + uVar5 = 0; + uVar3 = 0; + if (param_1[2] != 0) { + do { + uVar6 = param_2; + uVar2 = FUN_004220b0(*(undefined4 *)(*param_1 + uVar5 * 4),0); + bVar1 = FUN_0041a4e0(uVar2,uVar6); + bVar4 = bVar4 | bVar1; + uVar3 = param_1[2]; + uVar5 = uVar5 + 1; + } while (uVar5 < uVar3); + } + return CONCAT31((int3)(uVar3 >> 8),bVar4); +} + + + +// --- FUN_0041a5f0 at 0x0041A5F0 (size: 11) --- + +int FUN_0041a5f0(uint param_1) + +{ + return 2 - (uint)(param_1 < 2); +} + + + +// --- FUN_0041a600 at 0x0041A600 (size: 64) --- + +undefined4 * __thiscall FUN_0041a600(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079645c; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0041a640 at 0x0041A640 (size: 143) --- + +undefined4 * __thiscall FUN_0041a640(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_0079645c; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_0041a6d0 at 0x0041A6D0 (size: 156) --- + +void __fastcall FUN_0041a6d0(int param_1) + +{ + int iVar1; + void *pvVar2; + void *pvVar3; + int *piVar4; + void *pvVar5; + + iVar1 = *(int *)(param_1 + 0x6c); + do { + if (iVar1 == 0) { + return; + } + piVar4 = *(int **)(param_1 + 100); + while (piVar4 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar4 = *(int **)(param_1 + 100); + pvVar5 = (void *)*piVar4; + goto LAB_0041a70f; + } + piVar4 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar4; + } + piVar4 = (int *)0x0; + pvVar5 = (void *)0x0; +LAB_0041a70f: + pvVar3 = (void *)*piVar4; + if (pvVar3 == pvVar5) { +LAB_0041a722: + *piVar4 = *(int *)((int)pvVar3 + 4); + } + else { + do { + pvVar2 = pvVar3; + pvVar3 = *(void **)((int)pvVar2 + 4); + } while (pvVar3 != pvVar5); + if (pvVar2 == (void *)0x0) goto LAB_0041a722; + *(undefined4 *)((int)pvVar2 + 4) = *(undefined4 *)((int)pvVar3 + 4); + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + if (pvVar5 != (void *)0x0) { + if ((*(uint *)((int)pvVar5 + 0x10) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)((int)pvVar5 + 0xc)); + } + operator_delete(pvVar5); + } + iVar1 = *(int *)(param_1 + 0x6c); + } while( true ); +} + + + +// --- FUN_0041a770 at 0x0041A770 (size: 150) --- + +undefined4 FUN_0041a770(undefined4 *param_1,int param_2) + +{ + char cVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)FUN_005df0f5(0x58); + if (puVar2 == (undefined4 *)0x0) { + puVar2 = (undefined4 *)0x0; + } + else { + *puVar2 = *param_1; + puVar2[1] = 0; + puVar2[2] = &PTR_LAB_00795430; + puVar2[3] = puVar2 + 6; + puVar2[4] = 8; + puVar2[5] = 0; + FUN_00410a00(param_2 + 4); + } + cVar1 = FUN_0042bd40(puVar2); + if (cVar1 == '\0') { + if (puVar2 != (undefined4 *)0x0) { + if ((puVar2[4] & 0x80000000) == 0x80000000) { + operator_delete__((void *)puVar2[3]); + } + operator_delete(puVar2); + } + return 0; + } + return 1; +} + + + +// --- FUN_0041a810 at 0x0041A810 (size: 247) --- + +uint * FUN_0041a810(uint param_1) + +{ + uint *puVar1; + uint uVar2; + uint *puVar3; + undefined **local_50; + undefined1 *local_4c; + uint local_48; + undefined4 local_44; + undefined1 local_40 [64]; + + uVar2 = param_1; + puVar3 = (uint *)0x0; + for (puVar1 = *(uint **)(DAT_00818794 + (param_1 % DAT_0081879c) * 4); puVar1 != (uint *)0x0; + puVar1 = (uint *)puVar1[1]) { + if (*puVar1 == param_1) { + if ((puVar1 != (uint *)0x0) && (puVar1 + 2 != (uint *)0x0)) { + return puVar1 + 2; + } + break; + } + } + local_4c = local_40; + local_50 = &PTR_LAB_00795430; + local_48 = 8; + local_44 = 0; + FUN_0041a770(¶m_1,&local_50); + if ((local_48 & 0x80000000) == 0x80000000) { + operator_delete__(local_4c); + } + puVar1 = *(uint **)(DAT_00818794 + (uVar2 % DAT_0081879c) * 4); + do { + if (puVar1 == (uint *)0x0) { +LAB_0041a8ca: + FUN_00410500(0x436f7265,2 - (uint)(uVar2 < 2)); + FUN_00410500(0x444f626a,uVar2); + FUN_00410500(0x55494c20,2 < uVar2); + return puVar3; + } + if (*puVar1 == uVar2) { + if (puVar1 != (uint *)0x0) { + puVar3 = puVar1 + 2; + } + goto LAB_0041a8ca; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_0041a910 at 0x0041A910 (size: 82) --- + +undefined4 * __thiscall FUN_0041a910(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00796460; + FUN_0041a6d0(); + param_1[1] = &PTR_FUN_0079645c; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0041a970 at 0x0041A970 (size: 26) --- + +undefined4 __fastcall FUN_0041a970(int param_1) + +{ + if (*(int **)(param_1 + 0x34) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x34) + 0x14))(); + *(undefined4 *)(param_1 + 0x34) = 0; + } + return 1; +} + + + +// --- FUN_0041a9d0 at 0x0041A9D0 (size: 64) --- + +undefined4 * __thiscall FUN_0041a9d0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00796464; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0041aa10 at 0x0041AA10 (size: 64) --- + +undefined4 * __thiscall FUN_0041aa10(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00796468; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0041aa50 at 0x0041AA50 (size: 71) --- + +uint __fastcall FUN_0041aa50(undefined4 *param_1) + +{ + char *pcVar1; + char cVar2; + int iVar3; + uint uVar4; + char *pcVar5; + + pcVar5 = (char *)*param_1; + uVar4 = 0; + cVar2 = *pcVar5; + while (cVar2 != '\0') { + iVar3 = tolower((int)cVar2); + uVar4 = uVar4 * 0x10 + (int)(char)iVar3; + if ((uVar4 & 0xf0000000) != 0) { + uVar4 = ((uVar4 & 0xf0000000) >> 0x18 ^ uVar4) & 0xfffffff; + } + pcVar1 = pcVar5 + 1; + pcVar5 = pcVar5 + 1; + cVar2 = *pcVar1; + } + return uVar4; +} + + + +// --- FUN_0041aaa0 at 0x0041AAA0 (size: 42) --- + +void FUN_0041aaa0(undefined4 param_1,undefined4 param_2) + +{ + undefined4 uVar1; + + uVar1 = FUN_004220b0(param_1,0); + FUN_0041a4e0(uVar1,param_2); + return; +} + + + +// --- FUN_0041ab00 at 0x0041AB00 (size: 72) --- + +bool __thiscall FUN_0041ab00(int *param_1,int *param_2) + +{ + if (*param_1 == 0) { + return *param_2 != 0; + } + if ((*param_1 == *param_2) && (param_1[3] == param_2[3])) { + return false; + } + return true; +} + + + +// --- FUN_0041ab50 at 0x0041AB50 (size: 6) --- + +undefined4 __fastcall FUN_0041ab50(int param_1) + +{ + return **(undefined4 **)(param_1 + 0xc); +} + + + +// --- FUN_0041ab60 at 0x0041AB60 (size: 29) --- + +int * __thiscall FUN_0041ab60(int param_1,int *param_2) + +{ + int iVar1; + + iVar1 = *(int *)(*(int *)(param_1 + 0xc) + 8); + *param_2 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + return param_2; +} + + + +// --- FUN_0041ab80 at 0x0041AB80 (size: 27) --- + +int * __thiscall FUN_0041ab80(int *param_1,int *param_2) + +{ + int iVar1; + + iVar1 = *param_2; + *param_1 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + return param_1; +} + + + +// --- FUN_0041aba0 at 0x0041ABA0 (size: 48) --- + +undefined4 * __thiscall FUN_0041aba0(undefined4 *param_1,undefined4 param_2) + +{ + undefined4 uVar1; + + *param_1 = 0; + uVar1 = FUN_004220b0(param_2,0x24); + uVar1 = FUN_00415430(uVar1); + *param_1 = uVar1; + return param_1; +} + + + +// --- FUN_0041abd0 at 0x0041ABD0 (size: 48) --- + +undefined4 * __thiscall FUN_0041abd0(undefined4 *param_1,undefined4 param_2) + +{ + undefined4 uVar1; + + *param_1 = 0; + uVar1 = FUN_004220b0(param_2,0x26); + uVar1 = FUN_00415430(uVar1); + *param_1 = uVar1; + return param_1; +} + + + +// --- FUN_0041ac00 at 0x0041AC00 (size: 48) --- + +undefined4 * __thiscall FUN_0041ac00(undefined4 *param_1,undefined4 param_2) + +{ + undefined4 uVar1; + + *param_1 = 0; + uVar1 = FUN_004220b0(param_2,0x28); + uVar1 = FUN_00415430(uVar1); + *param_1 = uVar1; + return param_1; +} + + + +// --- FUN_0041ac30 at 0x0041AC30 (size: 47) --- + +undefined4 __thiscall FUN_0041ac30(int param_1,undefined4 param_2) + +{ + int local_c [3]; + + local_c[0] = param_1 + 0x3c; + local_c[1] = 0; + local_c[2] = 0; + FUN_0041ac60(0,local_c); + return param_2; +} + + + +// --- FUN_0041ac60 at 0x0041AC60 (size: 157) --- + +int * __thiscall FUN_0041ac60(int *param_1,int param_2,int *param_3) + +{ + int iVar1; + undefined4 uVar2; + int local_38 [3]; + undefined1 local_2c [16]; + int local_1c; + int local_18; + int local_14; + int local_4; + + *param_1 = param_2; + param_1[1] = *param_3; + param_1[2] = param_3[1]; + param_1[3] = param_3[2]; + iVar1 = *param_1; + while( true ) { + if (iVar1 == 0) { + return param_1; + } + local_38[0] = *param_1 + 0x3c; + local_38[1] = 0; + local_38[2] = 0; + FUN_0041ac60(0,local_38); + if (param_1[3] != local_4) break; + iVar1 = *(int *)(*param_1 + 0x34); + *param_1 = iVar1; + if (iVar1 != 0) { + uVar2 = FUN_00429c70(local_2c); + FUN_0041ac60(iVar1,uVar2); + param_1[1] = local_1c; + param_1[3] = local_14; + param_1[2] = local_18; + } + iVar1 = *param_1; + } + return param_1; +} + + + +// --- FUN_0041ad00 at 0x0041AD00 (size: 65) --- + +undefined4 __thiscall FUN_0041ad00(undefined4 param_1,undefined4 param_2) + +{ + undefined4 *puVar1; + undefined4 local_18; + undefined4 local_14; + undefined4 local_10; + undefined1 local_c [12]; + + puVar1 = (undefined4 *)FUN_0052dcf0(local_c); + local_18 = *puVar1; + local_14 = puVar1[1]; + local_10 = puVar1[2]; + FUN_0041ac60(param_1,&local_18); + return param_2; +} + + + +// --- FUN_0041ad50 at 0x0041AD50 (size: 212) --- + +int * __fastcall FUN_0041ad50(int *param_1) + +{ + int iVar1; + int *piVar2; + int local_38 [4]; + undefined4 *local_28; + undefined4 local_24; + int local_1c; + int local_18; + int local_14; + int local_4; + + FUN_0042cb20(local_38 + 3,0); + if (*param_1 != 0) { + local_38[1] = 0; + local_38[2] = 0; + do { + local_38[0] = *param_1 + 0x3c; + FUN_0041ac60(0,local_38); + if (param_1[3] != local_4) { + return param_1; + } + iVar1 = *(int *)(*param_1 + 0x34); + *param_1 = iVar1; + if (iVar1 != 0) { + local_38[3] = iVar1 + 0x3c; + piVar2 = *(int **)(iVar1 + 0xa0); + while (piVar2 != (int *)(*(int *)(iVar1 + 0x9c) + *(int *)(iVar1 + 0xa4) * 4)) { + if (**(int **)(iVar1 + 0xa0) != 0) { + local_28 = *(undefined4 **)(iVar1 + 0xa0); + local_24 = *local_28; + goto LAB_0041ade3; + } + piVar2 = *(int **)(iVar1 + 0xa0) + 1; + *(int **)(iVar1 + 0xa0) = piVar2; + } + local_28 = (undefined4 *)0x0; + local_24 = 0; +LAB_0041ade3: + FUN_0041ac60(iVar1,local_38 + 3); + param_1[1] = local_1c; + param_1[3] = local_14; + param_1[2] = local_18; + } + } while (*param_1 != 0); + } + return param_1; +} + + + +// --- FUN_0041ae30 at 0x0041AE30 (size: 120) --- + +undefined4 __thiscall FUN_0041ae30(int param_1,uint *param_2,uint *param_3) + +{ + uint *puVar1; + uint uVar2; + LONG LVar3; + + puVar1 = *(uint **)(*(int *)(param_1 + 100) + (*param_2 % *(uint *)(param_1 + 0x6c)) * 4); + while( true ) { + if (puVar1 == (uint *)0x0) { + return 0; + } + if (*puVar1 == *param_2) break; + puVar1 = (uint *)puVar1[1]; + } + if (puVar1 == (uint *)0x0) { + return 0; + } + uVar2 = *param_3; + if (uVar2 != puVar1[2]) { + LVar3 = InterlockedDecrement((LONG *)(uVar2 - 0x10)); + if ((LVar3 == 0) && ((undefined4 *)(uVar2 - 0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(uVar2 - 0x14))(1); + } + uVar2 = puVar1[2]; + *param_3 = uVar2; + InterlockedIncrement((LONG *)(uVar2 - 0x10)); + } + return 1; +} + + + +// --- FUN_0041aeb0 at 0x0041AEB0 (size: 93) --- + +void __thiscall FUN_0041aeb0(int param_1,int *param_2,undefined4 *param_3) + +{ + uint uVar1; + int iVar2; + undefined4 *puVar3; + uint uVar4; + int iVar5; + + uVar1 = *(uint *)(param_1 + 0x68); + uVar4 = FUN_0041aa50(); + uVar4 = uVar4 % uVar1; + iVar2 = *(int *)(param_1 + 0x60); + puVar3 = *(undefined4 **)(iVar2 + uVar4 * 4); + while ((puVar3 != (undefined4 *)0x0 && + (iVar5 = _stricmp((char *)*puVar3,(char *)*param_3), iVar5 != 0))) { + puVar3 = (undefined4 *)puVar3[1]; + } + param_2[2] = (int)puVar3; + *param_2 = param_1; + param_2[1] = iVar2 + uVar4 * 4; + return; +} + + + +// --- FUN_0041af10 at 0x0041AF10 (size: 73) --- + +void __fastcall FUN_0041af10(int param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + undefined4 local_4; + + puVar1 = PTR_DAT_00818558; + local_4 = *(undefined4 *)(param_1 + 0x68); + puVar2 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,local_4,0); + if ((puVar2 != (undefined4 *)puVar1) || (puVar2 = puVar2 + -1, puVar2 != (undefined4 *)puVar1)) { + puVar2 = puVar2 + 1; + } + FUN_0041b570(*puVar2); + return; +} + + + +// --- FUN_0041af60 at 0x0041AF60 (size: 246) --- + +undefined1 __thiscall FUN_0041af60(int param_1,undefined4 param_2,int *param_3) + +{ + undefined *puVar1; + int *piVar2; + undefined *puVar3; + char cVar4; + undefined1 uVar5; + LONG LVar6; + undefined4 *puVar7; + undefined *local_4; + + local_4 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + cVar4 = FUN_0041ae30(¶m_2,&local_4); + puVar3 = local_4; + piVar2 = param_3; + if (cVar4 != '\0') { + puVar1 = (undefined *)*param_3; + if (puVar1 != local_4) { + LVar6 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + *piVar2 = (int)puVar3; + InterlockedIncrement((LONG *)(puVar3 + -0x10)); + } + LVar6 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar3 + -0x14))(1); + } + return 1; + } + if (*(int *)(param_1 + 0x34) != 0) { + uVar5 = FUN_0041af60(param_2,param_3); + puVar7 = (undefined4 *)(local_4 + -0x14); + LVar6 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar6 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + return uVar5; + } + puVar7 = (undefined4 *)(local_4 + -0x14); + LVar6 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar6 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + return 0; +} + + + +// --- FUN_0041b060 at 0x0041B060 (size: 241) --- + +bool FUN_0041b060(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + char cVar1; + int iVar2; + uint local_8; + int *local_4; + + FUN_00415640(&local_8,param_1,1); + if (local_8 == DAT_00837c64) { + return false; + } + iVar2 = FUN_0041c280(local_8); + if (iVar2 == 0x24) { + FUN_0041aba0(local_8); + if (local_4 == (int *)0x0) { + return false; + } + cVar1 = FUN_0041af60(param_2,param_3); + } + else { + if (iVar2 == 0x26) { + FUN_0041abd0(local_8); + if (local_4 == (int *)0x0) { + return false; + } + cVar1 = FUN_00415c90(param_2,param_3); + (**(code **)(*local_4 + 0x14))(); + return cVar1 != '\0'; + } + if (iVar2 != 0x28) { + return false; + } + FUN_0041ac00(local_8); + if (local_4 == (int *)0x0) { + return false; + } + cVar1 = FUN_00415c90(param_2,param_3); + } + (**(code **)(*local_4 + 0x14))(); + return cVar1 != '\0'; +} + + + +// --- FUN_0041b160 at 0x0041B160 (size: 190) --- + +undefined1 FUN_0041b160(undefined4 param_1,undefined4 param_2,int *param_3) + +{ + int iVar1; + undefined1 uVar2; + int *piVar3; + LONG LVar4; + int local_8; + int local_4; + + FUN_0040d810(&local_8,param_3); + uVar2 = FUN_0041b060(param_1,param_2,&local_8); + piVar3 = (int *)FUN_0040d200(&local_4,&local_8); + iVar1 = *param_3; + if (iVar1 != *piVar3) { + LVar4 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *piVar3; + *param_3 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + LVar4 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + LVar4 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(local_8 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_8 + -0x14))(1); + } + return uVar2; +} + + + +// --- FUN_0041b220 at 0x0041B220 (size: 150) --- + +bool FUN_0041b220(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + char cVar1; + int iVar2; + int *piVar3; + undefined4 uVar4; + + iVar2 = FUN_0041c280(param_1); + if (iVar2 == 0x24) { + uVar4 = FUN_004220b0(param_1,0x24); + piVar3 = (int *)FUN_00415430(uVar4); + if (piVar3 == (int *)0x0) { + return false; + } + cVar1 = FUN_0041af60(param_2,param_3); + } + else { + if (iVar2 == 0x26) { + uVar4 = 0x26; + } + else { + if (iVar2 != 0x28) { + return false; + } + uVar4 = 0x28; + } + uVar4 = FUN_004220b0(param_1,uVar4); + piVar3 = (int *)FUN_00415430(uVar4); + if (piVar3 == (int *)0x0) { + return false; + } + cVar1 = FUN_00415c90(param_2,param_3); + } + (**(code **)(*piVar3 + 0x14))(); + return cVar1 != '\0'; +} + + + +// --- FUN_0041b2c0 at 0x0041B2C0 (size: 82) --- + +undefined4 * __thiscall FUN_0041b2c0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079646c; + FUN_00433a10(); + param_1[1] = &PTR_FUN_00796468; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0041b320 at 0x0041B320 (size: 143) --- + +undefined4 * __thiscall FUN_0041b320(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00796464; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_0041b3b0 at 0x0041B3B0 (size: 143) --- + +undefined4 * __thiscall FUN_0041b3b0(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00796468; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_0041b440 at 0x0041B440 (size: 77) --- + +void __thiscall FUN_0041b440(int param_1,int param_2) + +{ + uint uVar1; + int iVar2; + uint uVar3; + + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + FUN_0041af10(); + } + uVar1 = *(uint *)(param_1 + 0x68); + uVar3 = FUN_0041aa50(); + uVar3 = uVar3 % uVar1; + iVar2 = *(int *)(param_1 + 0x60); + *(undefined4 *)(param_2 + 4) = *(undefined4 *)(iVar2 + uVar3 * 4); + *(int *)(iVar2 + uVar3 * 4) = param_2; + uVar1 = iVar2 + uVar3 * 4; + if (uVar1 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar1; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + return; +} + + + +// --- FUN_0041b490 at 0x0041B490 (size: 221) --- + +undefined4 __thiscall FUN_0041b490(int param_1,undefined4 *param_2) + +{ + LONG *lpAddend; + undefined4 *puVar1; + int iVar2; + LONG LVar3; + undefined4 uVar4; + int iVar5; + undefined1 local_c [8]; + int local_4; + + iVar2 = (int)param_2; + lpAddend = (LONG *)((int)param_2 + -0x10); + InterlockedIncrement(lpAddend); + FUN_0041aeb0(local_c,¶m_2); + if (local_4 == 0) { + param_2 = (undefined4 *)0x0; + } + else { + param_2 = (undefined4 *)(local_4 + 8); + } + puVar1 = (undefined4 *)(iVar2 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + if (param_2 == (undefined4 *)0x0) { + if (*(int *)(param_1 + 0x34) == 0) { + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + return 0; + } + iVar5 = iVar2; + InterlockedIncrement(lpAddend); + uVar4 = FUN_0041b490(iVar5); + } + else { + uVar4 = *param_2; + } + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + return uVar4; +} + + + +// --- FUN_0041b570 at 0x0041B570 (size: 320) --- + +undefined4 __thiscall FUN_0041b570(int param_1,int param_2) + +{ + uint uVar1; + int iVar2; + int iVar3; + undefined4 *puVar4; + int iVar5; + int iVar6; + undefined4 *puVar7; + uint uVar8; + int iVar9; + int *piVar10; + + iVar2 = param_2; + if (param_2 == *(int *)(param_1 + 0x68)) { + return 0; + } + iVar6 = *(int *)(param_1 + 0x6c); + iVar3 = 0; + do { + if (iVar6 == 0) { + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_00693b20(iVar2); + puVar4 = (undefined4 *)PTR_DAT_00818558; + iVar2 = param_2; + while (iVar3 != 0) { + param_2 = *(int *)(param_1 + 0x68); + iVar6 = *(int *)(iVar3 + 4); + PTR_DAT_00818558 = (undefined *)puVar4; + if (param_2 * 2 < *(int *)(param_1 + 0x6c) + 1) { + puVar7 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,puVar4,¶m_2,param_2,0); + if ((puVar7 != puVar4) || (puVar7 = puVar7 + -1, puVar7 != puVar4)) { + puVar7 = puVar7 + 1; + } + FUN_0041b570(*puVar7); + iVar2 = param_2; + } + param_2 = iVar2; + uVar1 = *(uint *)(param_1 + 0x68); + uVar8 = FUN_0041aa50(); + uVar8 = uVar8 % uVar1; + iVar2 = *(int *)(param_1 + 0x60); + *(undefined4 *)(iVar3 + 4) = *(undefined4 *)(iVar2 + uVar8 * 4); + *(int *)(iVar2 + uVar8 * 4) = iVar3; + uVar1 = iVar2 + uVar8 * 4; + if (uVar1 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar1; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + puVar4 = (undefined4 *)PTR_DAT_00818558; + iVar2 = param_2; + iVar3 = iVar6; + } + PTR_DAT_00818558 = (undefined *)puVar4; + return 1; + } + piVar10 = *(int **)(param_1 + 100); + while (piVar10 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar10 = *(int **)(param_1 + 100); + iVar9 = *piVar10; + goto LAB_0041b5bf; + } + piVar10 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar10; + } + piVar10 = (int *)0x0; + iVar9 = 0; +LAB_0041b5bf: + iVar6 = *piVar10; + if (iVar6 == iVar9) { +LAB_0041b5d2: + *piVar10 = *(int *)(iVar6 + 4); + } + else { + do { + iVar5 = iVar6; + iVar6 = *(int *)(iVar5 + 4); + } while (iVar6 != iVar9); + if (iVar5 == 0) goto LAB_0041b5d2; + *(undefined4 *)(iVar5 + 4) = *(undefined4 *)(iVar6 + 4); + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + *(int *)(iVar9 + 4) = iVar3; + iVar6 = *(int *)(param_1 + 0x6c); + iVar3 = iVar9; + } while( true ); +} + + + +// --- FUN_0041b6b0 at 0x0041B6B0 (size: 289) --- + +undefined4 __thiscall FUN_0041b6b0(int param_1,int param_2) + +{ + uint *puVar1; + int iVar2; + uint *puVar3; + int *piVar4; + undefined4 *puVar5; + undefined4 *puVar6; + uint *puVar7; + + if (param_2 == *(int *)(param_1 + 0x68)) { + return 0; + } + iVar2 = *(int *)(param_1 + 0x6c); + puVar3 = (uint *)0x0; + do { + if (iVar2 == 0) { + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_00693b20(param_2); + puVar6 = (undefined4 *)PTR_DAT_00818558; + while (puVar3 != (uint *)0x0) { + param_2 = *(int *)(param_1 + 0x68); + puVar7 = (uint *)puVar3[1]; + PTR_DAT_00818558 = (undefined *)puVar6; + if (param_2 * 2 < *(int *)(param_1 + 0x6c) + 1) { + puVar5 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,puVar6,¶m_2,param_2,0); + if ((puVar5 != puVar6) || (puVar5 = puVar5 + -1, puVar5 != puVar6)) { + puVar5 = puVar5 + 1; + } + FUN_0041b6b0(*puVar5); + } + puVar1 = (uint *)(*(int *)(param_1 + 0x60) + (*puVar3 % *(uint *)(param_1 + 0x68)) * 4); + puVar3[1] = *puVar1; + *puVar1 = (uint)puVar3; + if (puVar1 < *(uint **)(param_1 + 100)) { + *(uint **)(param_1 + 100) = puVar1; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + puVar6 = (undefined4 *)PTR_DAT_00818558; + puVar3 = puVar7; + } + PTR_DAT_00818558 = (undefined *)puVar6; + return 1; + } + piVar4 = *(int **)(param_1 + 100); + while (piVar4 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + puVar6 = *(undefined4 **)(param_1 + 100); + puVar7 = (uint *)*puVar6; + goto LAB_0041b701; + } + piVar4 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar4; + } + puVar6 = (undefined4 *)0x0; + puVar7 = (uint *)0x0; +LAB_0041b701: + FUN_00428ba0(param_1,puVar6,puVar7); + puVar7[1] = (uint)puVar3; + iVar2 = *(int *)(param_1 + 0x6c); + puVar3 = puVar7; + } while( true ); +} + + + +// --- FUN_0041b7e0 at 0x0041B7E0 (size: 259) --- + +uint __thiscall FUN_0041b7e0(int param_1,int param_2,undefined4 *param_3) + +{ + undefined4 *puVar1; + int iVar2; + undefined1 uVar3; + LONG LVar4; + int iVar5; + undefined4 *puVar6; + undefined1 local_c [8]; + int local_4; + + iVar2 = param_2; + puVar1 = (undefined4 *)(param_2 + -0x14); + InterlockedIncrement((LONG *)(param_2 + -0x10)); + FUN_0041aeb0(local_c,¶m_2); + if (local_4 == 0) { + param_2 = (uint)param_2._1_3_ << 8; + } + else { + *param_3 = *(undefined4 *)(local_4 + 8); + param_2 = CONCAT31(param_2._1_3_,1); + } + LVar4 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar4 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + if ((char)param_2 != '\0') { + LVar4 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar4 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + return 1; + } + if (*(int *)(param_1 + 0x34) != 0) { + iVar5 = iVar2; + puVar6 = param_3; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + uVar3 = FUN_0041b7e0(iVar5,puVar6); + param_3 = (undefined4 *)CONCAT31(param_3._1_3_,uVar3); + LVar4 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar4 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + return (uint)param_3 & 0xff; + } + LVar4 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar4 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + return 0; +} + + + +// --- FUN_0041b8f0 at 0x0041B8F0 (size: 320) --- + +bool FUN_0041b8f0(undefined4 param_1,int param_2,undefined4 param_3) + +{ + char cVar1; + LONG LVar2; + int iVar3; + undefined4 *puVar4; + bool bVar5; + undefined4 uVar6; + int local_8; + int *local_4; + + bVar5 = false; + FUN_00415640(&local_8,param_1,1); + if (local_8 == DAT_00837c64) { + puVar4 = (undefined4 *)(param_2 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + return false; + } + iVar3 = FUN_0041c280(local_8); + if (iVar3 == 0x24) { + FUN_0041aba0(local_8); + if (local_4 == (int *)0x0) goto LAB_0041ba07; + iVar3 = param_2; + uVar6 = param_3; + InterlockedIncrement((LONG *)(param_2 + -0x10)); + cVar1 = FUN_0041b7e0(iVar3,uVar6); + } + else { + if (iVar3 != 0x26) { + if ((iVar3 == 0x28) && (FUN_0041ac00(local_8), local_4 != (int *)0x0)) { + cVar1 = FUN_004159d0(¶m_2,param_3); + bVar5 = cVar1 != '\0'; + (**(code **)(*local_4 + 0x14))(); + } + goto LAB_0041ba07; + } + FUN_0041abd0(local_8); + if (local_4 == (int *)0x0) goto LAB_0041ba07; + cVar1 = FUN_004159d0(¶m_2,param_3); + } + bVar5 = cVar1 != '\0'; + (**(code **)(*local_4 + 0x14))(); +LAB_0041ba07: + puVar4 = (undefined4 *)(param_2 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + return bVar5; +} + + + +// --- FUN_0041ba30 at 0x0041BA30 (size: 136) --- + +undefined1 FUN_0041ba30(undefined4 param_1,int param_2,undefined4 param_3) + +{ + undefined1 uVar1; + LONG LVar2; + undefined4 *puVar3; + int iVar4; + undefined4 uVar5; + int local_4; + + FUN_0040d810(&local_4,¶m_2); + iVar4 = local_4; + uVar5 = param_3; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + uVar1 = FUN_0041b8f0(param_1,iVar4,uVar5); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + puVar3 = (undefined4 *)(param_2 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + return uVar1; +} + + + +// --- FUN_0041bac0 at 0x0041BAC0 (size: 284) --- + +bool FUN_0041bac0(undefined4 param_1,int param_2,undefined4 param_3) + +{ + char cVar1; + int iVar2; + undefined4 uVar3; + int *piVar4; + LONG LVar5; + undefined4 *puVar6; + bool bVar7; + + bVar7 = false; + iVar2 = FUN_0041c280(param_1); + if (iVar2 == 0x24) { + uVar3 = FUN_004220b0(param_1,0x24); + piVar4 = (int *)FUN_00415430(uVar3); + if (piVar4 != (int *)0x0) { + iVar2 = param_2; + uVar3 = param_3; + InterlockedIncrement((LONG *)(param_2 + -0x10)); + cVar1 = FUN_0041b7e0(iVar2,uVar3); + bVar7 = cVar1 != '\0'; + (**(code **)(*piVar4 + 0x14))(); + } + } + else if (iVar2 == 0x26) { + uVar3 = FUN_004220b0(param_1,0x26); + piVar4 = (int *)FUN_00415430(uVar3); + if (piVar4 != (int *)0x0) { + cVar1 = FUN_004159d0(¶m_2,param_3); + bVar7 = cVar1 != '\0'; + (**(code **)(*piVar4 + 0x14))(); + } + } + else if (iVar2 == 0x28) { + uVar3 = FUN_004220b0(param_1,0x28); + piVar4 = (int *)FUN_00415430(uVar3); + if (piVar4 != (int *)0x0) { + cVar1 = FUN_004159d0(¶m_2,param_3); + bVar7 = cVar1 != '\0'; + (**(code **)(*piVar4 + 0x14))(); + } + } + puVar6 = (undefined4 *)(param_2 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar5 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + return bVar7; +} + + + +// --- FUN_0041bbe0 at 0x0041BBE0 (size: 143) --- + +undefined4 FUN_0041bbe0(int *param_1,int *param_2) + +{ + int iVar1; + int *piVar2; + undefined1 local_c [8]; + int local_4; + + FUN_0041aeb0(local_c,param_1); + if (local_4 != 0) { + *(int *)(local_4 + 8) = *param_2; + return 1; + } + piVar2 = (int *)FUN_005df0f5(0xc); + if (piVar2 == (int *)0x0) { + piVar2 = (int *)0x0; + } + else { + iVar1 = *param_1; + *piVar2 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + piVar2[1] = 0; + piVar2[2] = *param_2; + } + FUN_0041aeb0(local_c,piVar2); + if (local_4 == 0) { + FUN_0041b440(piVar2); + } + return 1; +} + + + +// --- FUN_0041bc70 at 0x0041BC70 (size: 67) --- + +void FUN_0041bc70(undefined4 param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + + puVar1 = PTR_DAT_00818558; + puVar2 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_1,param_1,0); + if (puVar2 == (undefined4 *)puVar1) { + puVar2 = puVar2 + -1; + } + FUN_0041b6b0(*puVar2); + return; +} + + + +// --- FUN_0041bcc0 at 0x0041BCC0 (size: 542) --- + +void FUN_0041bcc0(undefined4 param_1,int param_2,uint param_3) + +{ + int iVar1; + undefined *puVar2; + undefined *puVar3; + uint uVar4; + char cVar5; + undefined *puVar6; + byte *pbVar7; + int *piVar8; + undefined4 *puVar9; + LONG *lpAddend; + undefined4 *puVar10; + uint uVar11; + undefined4 *puVar12; + undefined1 local_c [12]; + + uVar4 = param_3; + if ((~*(byte *)(param_3 + 4) & 1) != 0) { + FUN_005c2c80(); + } + puVar3 = PTR_DAT_00818558; + puVar2 = PTR_DAT_00818554; + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x68); + puVar6 = (undefined *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_3,param_3,0); + if (puVar6 == puVar3) { + puVar6 = puVar6 + -4; + } + uVar11 = (int)puVar6 - (int)puVar2 >> 2; + } + else { + uVar11 = param_3 & 0xff; + } + FUN_0040ad10(1); + pbVar7 = (byte *)FUN_0040acf0(1); + if (pbVar7 != (byte *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + uVar11 = (uint)*pbVar7; + } + else { + *pbVar7 = (byte)uVar11; + } + } + if ((*(byte *)(uVar4 + 4) & 5) == 0) { + if ((uVar11 & 0xff) < DAT_007956cc) { + FUN_0041bc70(*(undefined4 *)(PTR_DAT_00818554 + (uVar11 & 0xff) * 4)); + } + else { + FUN_0040aa50(); + } + } + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x6c); + } + FUN_00401a80(¶m_3,¶m_3,uVar4); + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + piVar8 = (int *)FUN_0052dcf0(local_c); + iVar1 = *piVar8; + puVar12 = (undefined4 *)piVar8[1]; + puVar9 = (undefined4 *)piVar8[2]; +LAB_0041bdc2: + puVar10 = puVar9; + if (puVar9 != (undefined4 *)0x0) { + do { + FUN_0040ad10(4); + puVar9 = (undefined4 *)FUN_0040acf0(4); + if (puVar9 != (undefined4 *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + *puVar10 = *puVar9; + } + else { + *puVar9 = *puVar10; + } + } + FUN_00402400(uVar4); + puVar10 = (undefined4 *)puVar10[1]; + } while (puVar10 != (undefined4 *)0x0); + do { + puVar12 = puVar12 + 1; + puVar9 = puVar10; + if (puVar12 == (undefined4 *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) break; + puVar9 = (undefined4 *)*puVar12; + } while (puVar9 == (undefined4 *)0x0); + goto LAB_0041bdc2; + } + } + if ((*(byte *)(uVar4 + 4) & 5) == 0) { + uVar11 = FUN_0040a8f0(); + if (uVar11 < param_3) { +LAB_0041becf: + FUN_0040aa50(); + } + else { + uVar11 = 0; + puVar12 = (undefined4 *)0x0; + if (param_3 != 0) { + while( true ) { + puVar9 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar9 == (undefined4 *)0x0) { + puVar9 = (undefined4 *)0x0; + } + else { + puVar9[1] = 0; + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + puVar9[2] = PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + FUN_0040ad10(4); + puVar10 = (undefined4 *)FUN_0040acf0(4); + if (puVar10 != (undefined4 *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + *puVar9 = *puVar10; + } + else { + *puVar10 = *puVar9; + } + } + FUN_00402400(uVar4); + if ((*(uint *)(uVar4 + 4) >> 2 & 1) != 0) break; + cVar5 = FUN_00599310(puVar9,puVar12); + if (cVar5 == '\0') goto LAB_0041becf; + uVar11 = uVar11 + 1; + puVar12 = puVar9; + if (param_3 <= uVar11) { + return; + } + } + } + } + } + return; +} + + + +// --- FUN_0041bee0 at 0x0041BEE0 (size: 63) --- + +void __fastcall FUN_0041bee0(int param_1) + +{ + FUN_00433a10(); + FUN_00415e50(); + if (*(int **)(param_1 + 0x34) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x34) + 0x14))(); + *(undefined4 *)(param_1 + 0x34) = 0; + *(undefined4 *)(param_1 + 0x30) = DAT_00837c64; + return; + } + *(undefined4 *)(param_1 + 0x30) = DAT_00837c64; + return; +} + + + +// --- FUN_0041bf20 at 0x0041BF20 (size: 82) --- + +undefined4 * __thiscall FUN_0041bf20(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007964c8; + FUN_00415e50(); + param_1[1] = &PTR_FUN_00796464; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0041bf80 at 0x0041BF80 (size: 180) --- + +void __fastcall FUN_0041bf80(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_00796470; + FUN_00433a10(); + FUN_00415e50(); + if ((int *)param_1[0xd] != (int *)0x0) { + (**(code **)(*(int *)param_1[0xd] + 0x14))(); + param_1[0xd] = 0; + } + param_1[0xc] = DAT_00837c64; + param_1[0x2b] = &PTR_FUN_0079646c; + FUN_00433a10(); + param_1[0x2c] = &PTR_FUN_00796468; + if ((undefined4 *)param_1[0x44] != param_1 + 0x2d) { + operator_delete__((undefined4 *)param_1[0x44]); + } + param_1[0x44] = 0; + param_1[0x45] = 0; + param_1[0x46] = 0; + param_1[0x47] = 0; + param_1[0xe] = &PTR_FUN_007964c8; + FUN_00415e50(); + param_1[0xf] = &PTR_FUN_00796464; + if ((undefined4 *)param_1[0x27] != param_1 + 0x10) { + operator_delete__((undefined4 *)param_1[0x27]); + } + param_1[0x27] = 0; + param_1[0x28] = 0; + param_1[0x29] = 0; + param_1[0x2a] = 0; + FUN_004154b0(); + return; +} + + + +// --- FUN_0041c050 at 0x0041C050 (size: 97) --- + +undefined4 * __fastcall FUN_0041c050(undefined4 *param_1) + +{ + FUN_00415460(DAT_00837c64); + *param_1 = &PTR_LAB_00796470; + param_1[0xc] = DAT_00837c64; + param_1[0xd] = 0; + param_1[0xe] = &PTR_FUN_007964c8; + FUN_0041b320(0); + param_1[0xe] = &PTR_FUN_007964c8; + param_1[0x2b] = &PTR_FUN_0079646c; + FUN_0041b3b0(0); + param_1[0x2b] = &PTR_FUN_0079646c; + return param_1; +} + + + +// --- FUN_0041c0c0 at 0x0041C0C0 (size: 30) --- + +void * __thiscall FUN_0041c0c0(void *param_1,byte param_2) + +{ + FUN_0041bf80(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0041c220 at 0x0041C220 (size: 30) --- + +uint FUN_0041c220(undefined4 *param_1) + +{ + uint in_EAX; + uint uVar1; + + if ((param_1 != (undefined4 *)0x0) && + (in_EAX = (uint)DAT_00837c68, DAT_00837c68 == (undefined4 *)0x0)) { + DAT_00837c68 = param_1; + /* WARNING: Could not recover jumptable at 0x0041c239. Too many branches */ + /* WARNING: Treating indirect jump as call */ + uVar1 = (**(code **)*param_1)(); + return uVar1; + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_0041c240 at 0x0041C240 (size: 27) --- + +undefined4 FUN_0041c240(void) + +{ + operator_delete(DAT_00837c68); + DAT_00837c68 = (void *)0x0; + return 1; +} + + + +// --- FUN_0041c260 at 0x0041C260 (size: 24) --- + +undefined4 FUN_0041c260(undefined4 param_1) + +{ + undefined4 uVar1; + + if (DAT_00837c68 != (int *)0x0) { + uVar1 = (**(code **)(*DAT_00837c68 + 4))(param_1); + return uVar1; + } + return 0; +} + + + +// --- FUN_0041c280 at 0x0041C280 (size: 24) --- + +undefined4 FUN_0041c280(undefined4 param_1) + +{ + undefined4 uVar1; + + if (DAT_00837c68 != (int *)0x0) { + uVar1 = (**(code **)(*DAT_00837c68 + 8))(param_1); + return uVar1; + } + return 0; +} + + + +// --- FUN_0041c2a0 at 0x0041C2A0 (size: 64) --- + +undefined4 * __thiscall FUN_0041c2a0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007964cc; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0041c2e0 at 0x0041C2E0 (size: 79) --- + +void FUN_0041c2e0(int *param_1) + +{ + undefined4 *puVar1; + LONG LVar2; + + if (DAT_00837c70 != *param_1) { + puVar1 = (undefined4 *)(DAT_00837c70 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(DAT_00837c70 + -0x10)); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + DAT_00837c70 = *param_1; + InterlockedIncrement((LONG *)(DAT_00837c70 + -0x10)); + } + thunk_FUN_0040deb0(&DAT_00837c70,0); + return; +} + + + +// --- FUN_0041c330 at 0x0041C330 (size: 79) --- + +void FUN_0041c330(int *param_1) + +{ + undefined4 *puVar1; + LONG LVar2; + + if (DAT_00837c74 != *param_1) { + puVar1 = (undefined4 *)(DAT_00837c74 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(DAT_00837c74 + -0x10)); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + DAT_00837c74 = *param_1; + InterlockedIncrement((LONG *)(DAT_00837c74 + -0x10)); + } + thunk_FUN_0040deb0(&DAT_00837c74,0); + return; +} + + + +// --- FUN_0041c380 at 0x0041C380 (size: 116) --- + +undefined4 * __fastcall FUN_0041c380(undefined4 *param_1) + +{ + LONG *lpAddend; + + *param_1 = DAT_00837c6c; + param_1[1] = DAT_00837c6c; + param_1[2] = 0; + param_1[3] = 0; + param_1[4] = 0; + param_1[5] = 0; + param_1[6] = 0; + *(undefined1 *)(param_1 + 7) = 0; + *(undefined1 *)((int)param_1 + 0x1d) = 0; + *(undefined1 *)((int)param_1 + 0x1e) = 0; + *(undefined1 *)((int)param_1 + 0x1f) = 0; + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[8] = PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + *(undefined1 *)(param_1 + 9) = 0; + *(undefined1 *)((int)param_1 + 0x25) = 0; + *(undefined1 *)((int)param_1 + 0x26) = 0; + *(undefined1 *)((int)param_1 + 0x27) = 0; + *(undefined1 *)(param_1 + 10) = 0; + *(undefined1 *)((int)param_1 + 0x29) = 0; + *(undefined1 *)((int)param_1 + 0x2a) = 0; + *(undefined1 *)(param_1 + 0xb) = 0; + *(undefined1 *)((int)param_1 + 0x2d) = 0; + param_1[0xc] = 0x10; + param_1[0xd] = 0x10; + return param_1; +} + + + +// --- FUN_0041c400 at 0x0041C400 (size: 114) --- + +uint * FUN_0041c400(uint param_1) + +{ + uint *puVar1; + + if ((DAT_00837cb0 & 1) == 0) { + DAT_00837cb0 = DAT_00837cb0 | 1; + FUN_0041c380(); + _atexit((_func_4879 *)&LAB_00727fc0); + } + puVar1 = *(uint **)(DAT_0081880c + (param_1 % DAT_00818814) * 4); + if (puVar1 != (uint *)0x0) { + while (*puVar1 != param_1) { + puVar1 = (uint *)puVar1[1]; + if (puVar1 == (uint *)0x0) { + return (uint *)&DAT_00837c78; + } + } + if ((puVar1 != (uint *)0x0) && (puVar1 + 2 != (uint *)0x0)) { + return puVar1 + 2; + } + } + return (uint *)&DAT_00837c78; +} + + + +// --- FUN_0041c480 at 0x0041C480 (size: 17) --- + +undefined1 FUN_0041c480(undefined4 param_1) + +{ + int iVar1; + + iVar1 = FUN_0041c400(param_1); + return *(undefined1 *)(iVar1 + 0x1d); +} + + + +// --- FUN_0041c4a0 at 0x0041C4A0 (size: 17) --- + +undefined1 FUN_0041c4a0(undefined4 param_1) + +{ + int iVar1; + + iVar1 = FUN_0041c400(param_1); + return *(undefined1 *)(iVar1 + 0x1e); +} + + + +// --- FUN_0041c4c0 at 0x0041C4C0 (size: 17) --- + +undefined1 FUN_0041c4c0(undefined4 param_1) + +{ + int iVar1; + + iVar1 = FUN_0041c400(param_1); + return *(undefined1 *)(iVar1 + 0x1f); +} + + + +// --- FUN_0041c4e0 at 0x0041C4E0 (size: 17) --- + +undefined1 FUN_0041c4e0(undefined4 param_1) + +{ + int iVar1; + + iVar1 = FUN_0041c400(param_1); + return *(undefined1 *)(iVar1 + 0x29); +} + + + +// --- FUN_0041c500 at 0x0041C500 (size: 17) --- + +int FUN_0041c500(undefined4 param_1) + +{ + int iVar1; + + iVar1 = FUN_0041c400(param_1); + return iVar1 + 0x2c; +} + + + +// --- FUN_0041c520 at 0x0041C520 (size: 332) --- + +undefined1 FUN_0041c520(char *param_1,undefined4 param_2) + +{ + int iVar1; + LONG LVar2; + char *_Str1; + char *_Str1_00; + char *pcVar3; + undefined1 local_9; + char *local_8; + char *local_4; + + iVar1 = FUN_0041c400(param_2); + _Str1 = *(char **)(iVar1 + 0x20); + if (*(int *)(_Str1 + -4) == 1) { + InterlockedIncrement((LONG *)(_Str1 + -0x10)); + } + else { + FUN_0040bbc0(&local_4,(int *)(iVar1 + 0x20)); + _Str1 = local_4; + } + iVar1 = FUN_0041c400(param_2); + _Str1_00 = *(char **)(iVar1 + 0x20); + if (*(int *)(_Str1_00 + -4) == 1) { + InterlockedIncrement((LONG *)(_Str1_00 + -0x10)); + } + else { + FUN_0040bbc0(&local_4,(int *)(iVar1 + 0x20)); + _Str1_00 = local_4; + } + local_8 = param_1; + InterlockedIncrement((LONG *)(param_1 + -0x10)); + thunk_FUN_0040deb0(&local_8,0); + iVar1 = _strnicmp(_Str1,local_8,*(int *)(_Str1 + -4) - 1); + if (iVar1 != 0) { + iVar1 = _strnicmp(_Str1_00,local_8,*(int *)(_Str1_00 + -4) - 1); + local_9 = 0; + if (iVar1 != 0) goto LAB_0041c5ee; + } + local_9 = 1; +LAB_0041c5ee: + pcVar3 = local_8 + -0x14; + LVar2 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar2 == 0) && (pcVar3 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar3)(1); + } + LVar2 = InterlockedDecrement((LONG *)(_Str1_00 + -0x10)); + if ((LVar2 == 0) && (_Str1_00 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(_Str1_00 + -0x14))(1); + } + LVar2 = InterlockedDecrement((LONG *)(_Str1 + -0x10)); + if ((LVar2 == 0) && (_Str1 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(_Str1 + -0x14))(1); + } + LVar2 = InterlockedDecrement((LONG *)(param_1 + -0x10)); + if ((LVar2 == 0) && (param_1 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(param_1 + -0x14))(1); + } + return local_9; +} + + + +// --- FUN_0041c670 at 0x0041C670 (size: 143) --- + +undefined4 * __thiscall FUN_0041c670(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_007964cc; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_0041c700 at 0x0041C700 (size: 271) --- + +void __fastcall FUN_0041c700(int param_1) + +{ + int iVar1; + void *pvVar2; + void *pvVar3; + LONG LVar4; + int *piVar5; + void *pvVar6; + undefined4 *puVar7; + int iVar8; + int local_8; + + iVar1 = *(int *)(param_1 + 0x6c); + do { + if (iVar1 == 0) { + return; + } + piVar5 = *(int **)(param_1 + 100); + while (piVar5 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar5 = *(int **)(param_1 + 100); + pvVar6 = (void *)*piVar5; + goto LAB_0041c741; + } + piVar5 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar5; + } + piVar5 = (int *)0x0; + pvVar6 = (void *)0x0; +LAB_0041c741: + pvVar3 = (void *)*piVar5; + if (pvVar3 == pvVar6) { +LAB_0041c754: + *piVar5 = *(int *)((int)pvVar3 + 4); + } + else { + do { + pvVar2 = pvVar3; + pvVar3 = *(void **)((int)pvVar2 + 4); + } while (pvVar3 != pvVar6); + if (pvVar2 == (void *)0x0) goto LAB_0041c754; + *(undefined4 *)((int)pvVar2 + 4) = *(undefined4 *)((int)pvVar3 + 4); + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + if (pvVar6 != (void *)0x0) { + puVar7 = (undefined4 *)(*(int *)((int)pvVar6 + 0x28) + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*(int *)((int)pvVar6 + 0x28) + -0x10)); + if ((LVar4 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + if (((*(uint *)((int)pvVar6 + 0x14) & 0x80000000) == 0x80000000) && + (iVar1 = *(int *)((int)pvVar6 + 0x10), iVar1 != 0)) { + local_8 = *(int *)(iVar1 + -4); + iVar8 = iVar1 + local_8 * 4; + if (-1 < local_8 + -1) { + do { + piVar5 = (int *)(iVar8 + -4); + iVar8 = iVar8 + -4; + puVar7 = (undefined4 *)(*piVar5 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*piVar5 + -0x10)); + if ((LVar4 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + local_8 = local_8 + -1; + } while (local_8 != 0); + } + operator_delete__((void *)(iVar1 + -4)); + } + operator_delete(pvVar6); + } + iVar1 = *(int *)(param_1 + 0x6c); + } while( true ); +} + + + +// --- FUN_0041c820 at 0x0041C820 (size: 82) --- + +undefined4 * __thiscall FUN_0041c820(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007964d0; + FUN_0041c700(); + param_1[1] = &PTR_FUN_007964cc; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0041c880 at 0x0041C880 (size: 1087) --- + +int FUN_0041c880(uint param_1) + +{ + if (param_1 < 0x14010000) { + if (0x13ffffff < param_1) { + return 0x1d; + } + if (param_1 < 0xe00000e) { + if (0xe00000c < param_1) { + return 0x12; + } + if (param_1 < 0x8000000) { + if (0x5ffffff < param_1) { + return 0xc; + } + if (param_1 < 0x3010000) { + if (0x2ffffff < param_1) { + return 8; + } + if (param_1 < 0x2010000) { + if (0x1ffffff < param_1) { + return 7; + } + if (param_1 < 0x1010000) { + return (-(uint)(param_1 < 0x1000000) & 0xfffffffa) + 6; + } + } + } + else if (param_1 < 0x6000000) { + if (0x4ffffff < param_1) { + return 0xb; + } + if (param_1 < 0x4010000) { + return (-(uint)(param_1 < 0x4000000) & 0xfffffff6) + 10; + } + } + } + else if (param_1 < 0xa010000) { + if (0x9ffffff < param_1) { + return 0xf; + } + if (param_1 < 0x9010000) { + if (0x8ffffff < param_1) { + return 0xe; + } + if (param_1 < 0x8010000) { + return (-(uint)(param_1 < 0x8000000) & 0xfffffff3) + 0xd; + } + } + } + else if (param_1 < 0xe000008) { + if (0xe000006 < param_1) { + return 0x11; + } + if (param_1 < 0xd010000) { + return (-(uint)(param_1 < 0xd000000) & 0xfffffff0) + 0x10; + } + } + } + else if (param_1 < 0xf010000) { + if (0xeffffff < param_1) { + return 0x18; + } + if (param_1 < 0xe000020) { + if (0xe00001e < param_1) { + return 0x15; + } + if (param_1 < 0xe00001f) { + if (0xe00001d < param_1) { + return 0x14; + } + if (param_1 < 0xe00001b) { + return (-(uint)(param_1 < 0xe00001a) & 0xffffffed) + 0x13; + } + } + } + else if (param_1 < 0xe030000) { + if (0xe01ffff < param_1) { + return 0x17; + } + if (param_1 < 0xe000021) { + return (-(uint)(param_1 < 0xe000020) & 0xffffffea) + 0x16; + } + } + } + else if (param_1 < 0x12010000) { + if (0x11ffffff < param_1) { + return 0x1b; + } + if (param_1 < 0x11010000) { + if (0x10ffffff < param_1) { + return 0x1a; + } + if (param_1 < 0x10010000) { + return (-(uint)(param_1 < 0x10000000) & 0xffffffe7) + 0x19; + } + } + } + else if (param_1 < 0x13010000) { + return (-(uint)(param_1 < 0x13000000) & 0xffffffe4) + 0x1c; + } + } + else if (param_1 < 0x26010000) { + if (0x25ffffff < param_1) { + return 0x27; + } + if (param_1 < 0x20010000) { + if (0x1fffffff < param_1) { + return 0x22; + } + if (param_1 < 0x18000000) { + if (0x16ffffff < param_1) { + return 0x20; + } + if (param_1 < 0x17000000) { + if (0x15ffffff < param_1) { + return 0x1f; + } + if (param_1 < 0x16000000) { + return (-(uint)(param_1 < 0x15000000) & 0xffffffe2) + 0x1e; + } + } + } + else if (param_1 < 0x1a000000) { + if (0x18ffffff < param_1) { + return 0x43; + } + if (param_1 < 0x19000000) { + return (-(uint)(param_1 < 0x18000000) & 0xffffffdf) + 0x21; + } + } + } + else if (param_1 < 0x25000000) { + if (0x22ffffff < param_1) { + return 0x25; + } + if (param_1 < 0x23000000) { + if (0x21ffffff < param_1) { + return 0x24; + } + if (param_1 < 0x22000000) { + return (-(uint)(param_1 < 0x21000000) & 0xffffffdd) + 0x23; + } + } + } + else if (param_1 < 0x26000000) { + return (-(uint)(param_1 < 0x25000000) & 0xffffffda) + 0x26; + } + } + else if (param_1 < 0x3a000000) { + if (0x38ffffff < param_1) { + return 0x2d; + } + if (param_1 < 0x32010000) { + if (0x31ffffff < param_1) { + return 0x2a; + } + if (param_1 < 0x31010000) { + if (0x30ffffff < param_1) { + return 0x29; + } + if (param_1 < 0x28000000) { + return (-(uint)(param_1 < 0x27000000) & 0xffffffd8) + 0x28; + } + } + } + else if (param_1 < 0x34010000) { + if (0x33ffffff < param_1) { + return 0x2c; + } + if (param_1 < 0x33010000) { + return (-(uint)(param_1 < 0x33000000) & 0xffffffd5) + 0x2b; + } + } + } + else if (param_1 < 0x42000000) { + if (0x40ffffff < param_1) { + return 0x30; + } + if (param_1 < 0x41000000) { + if (0x40000fff < param_1) { + return 0x2f; + } + if (param_1 < 0x40001000) { + return (-(uint)(param_1 < 0x40000000) & 0xffffffd2) + 0x2e; + } + } + } + else if (param_1 < 0x80000000) { + return (-(uint)(param_1 < 0x78000000) & 0xffffffcf) + 0x31; + } + return 0; +} + + + +// --- FUN_0041ccc0 at 0x0041CCC0 (size: 22) --- + +void __fastcall FUN_0041ccc0(undefined4 *param_1) + +{ + FUN_004080c0(); + _strlwr((char *)*param_1); + return; +} + + + +// --- FUN_0041cce0 at 0x0041CCE0 (size: 5085) --- + +undefined4 FUN_0041cce0(undefined4 param_1) + +{ + char *pcVar1; + uint uVar2; + int iVar3; + LONG LVar4; + char *local_e4; + char *local_e0; + char *local_dc; + char *local_d8; + char *local_d4; + char *local_d0; + char *local_cc; + char *local_c8; + char *local_c4; + char *local_c0; + char *local_bc; + char *local_b8; + char *local_b4; + char *local_b0; + char *local_ac; + char *local_a8; + char *local_a4; + char *local_a0; + char *local_9c; + char *local_98; + char *local_94; + char *local_90; + char *local_8c; + char *local_88; + char *local_84; + char *local_80; + char *local_7c; + char *local_78; + char *local_74; + char *local_70; + char *local_6c; + char *local_68; + char *local_64; + char *local_60; + char *local_5c; + char *local_58; + char *local_54; + char *local_50; + char *local_4c; + char *local_48; + char *local_44; + char *local_40; + char *local_3c; + char *local_38; + char *local_34; + char *local_30; + char *local_2c; + char *local_28; + char *local_24; + char *local_20; + char *local_1c; + char *local_18; + char *local_14; + char *local_10; + char *local_c; + char *local_8; + char *local_4; + + FUN_0040ce00(&local_e4,param_1); + FUN_004080c0(); + _strlwr(local_e4); + pcVar1 = local_e4; + uVar2 = *(uint *)(local_e4 + -8); + if (uVar2 == 0xffffffff) { + uVar2 = FUN_004016b0(local_e4); + *(uint *)(pcVar1 + -8) = uVar2; + } + if (uVar2 < 0x356c4) { + if (uVar2 == 0x356c3) { + FUN_00401340(&DAT_00796734); + iVar3 = _stricmp(local_e4,local_dc); + LVar4 = InterlockedDecrement((LONG *)(local_dc + -0x10)); + if ((LVar4 == 0) && (local_dc + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(local_dc + -0x14))(1); + } + if (iVar3 == 0) { + LVar4 = InterlockedDecrement((LONG *)(local_e4 + -0x10)); + if ((LVar4 == 0) && (local_e4 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(local_e4 + -0x14))(1); + } + return 0x2b; + } + goto LAB_0041e096; + } + if (uVar2 < 0x34c45) { + if (uVar2 == 0x34c44) { + FUN_00401340(&DAT_0079672c); + iVar3 = _stricmp(local_e4,local_18); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x2a; + } + goto LAB_0041e096; + } + if (uVar2 < 0x34a30) { + if (uVar2 == 0x34a2f) { + FUN_00401340(&DAT_00796680); + iVar3 = _stricmp(local_e4,local_c0); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x19; + } + goto LAB_0041e096; + } + if (uVar2 < 0x347ec) { + if (uVar2 == 0x347eb) { + FUN_00401340(&DAT_007965cc); + iVar3 = _stricmp(local_e4,local_d0); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 9; + } + goto LAB_0041e096; + } + if (uVar2 == 0x3539) { + FUN_00401340(&DAT_007966c0); + iVar3 = _stricmp(local_e4,local_38); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x21; + } + goto LAB_0041e096; + } + if (uVar2 == 0x353d) { + FUN_00401340(&DAT_007966bc); + iVar3 = _stricmp(local_e4,local_d8); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x20; + } + goto LAB_0041e096; + } + if (uVar2 != 0x31586) goto LAB_0041e096; + FUN_00401340(&DAT_00796608); + iVar3 = _stricmp(local_e4,local_70); + } + else { + if (uVar2 != 0x34830) { + if (uVar2 == 0x3484d) { + FUN_00401340(&DAT_007965c4); + iVar3 = _stricmp(local_e4,local_c8); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 8; + } + } + else if (uVar2 == 0x34874) { + FUN_00401340(&DAT_00796654); + iVar3 = _stricmp(local_e4,local_68); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x13; + } + } + goto LAB_0041e096; + } + FUN_00401340(&DAT_00796618); + iVar3 = _stricmp(local_e4,local_10); + } + } + else { + if (0x34ab7 < uVar2) { + if (uVar2 == 0x34b93) { + FUN_00401340(&DAT_0079662c); + iVar3 = _stricmp(local_e4,local_a8); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0xe; + } + } + else if (uVar2 == 0x34c40) { + FUN_00401340(&DAT_007966e0); + iVar3 = _stricmp(local_e4,local_58); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x24; + } + } + goto LAB_0041e096; + } + if (uVar2 == 0x34ab7) { + FUN_00401340(&DAT_00796688); + iVar3 = _stricmp(local_e4,local_b0); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x1a; + } + goto LAB_0041e096; + } + if (uVar2 == 0x34a73) { + FUN_00401340(&DAT_00796644); + iVar3 = _stricmp(local_e4,local_30); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x11; + } + goto LAB_0041e096; + } + if (uVar2 == 0x34a99) { + FUN_00401340(&DAT_00796610); + iVar3 = _stricmp(local_e4,local_b8); + } + else { + if (uVar2 != 0x34ab3) goto LAB_0041e096; + FUN_00401340(&DAT_007965f0); + iVar3 = _stricmp(local_e4,local_60); + } + } + } + else { + if (0x35289 < uVar2) { + if (uVar2 < 0x354d5) { + if (uVar2 == 0x354d4) { + FUN_00401340(&DAT_00796664); + iVar3 = _stricmp(local_e4,local_78); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x16; + } + } + else if (uVar2 == 0x3528f) { + FUN_00401340(&DAT_007965a4); + iVar3 = _stricmp(local_e4,local_40); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 4; + } + } + else if (uVar2 == 0x35384) { + FUN_00401340(&DAT_007966b4); + iVar3 = _stricmp(local_e4,local_80); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x1f; + } + } + else if (uVar2 == 0x35472) { + FUN_00401340(&DAT_00796744); + iVar3 = _stricmp(local_e4,local_8); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x2d; + } + } + } + else if (uVar2 == 0x3558a) { + FUN_00401340(&DAT_007965b4); + iVar3 = _stricmp(local_e4,local_e0); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 6; + } + } + else if (uVar2 == 0x3567c) { + FUN_00401340(&DAT_007965d4); + iVar3 = _stricmp(local_e4,local_20); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 10; + } + } + goto LAB_0041e096; + } + if (uVar2 == 0x35289) { + FUN_00401340(&DAT_0079659c); + iVar3 = _stricmp(local_e4,local_88); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 2; + } + goto LAB_0041e096; + } + if (uVar2 < 0x35041) { + if (uVar2 == 0x35040) { + FUN_00401340(&DAT_00796708); + iVar3 = _stricmp(local_e4,local_28); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x26; + } + goto LAB_0041e096; + } + if (uVar2 == 0x34c56) { + FUN_00401340(&DAT_0079663c); + iVar3 = _stricmp(local_e4,local_98); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x10; + } + goto LAB_0041e096; + } + if (uVar2 == 0x34f83) { + FUN_00401340(&DAT_0079664c); + iVar3 = _stricmp(local_e4,local_50); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x12; + } + goto LAB_0041e096; + } + if (uVar2 != 0x34fc6) goto LAB_0041e096; + FUN_00401340(&DAT_00796600); + iVar3 = _stricmp(local_e4,local_a0); + } + else { + if (uVar2 == 0x35053) { + FUN_00401340(&DAT_007965ac); + iVar3 = _stricmp(local_e4,local_48); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 5; + } + goto LAB_0041e096; + } + if (uVar2 != 0x35167) goto LAB_0041e096; + FUN_00401340(&DAT_007965e8); + iVar3 = _stricmp(local_e4,local_90); + } + } + } + else { + if (0x34b040 < uVar2) { + if (uVar2 < 0xaba5baf) { + if (uVar2 != 0xaba5bae) { + if (0x4657c30 < uVar2) { + if (uVar2 == 0x51d03b0) { + FUN_00401340(".keymap"); + iVar3 = _stricmp(local_e4,local_3c); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x1d; + } + } + else if (uVar2 == 0xa778f2c) { + FUN_00401340(".font_local"); + iVar3 = _stricmp(local_e4,local_44); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x2f; + } + } + goto LAB_0041e096; + } + if (uVar2 == 0x4657c30) { + FUN_00401340(".monprop"); + iVar3 = _stricmp(local_e4,local_4c); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x17; + } + goto LAB_0041e096; + } + if (uVar2 == 0x34d654) { + FUN_00401340(".font"); + iVar3 = _stricmp(local_e4,local_54); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x2e; + } + goto LAB_0041e096; + } + if (uVar2 != 0x357384) { + if (uVar2 == 0x35a795f) { + FUN_00401340(".taboo"); + iVar3 = _stricmp(local_e4,local_64); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x14; + } + } + goto LAB_0041e096; + } + FUN_00401340(".pmat"); + iVar3 = _stricmp(local_e4,local_5c); +LAB_0041dc86: + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x31; + } + goto LAB_0041e096; + } + FUN_00401340(".stt_bin"); + iVar3 = _stricmp(local_e4,local_34); + } + else { + if (uVar2 < 0xafeb0d9) { + if (uVar2 == 0xafeb0d8) { + FUN_00401340(".rendermesh"); + iVar3 = _stricmp(local_e4,local_14); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x43; + } + } + else if (uVar2 == 0xac8c4c5) { + FUN_00401340(".surface"); + iVar3 = _stricmp(local_e4,local_1c); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0xd; + } + } + else if (uVar2 == 0xacf8915) { + FUN_00401340(".rtexture"); + iVar3 = _stricmp(local_e4,local_24); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x1e; + } + } + else if (uVar2 == 0xacfbfd5) { + FUN_00401340(".texture"); + iVar3 = _stricmp(local_e4,local_2c); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0xb; + } + } + goto LAB_0041e096; + } + if (uVar2 == 0xb071420) { + FUN_00401340(".actionmap"); + iVar3 = _stricmp(local_e4,local_4); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x27; + } + goto LAB_0041e096; + } + if (uVar2 != 0xba55039) goto LAB_0041e096; + FUN_00401340(".stt_ansi"); + iVar3 = _stricmp(local_e4,local_c); + } +LAB_0041e017: + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x25; + } + goto LAB_0041e096; + } + if (uVar2 == 0x34b040) { + FUN_00401340(".dimp"); + iVar3 = _stricmp(local_e4,local_6c); + LVar4 = InterlockedDecrement((LONG *)(local_6c + -0x10)); + if ((LVar4 == 0) && (local_6c + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(local_6c + -0x14))(1); + } + if (iVar3 == 0) { + FUN_004011b0(); + return 0x28; + } + goto LAB_0041e096; + } + if (uVar2 < 0x35aaa) { + if (uVar2 == 0x35aa9) { + FUN_00401340(&DAT_00796760); + iVar3 = _stricmp(local_e4,local_a4); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x30; + } + } + else if (uVar2 < 0x3599f) { + if (uVar2 == 0x3599e) { + FUN_00401340(&DAT_00796690); + iVar3 = _stricmp(local_e4,local_bc); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x1b; + } + } + else if (uVar2 == 0x356c4) { + FUN_00401340(&DAT_0079673c); + iVar3 = _stricmp(local_e4,local_c4); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x2c; + } + } + else if (uVar2 == 0x357a4) { + FUN_00401340(&DAT_00796678); + iVar3 = _stricmp(local_e4,local_cc); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x18; + } + } + else if (uVar2 == 0x358de) { + FUN_00401340(&DAT_00796698); + iVar3 = _stricmp(local_e4,local_d4); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x1c; + } + } + } + else if (uVar2 == 0x359c4) { + FUN_00401340(&DAT_007965bc); + iVar3 = _stricmp(local_e4,local_ac); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 7; + } + } + else if (uVar2 == 0x35aa2) { + FUN_00401340(&DAT_007966d0); + iVar3 = _stricmp(local_e4,local_b4); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x22; + } + } + goto LAB_0041e096; + } + if (0x35bfc < uVar2) { + if (uVar2 == 0x35d86) { + FUN_00401340(&DAT_00796634); + iVar3 = _stricmp(local_e4,local_74); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0xf; + } + goto LAB_0041e096; + } + if (uVar2 != 0x34a963) goto LAB_0041e096; + FUN_00401340(".dbpc"); + iVar3 = _stricmp(local_e4,local_7c); + goto LAB_0041dc86; + } + if (uVar2 == 0x35bfc) { + FUN_00401340(&DAT_007966d8); + iVar3 = _stricmp(local_e4,local_84); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x23; + } + goto LAB_0041e096; + } + if (uVar2 == 0x35ab2) { + FUN_00401340(&DAT_00796724); + iVar3 = _stricmp(local_e4,local_8c); + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0x29; + } + goto LAB_0041e096; + } + if (uVar2 == 0x35ab4) { + FUN_00401340(&DAT_007966e8); + iVar3 = _stricmp(local_e4,local_94); + goto LAB_0041e017; + } + if (uVar2 != 0x35ad1) goto LAB_0041e096; + FUN_00401340(&DAT_007965f8); + iVar3 = _stricmp(local_e4,local_9c); + } + FUN_004011b0(); + if (iVar3 == 0) { + FUN_004011b0(); + return 0xc; + } +LAB_0041e096: + LVar4 = InterlockedDecrement((LONG *)(local_e4 + -0x10)); + if ((LVar4 == 0) && (local_e4 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(local_e4 + -0x14))(1); + } + return 0; +} + + + +// --- FUN_0041e0c0 at 0x0041E0C0 (size: 4464) --- + +undefined1 FUN_0041e0c0(undefined4 *param_1,undefined4 *param_2) + +{ + char *_String; + undefined *puVar1; + int iVar2; + LONG LVar3; + undefined1 uVar4; + char *local_c8; + char *local_c4; + char *local_c0; + char *local_bc; + char *local_b8; + char *local_b4; + char *local_b0; + char *local_ac; + char *local_a8; + char *local_a4; + char *local_a0; + char *local_9c; + char *local_98; + char *local_94; + char *local_90; + char *local_8c; + char *local_88; + char *local_84; + char *local_80; + char *local_7c; + char *local_78; + char *local_74; + char *local_70; + char *local_6c; + char *local_68; + char *local_64; + char *local_60; + char *local_5c; + char *local_58; + char *local_54; + char *local_50; + char *local_4c; + char *local_48; + char *local_44; + char *local_40; + char *local_3c; + char *local_38; + char *local_34; + char *local_30; + char *local_2c; + char *local_28; + char *local_24; + char *local_20; + char *local_1c; + char *local_18; + char *local_14; + char *local_10; + char *local_c; + char *local_8; + char *local_4; + + _String = (char *)*param_1; + uVar4 = 0; + InterlockedIncrement((LONG *)(_String + -0x10)); + FUN_004080c0(); + _strlwr(_String); + puVar1 = *(undefined **)(_String + -8); + if (puVar1 == (undefined *)0xffffffff) { + puVar1 = (undefined *)FUN_004016b0(_String); + *(undefined **)(_String + -8) = puVar1; + } + if (puVar1 < (undefined *)0x6779a50) { + if (puVar1 == (undefined *)0x6779a4f) { + FUN_00401340("DEGRADEINFO"); + iVar2 = _stricmp(_String,local_c4); + LVar3 = InterlockedDecrement((LONG *)(local_c4 + -0x10)); + if ((LVar3 == 0) && (local_c4 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(local_c4 + -0x14))(1); + } + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x1a; + } + else if (puVar1 < (undefined *)0x29374e5) { + if (puVar1 == (undefined *)0x29374e4) { + FUN_00401340("PHYSICS_SCRIPT"); + iVar2 = _stricmp(_String,local_28); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x2b; + } + else if (&DAT_006209de < puVar1) { + if (puVar1 < (undefined *)0xe658ad) { + if (puVar1 == (undefined *)0xe658ac) { + FUN_00401340("RENDERMATERIAL"); + iVar2 = _stricmp(_String,local_a0); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x1f; + } + else if (puVar1 == (undefined *)0xc26824) { + FUN_00401340("PAL_SET"); + iVar2 = _stricmp(_String,local_18); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x18; + } + else { + if (puVar1 != (undefined *)0xc2ca45) goto LAB_0041f205; + FUN_00401340("PALETTE"); + iVar2 = _stricmp(_String,local_a8); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 10; + } + } + else if (puVar1 == (undefined *)0x1ef0bc0) { + FUN_00401340("SETUP"); + iVar2 = _stricmp(_String,local_98); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 7; + } + else { + if (puVar1 != (undefined *)0x1ef5c45) goto LAB_0041f205; + FUN_00401340("SCENE"); + iVar2 = _stricmp(_String,local_50); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x1b; + } + } + else if (puVar1 == &DAT_006209de) { + FUN_00401340("INSTANTIATION"); + iVar2 = _stricmp(_String,local_58); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 5; + } + else if (puVar1 < (undefined *)0x1dba55) { + if (puVar1 == (undefined *)0x1dba54) { + FUN_00401340(&DAT_007969dc); + iVar2 = _stricmp(_String,local_b8); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x2e; + } + else if (puVar1 == (undefined *)0x1e449) { + FUN_00401340(&DAT_007969e4); + iVar2 = _stricmp(_String,local_60); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 2; + } + else if (puVar1 == (undefined *)0x1e44f) { + FUN_00401340(&DAT_007969e8); + iVar2 = _stricmp(_String,local_c0); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 4; + } + else { + if (puVar1 != (undefined *)0x1d28fd) goto LAB_0041f205; + FUN_00401340(&DAT_007969ec); + iVar2 = _stricmp(_String,local_68); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 8; + } + } + else if (puVar1 == (undefined *)0x1df82c) { + FUN_00401340(&DAT_007969cc); + iVar2 = _stricmp(_String,local_b0); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 3; + } + else { + if (puVar1 != (undefined *)0x1eb4c5) goto LAB_0041f205; + FUN_00401340(&DAT_007969d4); + iVar2 = _stricmp(_String,local_30); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0xf; + } + } + else if (puVar1 < (undefined *)0x4448256) { + if (puVar1 == (undefined *)0x4448255) { + FUN_00401340("NAME_FILTER_TABLE"); + iVar2 = _stricmp(_String,local_78); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x16; + } + else if (puVar1 < (undefined *)0x3cb6a8a) { + if (puVar1 == (undefined *)0x3cb6a89) { + FUN_00401340("MASTER_PROPERTY"); + iVar2 = _stricmp(_String,local_8); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x2d; + } + else if (puVar1 == (undefined *)0x2e89502) { + FUN_00401340("PARTICLE_EMITTER"); + iVar2 = _stricmp(_String,local_88); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x2a; + } + else if (puVar1 == (undefined *)0x3ad38f5) { + FUN_00401340("STRING_STATE"); + iVar2 = _stricmp(_String,local_48); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x30; + } + else { + if (puVar1 != (undefined *)0x3ade975) goto LAB_0041f205; + FUN_00401340("STRING_TABLE"); + iVar2 = _stricmp(_String,local_90); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x25; + } + } + else if (puVar1 == (undefined *)0x3cdb295) { + FUN_00401340("CHAT_POSE_TABLE"); + iVar2 = _stricmp(_String,local_40); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x11; + } + else { + if (puVar1 != (undefined *)0x428f205) goto LAB_0041f205; + FUN_00401340("FILE2ID_TABLE"); + iVar2 = _stricmp(_String,local_80); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x15; + } + } + else if (puVar1 < (undefined *)0x5e6eaf3) { + if (puVar1 == (undefined *)0x5e6eaf2) { + FUN_00401340("ENUM_MAPPER"); + iVar2 = _stricmp(_String,local_38); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x24; + } + else if (puVar1 == (undefined *)0x44b11f5) { + FUN_00401340("RENDERTEXTURE"); + iVar2 = _stricmp(_String,local_70); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x1e; + } + else { + if (puVar1 != (undefined *)0x44c6ae5) goto LAB_0041f205; + FUN_00401340("RENDERSURFACE"); + iVar2 = _stricmp(_String,local_20); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0xc; + } + } + else if (puVar1 == (undefined *)0x625b562) { + FUN_00401340("DID_MAPPER"); + iVar2 = _stricmp(_String,local_10); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x26; + } + else { + if (puVar1 != (undefined *)0x6292bf4) goto LAB_0041f205; + FUN_00401340("UI_LAYOUT"); + iVar2 = _stricmp(_String,local_c8); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x23; + } + } + else if (puVar1 < (undefined *)0xcf90dc6) { + if (puVar1 == (undefined *)0xcf90dc5) { + FUN_00401340("PHYSICS_SCRIPT_TABLE"); + iVar2 = _stricmp(_String,local_5c); + LVar3 = InterlockedDecrement((LONG *)(local_5c + -0x10)); + if ((LVar3 == 0) && (local_5c + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(local_5c + -0x14))(1); + } + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x2c; + } + else if (puVar1 < (undefined *)0xa4779dc) { + if (puVar1 == (undefined *)0xa4779db) { + FUN_00401340("LAND_BLOCK"); + iVar2 = _stricmp(_String,local_8c); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 1; + } + else if (puVar1 < (undefined *)0x93b52f6) { + if (puVar1 == (undefined *)0x93b52f5) { + FUN_00401340("MATERIALINSTANCE"); + iVar2 = _stricmp(_String,local_a4); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x21; + } + else if (puVar1 == (undefined *)0x686c245) { + FUN_00401340("TABOO_TABLE"); + iVar2 = _stricmp(_String,local_ac); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x14; + } + else if (puVar1 == (undefined *)0x730e209) { + FUN_00401340("OBJECT_HIERARCHY"); + iVar2 = _stricmp(_String,local_b4); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x12; + } + else { + if (puVar1 != (undefined *)0x8d7da23) goto LAB_0041f205; + FUN_00401340("MONITOREDPROPERTIES"); + iVar2 = _stricmp(_String,local_bc); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x17; + } + } + else if (puVar1 == (undefined *)0x93ef862) { + FUN_00401340("MATERIALMODIFIER"); + iVar2 = _stricmp(_String,local_94); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x20; + } + else { + if (puVar1 != (undefined *)0xa43db85) goto LAB_0041f205; + FUN_00401340("SURFACETEXTURE"); + iVar2 = _stricmp(_String,local_9c); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0xb; + } + } + else if (puVar1 < (undefined *)0xb05a2e1) { + if (puVar1 == (undefined *)0xb05a2e0) { + FUN_00401340("ACTIONMAP"); + iVar2 = _stricmp(_String,local_74); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x27; + } + else if (puVar1 == (undefined *)0xa60e32c) { + FUN_00401340("FONT_LOCAL"); + iVar2 = _stricmp(_String,local_7c); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x2f; + } + else { + if (puVar1 != (undefined *)0xa9ba754) goto LAB_0041f205; + FUN_00401340("ENVIRONMENT"); + iVar2 = _stricmp(_String,local_84); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x10; + } + } + else if (puVar1 == (undefined *)0xb0cd6b3) { + FUN_00401340("DBPROPERTIES"); + iVar2 = _stricmp(_String,local_64); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x31; + } + else { + if (puVar1 != (undefined *)0xc08c675) goto LAB_0041f205; + FUN_00401340("SURFACE"); + iVar2 = _stricmp(_String,local_6c); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0xd; + } + } + else if (puVar1 < (undefined *)0xe710391) { + if (puVar1 == (undefined *)0xe710390) { + FUN_00401340("KEYMAP"); + iVar2 = _stricmp(_String,local_2c); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x1d; + } + else if (puVar1 < (undefined *)0xdb1f59b) { + if (puVar1 == (undefined *)0xdb1f59a) { + FUN_00401340("GFXOBJ"); + iVar2 = _stricmp(_String,local_44); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 6; + } + else if (puVar1 == (undefined *)0xd4683bb) { + FUN_00401340("ANIMATION_HOOK"); + iVar2 = _stricmp(_String,local_4c); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 9; + } + else { + if (puVar1 != (undefined *)0xdacb838) goto LAB_0041f205; + FUN_00401340("RENDER_MESH"); + iVar2 = _stricmp(_String,local_54); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x43; + } + } + else if (puVar1 == (undefined *)0xe1c0432) { + FUN_00401340("DUAL_DID_MAPPER"); + iVar2 = _stricmp(_String,local_34); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x28; + } + else { + if (puVar1 != (undefined *)0xe267935) goto LAB_0041f205; + FUN_00401340("MTABLE"); + iVar2 = _stricmp(_String,local_3c); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0xe; + } + } + else if (puVar1 < (undefined *)0xec79058) { + if (puVar1 == (undefined *)0xec79057) { + FUN_00401340("STRING"); + iVar2 = _stricmp(_String,local_14); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x29; + } + else if (puVar1 == (undefined *)0xebaa971) { + FUN_00401340("BADDATA"); + iVar2 = _stricmp(_String,local_1c); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x13; + } + else { + if (puVar1 != (undefined *)0xec67935) goto LAB_0041f205; + FUN_00401340("STABLE"); + iVar2 = _stricmp(_String,local_24); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x22; + } + } + else if (puVar1 == (undefined *)0xee7e04e) { + FUN_00401340("REGION"); + iVar2 = _stricmp(_String,local_4); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x1c; + } + else { + if (puVar1 != (undefined *)0xf6af247) goto LAB_0041f205; + FUN_00401340("CLOTHING"); + iVar2 = _stricmp(_String,local_c); + FUN_004011b0(); + if (iVar2 != 0) goto LAB_0041f205; + *param_2 = 0x19; + } + uVar4 = 1; +LAB_0041f205: + LVar3 = InterlockedDecrement((LONG *)(_String + -0x10)); + if ((LVar3 == 0) && (_String + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(_String + -0x14))(1); + } + return uVar4; +} + + + +// --- FUN_0041f230 at 0x0041F230 (size: 319) --- + +int * __thiscall FUN_0041f230(int *param_1,undefined4 *param_2) + +{ + LONG *lpAddend; + int *piVar1; + int iVar2; + undefined *puVar3; + undefined *puVar4; + char cVar5; + LONG LVar6; + uint uVar7; + int *piVar8; + int *piVar9; + + if ((param_1[1] & 0x7fffffffU) < (param_2[1] & 0x7fffffff)) { + param_1[2] = 0; + cVar5 = FUN_004082c0(param_2[1] & 0x7fffffff); + if (cVar5 == '\0') { + return param_1; + } + } + piVar8 = (int *)*param_1; + piVar9 = (int *)*param_2; + piVar1 = piVar9 + param_2[2]; + for (; piVar9 < piVar1; piVar9 = piVar9 + 1) { + iVar2 = *piVar8; + if (iVar2 != *piVar9) { + LVar6 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar2 = *piVar9; + *piVar8 = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + } + piVar8 = piVar8 + 1; + } + uVar7 = param_2[2]; + if (uVar7 < (uint)param_1[2]) { + do { + puVar4 = PTR_DAT_00818344; + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + InterlockedIncrement(lpAddend); + piVar1 = (int *)(*param_1 + uVar7 * 4); + puVar3 = (undefined *)*piVar1; + if (puVar3 != puVar4) { + LVar6 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar3 + -0x14))(1); + } + *piVar1 = (int)puVar4; + InterlockedIncrement(lpAddend); + } + LVar6 = InterlockedDecrement((LONG *)(puVar4 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar4 + -0x14))(1); + } + uVar7 = uVar7 + 1; + } while (uVar7 < (uint)param_1[2]); + } + param_1[2] = param_2[2]; + return param_1; +} + + + +// --- FUN_0041f370 at 0x0041F370 (size: 973) --- + +undefined1 FUN_0041f370(undefined4 param_1) + +{ + undefined1 uVar1; + + uVar1 = 0; + switch(param_1) { + case 1: + FUN_00405000("LAND_BLOCK"); + return 1; + case 2: + FUN_00405000(&DAT_007969e4); + return 1; + case 3: + FUN_00405000(&DAT_007969cc); + return 1; + case 4: + FUN_00405000(&DAT_007969e8); + return 1; + case 5: + FUN_00405000("INSTANTIATION"); + return 1; + case 6: + FUN_00405000("GFXOBJ"); + return 1; + case 7: + FUN_00405000("SETUP"); + return 1; + case 8: + FUN_00405000(&DAT_007969ec); + return 1; + case 9: + FUN_00405000("ANIMATION_HOOK"); + return 1; + case 10: + FUN_00405000("PALETTE"); + return 1; + case 0xb: + FUN_00405000("SURFACETEXTURE"); + return 1; + case 0xc: + FUN_00405000("RENDERSURFACE"); + return 1; + case 0xd: + FUN_00405000("SURFACE"); + return 1; + case 0xe: + FUN_00405000("MTABLE"); + return 1; + case 0xf: + FUN_00405000(&DAT_007969d4); + return 1; + case 0x10: + FUN_00405000("ENVIRONMENT"); + return 1; + case 0x11: + FUN_00405000("CHAT_POSE_TABLE"); + return 1; + case 0x12: + FUN_00405000("OBJECT_HIERARCHY"); + return 1; + case 0x13: + FUN_00405000("BADDATA"); + return 1; + case 0x14: + FUN_00405000("TABOO_TABLE"); + return 1; + case 0x15: + FUN_00405000("FILE2ID_TABLE"); + return 1; + case 0x16: + FUN_00405000("NAME_FILTER_TABLE"); + return 1; + case 0x17: + FUN_00405000("MONITOREDPROPERTIES"); + return 1; + case 0x18: + FUN_00405000("PAL_SET"); + return 1; + case 0x19: + FUN_00405000("CLOTHING"); + return 1; + case 0x1a: + FUN_00405000("DEGRADEINFO"); + return 1; + case 0x1b: + FUN_00405000("SCENE"); + return 1; + case 0x1c: + FUN_00405000("REGION"); + return 1; + case 0x1d: + FUN_00405000("KEYMAP"); + return 1; + case 0x1e: + FUN_00405000("RENDERTEXTURE"); + return 1; + case 0x1f: + FUN_00405000("RENDERMATERIAL"); + return 1; + case 0x20: + FUN_00405000("MATERIALMODIFIER"); + return 1; + case 0x21: + FUN_00405000("MATERIALINSTANCE"); + return 1; + case 0x22: + FUN_00405000("STABLE"); + return 1; + case 0x23: + FUN_00405000("UI_LAYOUT"); + return 1; + case 0x24: + FUN_00405000("ENUM_MAPPER"); + return 1; + case 0x25: + FUN_00405000("STRING_TABLE"); + return 1; + case 0x26: + FUN_00405000("DID_MAPPER"); + return 1; + case 0x27: + FUN_00405000("ACTIONMAP"); + return 1; + case 0x28: + FUN_00405000("DUAL_DID_MAPPER"); + return 1; + case 0x29: + FUN_00405000("STRING"); + return 1; + case 0x2a: + FUN_00405000("PARTICLE_EMITTER"); + return 1; + case 0x2b: + FUN_00405000("PHYSICS_SCRIPT"); + return 1; + case 0x2c: + FUN_00405000("PHYSICS_SCRIPT_TABLE"); + return 1; + case 0x2d: + FUN_00405000("MASTER_PROPERTY"); + return 1; + case 0x2e: + FUN_00405000(&DAT_007969dc); + return 1; + case 0x2f: + FUN_00405000("FONT_LOCAL"); + return 1; + case 0x30: + FUN_00405000("STRING_STATE"); + return 1; + case 0x31: + FUN_00405000("DBPROPERTIES"); + uVar1 = 1; + break; + case 0x43: + FUN_00405000("RENDER_MESH"); + return 1; + } + return uVar1; +} + + + +// --- FUN_0041f850 at 0x0041F850 (size: 163) --- + +undefined4 * __thiscall FUN_0041f850(undefined4 *param_1,undefined4 *param_2) + +{ + int iVar1; + + *param_1 = *param_2; + param_1[1] = param_2[1]; + param_1[2] = 0; + param_1[3] = 0; + param_1[4] = 0; + FUN_0041f230(param_2 + 2); + param_1[5] = param_2[5]; + param_1[6] = param_2[6]; + *(undefined1 *)(param_1 + 7) = *(undefined1 *)(param_2 + 7); + *(undefined1 *)((int)param_1 + 0x1d) = *(undefined1 *)((int)param_2 + 0x1d); + *(undefined1 *)((int)param_1 + 0x1e) = *(undefined1 *)((int)param_2 + 0x1e); + *(undefined1 *)((int)param_1 + 0x1f) = *(undefined1 *)((int)param_2 + 0x1f); + iVar1 = param_2[8]; + param_1[8] = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + *(undefined1 *)(param_1 + 9) = *(undefined1 *)(param_2 + 9); + *(undefined1 *)((int)param_1 + 0x25) = *(undefined1 *)((int)param_2 + 0x25); + *(undefined1 *)((int)param_1 + 0x26) = *(undefined1 *)((int)param_2 + 0x26); + *(undefined1 *)((int)param_1 + 0x27) = *(undefined1 *)((int)param_2 + 0x27); + *(undefined1 *)(param_1 + 10) = *(undefined1 *)(param_2 + 10); + *(undefined1 *)((int)param_1 + 0x29) = *(undefined1 *)((int)param_2 + 0x29); + *(undefined1 *)((int)param_1 + 0x2a) = *(undefined1 *)((int)param_2 + 0x2a); + param_1[0xb] = param_2[0xb]; + param_1[0xc] = param_2[0xc]; + param_1[0xd] = param_2[0xd]; + return param_1; +} + + + +// --- FUN_0041f900 at 0x0041F900 (size: 153) --- + +undefined4 FUN_0041f900(undefined4 *param_1,undefined4 param_2) + +{ + char cVar1; + undefined4 *puVar2; + LONG LVar3; + undefined4 *puVar4; + + puVar2 = (undefined4 *)FUN_005df0f5(0x40); + if (puVar2 == (undefined4 *)0x0) { + puVar2 = (undefined4 *)0x0; + } + else { + *puVar2 = *param_1; + puVar2[1] = 0; + FUN_0041f850(param_2); + } + cVar1 = FUN_0042bd40(puVar2); + if (cVar1 == '\0') { + if (puVar2 != (undefined4 *)0x0) { + puVar4 = (undefined4 *)(puVar2[10] + -0x14); + LVar3 = InterlockedDecrement((LONG *)(puVar2[10] + -0x10)); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + if (((puVar2[5] & 0x80000000) == 0x80000000) && (puVar2[4] != 0)) { + FUN_00407920(3); + } + operator_delete(puVar2); + } + return 0; + } + return 1; +} + + + +// --- FUN_0041f9a0 at 0x0041F9A0 (size: 9998) --- + +/* WARNING: Type propagation algorithm not settling */ + +undefined4 FUN_0041f9a0(void) + +{ + LONG LVar1; + undefined4 *puVar2; + int local_3c [4]; + uint uStack_2c; + undefined4 local_28; + undefined4 local_24; + undefined4 local_20; + undefined1 local_1c; + undefined1 local_1b; + undefined1 local_1a; + undefined1 local_19; + int local_18; + undefined1 local_14; + undefined1 local_13; + undefined1 local_12; + undefined1 local_11; + undefined1 local_10; + undefined1 local_f; + undefined1 local_e; + undefined1 local_c; + undefined1 local_b; + undefined4 local_8; + undefined4 local_4; + + FUN_0041c380(); + local_3c[1] = 0; + local_3c[2] = 0; + local_24 = 1; + local_20 = 2; + local_1c = 0; + local_1b = 0; + local_1a = 1; + local_19 = 0; + FUN_00405000(&DAT_007938af); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x15; + local_4 = 0x90; + local_e = 0; + FUN_0041f900(&DAT_007964d4,local_3c + 1); + local_28 = 0; + local_3c[1] = 0; + local_3c[2] = 0; + FUN_00401340(&DAT_0079659c); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 2; + local_1c = 1; + local_1b = 0; + local_1a = 1; + local_19 = 0; + FUN_00405000(&DAT_00796b18); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x15; + local_4 = 0x90; + local_e = 0; + FUN_0041f900(&DAT_007964d8,local_3c + 1); + local_28 = 0; + local_3c[1] = 0; + local_3c[2] = 0; + local_24 = 1; + local_20 = 2; + local_1c = 0; + local_1b = 0; + local_1a = 1; + local_19 = 0; + FUN_00405000(&DAT_007938af); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x14; + local_4 = 0x90; + local_e = 0; + FUN_0041f900(&DAT_007964dc,local_3c + 1); + local_28 = 0; + local_3c[1] = 0; + local_3c[2] = 0; + FUN_00401340(&DAT_007965a4); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 2; + local_1c = 1; + local_1b = 0; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796b14); + local_14 = 0; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_007964e0,local_3c + 1); + local_28 = 0; + local_3c[1] = 0; + local_3c[2] = 0; + FUN_00401340(&DAT_007965ac); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 2; + local_1c = 1; + local_1b = 0; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796b10); + local_14 = 0; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_007964e4,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x1000000; + local_3c[2] = 0x100ffff; + FUN_00401340(&DAT_007965b4); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("gfxobj"); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 100; + local_4 = 200; + local_e = 0; + FUN_0041f900(&DAT_007964e8,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x2000000; + local_3c[2] = 0x200ffff; + FUN_00401340(&DAT_007965bc); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("setup"); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x19; + local_4 = 100; + local_e = 0; + FUN_0041f900(&DAT_007964ec,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x3000000; + local_3c[2] = 0x300ffff; + FUN_00401340(&DAT_007965c4); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796af8); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x14; + local_4 = 0x50; + local_e = 0; + FUN_0041f900(&DAT_007964f0,local_3c + 1); + local_28 = 0; + local_3c[1] = 0; + local_3c[2] = 0; + FUN_00401340(&DAT_007965cc); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 0; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796af4); + local_14 = 0; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_007964f4,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x4000000; + local_3c[2] = 0x400ffff; + FUN_00401340(&DAT_007965d4); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("palette"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x3c; + local_4 = 100; + local_e = 0; + FUN_0041f900(&DAT_007964f8,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x5000000; + local_3c[2] = 0x5ffffff; + FUN_00401340(".texture"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("textures"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 1; + local_c = 0; + local_b = 1; + local_8 = 100; + local_4 = 400; + local_e = 0; + FUN_0041f900(&DAT_007964fc,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x6000000; + local_3c[2] = 0x7ffffff; + FUN_00401340(&DAT_007965e8); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(&DAT_007965f0); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(&DAT_007965f8); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(&DAT_00796600); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(&DAT_00796608); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(&DAT_00796610); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(&DAT_00796618); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("surfaces"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 1; + local_c = 0; + local_b = 1; + local_8 = 100; + local_4 = 400; + local_e = 0; + FUN_0041f900(&DAT_00796500,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x8000000; + local_3c[2] = 0x800ffff; + FUN_00401340(".surface"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("materials"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x32; + local_4 = 200; + local_e = 0; + FUN_0041f900(&DAT_00796504,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x9000000; + local_3c[2] = 0x900ffff; + FUN_00401340(&DAT_0079662c); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796ac4); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_00796508,local_3c + 1); + local_28 = 0; + local_3c[1] = 0xa000000; + local_3c[2] = 0xa00ffff; + FUN_00401340(&DAT_00796634); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("sound"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_0079650c,local_3c + 1); + local_28 = 0; + local_3c[1] = 0xd000000; + local_3c[2] = 0xd00ffff; + FUN_00401340(&DAT_0079663c); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796ab8); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_00796510,local_3c + 1); + local_28 = 0; + local_3c[1] = 0xe000007; + local_3c[2] = 0xe000007; + FUN_00401340(&DAT_00796644); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796ab4); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 0; + local_8 = 1; + local_4 = 1; + local_e = 0; + FUN_0041f900(&DAT_00796514,local_3c + 1); + local_28 = 0; + local_3c[1] = 0xe00000d; + local_3c[2] = 0xe00000d; + FUN_00401340(&DAT_0079664c); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("DungeonCfgs"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_00796518,local_3c + 1); + local_28 = 0; + local_3c[1] = 0xe00001a; + local_3c[2] = 0xe00001a; + FUN_00401340(&DAT_00796654); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("weenie"); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 0; + local_8 = 1; + local_4 = 1; + local_e = 0; + FUN_0041f900(&DAT_0079651c,local_3c + 1); + local_28 = 0; + local_3c[1] = 0xe00001e; + local_3c[2] = 0xe00001e; + FUN_00401340(".taboo"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("weenie"); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_00796520,local_3c + 1); + local_28 = 0; + local_3c[1] = 0xe00001f; + local_3c[2] = 0xe00001f; + local_24 = 1; + local_20 = 1; + local_1c = 0; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_007938af); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_00796524,local_3c + 1); + local_28 = 0; + local_3c[1] = 0xe000020; + local_3c[2] = 0xe000020; + FUN_00401340(&DAT_00796664); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("namefilter"); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_00796528,local_3c + 1); + local_28 = 0; + local_3c[1] = 0xe020000; + local_3c[2] = 0xe02ffff; + FUN_00401340(".monprop"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("properties"); + local_14 = 0; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_0079652c,local_3c + 1); + local_28 = 0; + local_3c[1] = 0xf000000; + local_3c[2] = 0xf00ffff; + FUN_00401340(&DAT_00796678); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("palset"); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 10; + local_4 = 0x28; + local_e = 0; + FUN_0041f900(&DAT_00796530,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x10000000; + local_3c[2] = 0x1000ffff; + FUN_00401340(&DAT_00796680); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("clothing"); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x14; + local_4 = 0x28; + local_e = 0; + FUN_0041f900(&DAT_00796534,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x11000000; + local_3c[2] = 0x1100ffff; + FUN_00401340(&DAT_00796688); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796a70); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x50; + local_4 = 200; + local_e = 0; + FUN_0041f900(&DAT_00796538,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x12000000; + local_3c[2] = 0x1200ffff; + FUN_00401340(&DAT_00796690); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796a6c); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x19; + local_4 = 100; + local_e = 0; + FUN_0041f900(&DAT_0079653c,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x13000000; + local_3c[2] = 0x1300ffff; + FUN_00401340(&DAT_00796698); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("landscape"); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 1; + FUN_0041f900(&DAT_00796540,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x14000000; + local_3c[2] = 0x1400ffff; + FUN_00401340(".keymap"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("keymap"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_00796544,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x15000000; + local_3c[2] = 0x15ffffff; + FUN_00401340(".rtexture"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("textures"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 1; + local_c = 0; + local_b = 1; + local_8 = 0x80; + local_4 = 0x100; + local_e = 0; + FUN_0041f900(&DAT_00796548,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x16000000; + local_3c[2] = 0x16ffffff; + FUN_00401340(&DAT_007966b4); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("materials"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x40; + local_4 = 0x80; + local_e = 1; + FUN_0041f900(&DAT_0079654c,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x17000000; + local_3c[2] = 0x17ffffff; + FUN_00401340(&DAT_007966bc); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("materials"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x40; + local_4 = 0x80; + local_e = 0; + FUN_0041f900(&DAT_00796550,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x18000000; + local_3c[2] = 0x18ffffff; + FUN_00401340(&DAT_007966c0); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("materials"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x40; + local_4 = 0x80; + local_e = 0; + FUN_0041f900(&DAT_00796554,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x19000000; + local_3c[2] = 0x19ffffff; + FUN_00401340(".rendermesh"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796a58); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x10; + local_4 = 0x20; + local_e = 0; + FUN_0041f900(&DAT_00796598,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x20000000; + local_3c[2] = 0x2000ffff; + FUN_00401340(&DAT_007966d0); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796a54); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 2; + local_4 = 6; + local_e = 0; + FUN_0041f900(&DAT_00796558,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x21000000; + local_3c[2] = 0x21ffffff; + FUN_00401340(&DAT_007966d8); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 3; + local_20 = 1; + local_1c = 1; + local_1b = 0; + local_1a = 0; + local_19 = 1; + FUN_00405000("ui/layout"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 1; + FUN_0041f900(&DAT_0079655c,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x22000000; + local_3c[2] = 0x22ffffff; + FUN_00401340(&DAT_007966e0); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796a44); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x40; + local_4 = 0x80; + local_e = 1; + FUN_0041f900(&DAT_00796560,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x23000000; + local_3c[2] = 0x24ffffff; + FUN_00401340(&DAT_007966e8); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(".stt_ansi"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(".stt_bin"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 0; + local_1a = 0; + local_19 = 1; + FUN_00405000("stringtable"); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 1; + FUN_0041f900(&DAT_00796564,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x25000000; + local_3c[2] = 0x25ffffff; + FUN_00401340(&DAT_00796708); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("emp/idmap"); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x40; + local_4 = 0x80; + local_e = 1; + FUN_0041f900(&DAT_00796568,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x26000000; + local_3c[2] = 0x2600ffff; + FUN_00401340(".actionmap"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("actionmap"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_0079656c,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x27000000; + local_3c[2] = 0x27ffffff; + FUN_00401340(".dimp"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("emp/idmap"); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 0x40; + local_4 = 0x80; + local_e = 1; + FUN_0041f900(&DAT_00796570,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x31000000; + local_3c[2] = 0x3100ffff; + FUN_00401340(&DAT_00796724); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("string"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_00796574,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x32000000; + local_3c[2] = 0x3200ffff; + FUN_00401340(&DAT_0079672c); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796a14); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_00796578,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x33000000; + local_3c[2] = 0x3300ffff; + FUN_00401340(&DAT_00796734); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796a10); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_0079657c,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x34000000; + local_3c[2] = 0x3400ffff; + FUN_00401340(&DAT_0079673c); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000(&DAT_00796a0c); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_00796580,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x39000000; + local_3c[2] = 0x39ffffff; + FUN_00401340(&DAT_00796744); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("emp/property"); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 1; + FUN_0041f900(&DAT_00796584,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x40000000; + local_3c[2] = 0x40000fff; + FUN_00401340(".font"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("fonts"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_00796588,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x40001000; + local_3c[2] = 0x40ffffff; + FUN_00401340(".font_local"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 0; + local_1a = 0; + local_19 = 1; + FUN_00405000("fonts"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 1; + FUN_0041f900(&DAT_0079658c,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x41000000; + local_3c[2] = 0x41ffffff; + FUN_00401340(&DAT_00796760); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 0; + local_1a = 0; + local_19 = 1; + FUN_00405000("stringtable"); + local_14 = 1; + local_13 = 0; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 1; + FUN_0041f900(&DAT_00796590,local_3c + 1); + local_28 = 0; + local_3c[1] = 0x78000000; + local_3c[2] = 0x7fffffff; + FUN_00401340(".dbpc"); + FUN_0040c440(local_3c); + puVar2 = (undefined4 *)(local_3c[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(".pmat"); + FUN_0040c440(local_3c); + LVar1 = InterlockedDecrement((LONG *)(local_3c[0] + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(local_3c[0] + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_3c[0] + -0x14))(1); + } + local_24 = 1; + local_20 = 1; + local_1c = 1; + local_1b = 1; + local_1a = 0; + local_19 = 0; + FUN_00405000("properties"); + local_14 = 1; + local_13 = 1; + local_12 = 1; + local_11 = 0; + local_10 = 0; + local_f = 0; + local_c = 0; + local_b = 1; + local_8 = 3; + local_4 = 0xf; + local_e = 0; + FUN_0041f900(&DAT_00796594,local_3c + 1); + local_28 = 0; + LVar1 = InterlockedDecrement((LONG *)(local_18 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(local_18 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_18 + -0x14))(1); + } + if (((uStack_2c & 0x80000000) == 0x80000000) && (local_3c[3] != 0)) { + FUN_00407920(3); + } + return 1; +} + + + diff --git a/docs/research/decompiled/chunk_00420000.c b/docs/research/decompiled/chunk_00420000.c new file mode 100644 index 0000000..606afad --- /dev/null +++ b/docs/research/decompiled/chunk_00420000.c @@ -0,0 +1,10891 @@ +// Decompiled from acclient.exe — chunk 0x00420000 +// Ghidra 12.0.4 + pyghidra headless + +// --- FUN_004220b0 at 0x004220B0 (size: 45) --- + +int * __thiscall FUN_004220b0(int *param_1,int param_2,int param_3) + +{ + int iVar1; + + *param_1 = param_3; + param_1[1] = param_2; + if ((param_2 != DAT_00837cb8) && (param_3 == 0)) { + iVar1 = FUN_0041c280(param_2); + *param_1 = iVar1; + } + return param_1; +} + + + +// --- FUN_004220e0 at 0x004220E0 (size: 27) --- + +undefined4 __thiscall FUN_004220e0(int *param_1,undefined2 *param_2) + +{ + undefined2 uVar1; + int iVar2; + + iVar2 = *param_1; + if (iVar2 != 0) { + uVar1 = *(undefined2 *)(iVar2 + 0x36); + *param_2 = uVar1; + return CONCAT31((int3)(CONCAT22((short)((uint)iVar2 >> 0x10),uVar1) >> 8),1); + } + return 0; +} + + + +// --- FUN_00422100 at 0x00422100 (size: 25) --- + +undefined4 __thiscall FUN_00422100(int *param_1,undefined1 *param_2) + +{ + int iVar1; + + iVar1 = *param_1; + if (iVar1 != 0) { + *param_2 = *(undefined1 *)(iVar1 + 0x38); + return CONCAT31((int3)((uint)iVar1 >> 8),1); + } + return 0; +} + + + +// --- FUN_00422120 at 0x00422120 (size: 27) --- + +undefined4 __thiscall FUN_00422120(int *param_1,undefined2 *param_2) + +{ + undefined2 uVar1; + int iVar2; + + iVar2 = *param_1; + if (iVar2 != 0) { + uVar1 = *(undefined2 *)(iVar2 + 0x34); + *param_2 = uVar1; + return CONCAT31((int3)(CONCAT22((short)((uint)iVar2 >> 0x10),uVar1) >> 8),1); + } + return 0; +} + + + +// --- FUN_00422140 at 0x00422140 (size: 27) --- + +undefined4 __thiscall FUN_00422140(int *param_1,undefined2 *param_2) + +{ + undefined2 uVar1; + int iVar2; + + iVar2 = *param_1; + if (iVar2 != 0) { + uVar1 = *(undefined2 *)(iVar2 + 0x3a); + *param_2 = uVar1; + return CONCAT31((int3)(CONCAT22((short)((uint)iVar2 >> 0x10),uVar1) >> 8),1); + } + return 0; +} + + + +// --- FUN_00422160 at 0x00422160 (size: 94) --- + +int __thiscall FUN_00422160(int *param_1,int param_2) + +{ + int iVar1; + uint3 uVar2; + + iVar1 = *param_1; + uVar2 = (uint3)((uint)iVar1 >> 8); + if (iVar1 != 0) { + if (param_2 == 0) { + if (*(char *)(iVar1 + 0x4c) != '\0') { +LAB_00422175: + return CONCAT31(uVar2,1); + } + } + else if (param_2 == 1) { + if (*(char *)(iVar1 + 0x4d) != '\0') { + return CONCAT31(uVar2,1); + } + } + else if (param_2 == -1) { + if (*(char *)(iVar1 + 0x4e) != '\0') { + return CONCAT31(uVar2,1); + } + } + else { + if ((1 < param_2) && (*(char *)(iVar1 + 0x4f) != '\0')) goto LAB_00422175; + if ((param_2 < -1) && (*(char *)(iVar1 + 0x50) != '\0')) { + return CONCAT31(uVar2,1); + } + } + } + return (uint)uVar2 << 8; +} + + + +// --- FUN_004221c0 at 0x004221C0 (size: 67) --- + +undefined4 FUN_004221c0(void) + +{ + int *piVar1; + int iVar2; + + piVar1 = (int *)FUN_005df0f5(4); + if (piVar1 == (int *)0x0) { + DAT_00837cc8 = (int *)0x0; + } + else { + *piVar1 = 0; + DAT_00837cc8 = piVar1; + iVar2 = FUN_00415730(1,4,0x30); + if (iVar2 != 0) { + *piVar1 = iVar2; + return 1; + } + } + return 0; +} + + + +// --- FUN_00422210 at 0x00422210 (size: 52) --- + +undefined4 FUN_00422210(void) + +{ + int *piVar1; + + piVar1 = DAT_00837cc8; + if (DAT_00837cc8 != (int *)0x0) { + if ((int *)*DAT_00837cc8 != (int *)0x0) { + (**(code **)(*(int *)*DAT_00837cc8 + 0x14))(); + *piVar1 = 0; + } + operator_delete(piVar1); + } + DAT_00837cc8 = (int *)0x0; + return 1; +} + + + +// --- FUN_00422250 at 0x00422250 (size: 80) --- + +void FUN_00422250(char *param_1,int param_2) + +{ + char *pcVar1; + char cVar2; + + cVar2 = *param_1; + FUN_0040ad10(1); + pcVar1 = (char *)FUN_0040acf0(1); + if (pcVar1 != (char *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + cVar2 = *pcVar1; + } + else { + *pcVar1 = cVar2; + } + } + if ((((*(byte *)(param_2 + 4) & 5) == 0) && (cVar2 != '\0')) && (cVar2 != '\x01')) { + FUN_0040aa50(); + } + *param_1 = cVar2 != '\0'; + return; +} + + + +// --- FUN_00422380 at 0x00422380 (size: 310) --- + +void __fastcall FUN_00422380(undefined4 *param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)(param_1[0x2c] + -0x14); + *param_1 = &PTR_LAB_00796b20; + LVar1 = InterlockedDecrement((LONG *)(param_1[0x2c] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x19] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x19] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x18] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x18] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x17] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x17] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x16] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x16] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x15] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x15] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x12] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x12] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x11] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x11] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x10] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x10] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0xf] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0xf] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_004154b0(); + return; +} + + + +// --- FUN_004224f0 at 0x004224F0 (size: 30) --- + +void * __thiscall FUN_004224f0(void *param_1,byte param_2) + +{ + FUN_00422380(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00422510 at 0x00422510 (size: 80) --- + +undefined4 __thiscall FUN_00422510(int *param_1,int *param_2) + +{ + int iVar1; + int iVar2; + LONG LVar3; + + iVar1 = *param_1; + if (iVar1 != 0) { + iVar2 = *param_2; + if (iVar2 != *(int *)(iVar1 + 0x3c)) { + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar1 = *(int *)(iVar1 + 0x3c); + *param_2 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + return 1; + } + return 0; +} + + + +// --- FUN_00422560 at 0x00422560 (size: 80) --- + +undefined4 __thiscall FUN_00422560(int *param_1,int *param_2) + +{ + int iVar1; + int iVar2; + LONG LVar3; + + iVar1 = *param_1; + if (iVar1 != 0) { + iVar2 = *param_2; + if (iVar2 != *(int *)(iVar1 + 0x44)) { + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar1 = *(int *)(iVar1 + 0x44); + *param_2 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + return 1; + } + return 0; +} + + + +// --- FUN_004225b0 at 0x004225B0 (size: 80) --- + +undefined4 __thiscall FUN_004225b0(int *param_1,int *param_2) + +{ + int iVar1; + int iVar2; + LONG LVar3; + + iVar1 = *param_1; + if (iVar1 != 0) { + iVar2 = *param_2; + if (iVar2 != *(int *)(iVar1 + 0x40)) { + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar1 = *(int *)(iVar1 + 0x40); + *param_2 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + return 1; + } + return 0; +} + + + +// --- FUN_00422600 at 0x00422600 (size: 80) --- + +undefined4 __thiscall FUN_00422600(int *param_1,int *param_2) + +{ + int iVar1; + int iVar2; + LONG LVar3; + + iVar1 = *param_1; + if (iVar1 != 0) { + iVar2 = *param_2; + if (iVar2 != *(int *)(iVar1 + 0x48)) { + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar1 = *(int *)(iVar1 + 0x48); + *param_2 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + return 1; + } + return 0; +} + + + +// --- FUN_00422650 at 0x00422650 (size: 80) --- + +undefined4 __thiscall FUN_00422650(int *param_1,int *param_2) + +{ + int iVar1; + int iVar2; + LONG LVar3; + + iVar1 = *param_1; + if (iVar1 != 0) { + iVar2 = *param_2; + if (iVar2 != *(int *)(iVar1 + 0x60)) { + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar1 = *(int *)(iVar1 + 0x60); + *param_2 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + return 1; + } + return 0; +} + + + +// --- FUN_004226a0 at 0x004226A0 (size: 80) --- + +undefined4 __thiscall FUN_004226a0(int *param_1,int *param_2) + +{ + int iVar1; + int iVar2; + LONG LVar3; + + iVar1 = *param_1; + if (iVar1 != 0) { + iVar2 = *param_2; + if (iVar2 != *(int *)(iVar1 + 100)) { + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar1 = *(int *)(iVar1 + 100); + *param_2 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + return 1; + } + return 0; +} + + + +// --- FUN_004226f0 at 0x004226F0 (size: 214) --- + +undefined4 __thiscall FUN_004226f0(int *param_1,int *param_2,int *param_3,int *param_4) + +{ + int iVar1; + int iVar2; + LONG LVar3; + + iVar1 = *param_1; + if (iVar1 != 0) { + iVar2 = *param_2; + if (iVar2 != *(int *)(iVar1 + 0x54)) { + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar1 = *(int *)(iVar1 + 0x54); + *param_2 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + iVar1 = *param_1; + iVar2 = *param_3; + if (iVar2 != *(int *)(iVar1 + 0x58)) { + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar1 = *(int *)(iVar1 + 0x58); + *param_3 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + iVar1 = *param_1; + iVar2 = *param_4; + if (iVar2 != *(int *)(iVar1 + 0x5c)) { + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar1 = *(int *)(iVar1 + 0x5c); + *param_4 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + return 1; + } + return 0; +} + + + +// --- FUN_004227d0 at 0x004227D0 (size: 145) --- + +void __thiscall FUN_004227d0(int *param_1,int param_2) + +{ + uint uVar1; + int iVar2; + int iVar3; + uint uVar4; + + iVar2 = param_2; + if ((*(byte *)(param_2 + 4) & 1) != 0) { + param_2 = *(int *)(*param_1 + -4) + -1; + } + FUN_00401a80(¶m_2,¶m_2,iVar2); + iVar3 = param_2; + if ((*(uint *)(iVar2 + 4) >> 2 & 1) == 0) { + uVar1 = param_2 * 2; + if ((~*(byte *)(iVar2 + 4) & 1) != 0) { + uVar4 = FUN_0040a8f0(); + if (uVar4 < uVar1) { + FUN_0040aa50(); + return; + } + FUN_004010a0(); + FUN_004022d0(iVar3); + *(undefined2 *)(uVar1 + *param_1) = 0; + } + FUN_00401590(*param_1,uVar1,iVar2); + } + return; +} + + + +// --- FUN_00422d00 at 0x00422D00 (size: 30) --- + +void FUN_00422d00(undefined4 *param_1,undefined4 *param_2,undefined4 *param_3) + +{ + for (; param_1 != param_2; param_1 = param_1 + 1) { + *param_1 = *param_3; + } + return; +} + + + +// --- FUN_00422d20 at 0x00422D20 (size: 63) --- + +void FUN_00422d20(int param_1,int param_2,uint *param_3) + +{ + int iVar1; + int iVar2; + + iVar2 = param_2 - param_1 >> 2; + if (0 < iVar2) { + do { + iVar1 = iVar2 >> 1; + if (*(uint *)(param_1 + iVar1 * 4) < *param_3) { + param_1 = param_1 + 4 + iVar1 * 4; + iVar1 = iVar2 + (-1 - iVar1); + } + iVar2 = iVar1; + } while (0 < iVar1); + } + return; +} + + + +// --- FUN_00422d60 at 0x00422D60 (size: 82) --- + +undefined4 * __thiscall FUN_00422d60(int param_1,int *param_2) + +{ + int iVar1; + undefined4 *puVar2; + char cVar3; + uint uVar4; + + iVar1 = *param_2; + uVar4 = *(uint *)(iVar1 + -8); + if (uVar4 == 0xffffffff) { + uVar4 = FUN_004016b0(iVar1); + *(uint *)(iVar1 + -8) = uVar4; + } + puVar2 = *(undefined4 **) + (*(int *)(param_1 + 4) + + (uVar4 % (uint)(*(int *)(param_1 + 8) - *(int *)(param_1 + 4) >> 2)) * 4); + while ((puVar2 != (undefined4 *)0x0 && (cVar3 = FUN_00401920(param_2), cVar3 == '\0'))) { + puVar2 = (undefined4 *)*puVar2; + } + return puVar2; +} + + + +// --- FUN_00422dc0 at 0x00422DC0 (size: 78) --- + +void * FUN_00422dc0(int param_1,void *param_2,void *param_3) + +{ + void *_Dst; + + if (param_1 == 0) { + _Dst = (void *)0x0; + } + else if ((uint)(param_1 << 2) < 0x81) { + _Dst = (void *)FUN_004050d0(param_1 << 2); + } + else { + _Dst = (void *)FUN_005df0f5(); + } + if (param_3 != param_2) { + memmove(_Dst,param_2,(int)param_3 - (int)param_2); + } + return _Dst; +} + + + +// --- FUN_00422e10 at 0x00422E10 (size: 145) --- + +void __thiscall FUN_00422e10(int *param_1,uint param_2) + +{ + int iVar1; + int iVar2; + int iVar3; + int iVar4; + + iVar1 = *param_1; + if ((uint)(param_1[2] - iVar1 >> 2) < param_2) { + iVar2 = param_1[1]; + if (iVar1 == 0) { + if (param_2 == 0) { + iVar4 = 0; + } + else if (param_2 * 4 < 0x81) { + iVar4 = FUN_004050d0(param_2 * 4); + } + else { + iVar4 = FUN_005df0f5(); + } + } + else { + iVar4 = FUN_00422dc0(param_2,iVar1,iVar2); + iVar3 = *param_1; + if (iVar3 != 0) { + FUN_004051c0(iVar3,(param_1[2] - iVar3 >> 2) << 2); + } + } + *param_1 = iVar4; + param_1[1] = iVar4 + (iVar2 - iVar1 >> 2) * 4; + param_1[2] = iVar4 + param_2 * 4; + } + return; +} + + + +// --- FUN_00422eb0 at 0x00422EB0 (size: 108) --- + +undefined4 * __thiscall FUN_00422eb0(undefined4 *param_1,int param_2,undefined4 *param_3) + +{ + undefined4 *puVar1; + + *param_1 = 0; + param_1[1] = 0; + param_1[2] = 0; + if (param_2 == 0) { + puVar1 = (undefined4 *)0x0; + } + else if ((uint)(param_2 * 4) < 0x81) { + puVar1 = (undefined4 *)FUN_004050d0(param_2 * 4); + } + else { + puVar1 = (undefined4 *)FUN_005df0f5(); + } + *param_1 = puVar1; + param_1[1] = puVar1; + param_1[2] = puVar1 + param_2; + for (; param_2 != 0; param_2 = param_2 + -1) { + *puVar1 = *param_3; + puVar1 = puVar1 + 1; + } + param_1[1] = puVar1; + return param_1; +} + + + +// --- FUN_00422f20 at 0x00422F20 (size: 284) --- + +void __thiscall FUN_00422f20(int param_1,undefined4 *param_2,uint param_3,undefined4 *param_4) + +{ + undefined4 uVar1; + undefined4 *_Dst; + uint uVar2; + int iVar3; + size_t _Size; + undefined4 *puVar4; + void *_Dst_00; + + if (param_3 != 0) { + if (param_3 <= (uint)(*(int *)(param_1 + 8) - *(int *)(param_1 + 4) >> 2)) { + uVar1 = *param_4; + _Dst = *(undefined4 **)(param_1 + 4); + uVar2 = *(int *)(param_1 + 4) - (int)param_2 >> 2; + if (uVar2 <= param_3) { + param_4 = (undefined4 *)(param_3 - uVar2); + iVar3 = (int)param_4; + puVar4 = _Dst; + if (param_4 != (undefined4 *)0x0) { + for (; iVar3 != 0; iVar3 = iVar3 + -1) { + *puVar4 = uVar1; + puVar4 = puVar4 + 1; + } + } + _Dst_00 = (void *)(*(int *)(param_1 + 4) + (int)param_4 * 4); + *(void **)(param_1 + 4) = _Dst_00; + param_3 = uVar1; + if (_Dst != param_2) { + memmove(_Dst_00,param_2,(int)_Dst - (int)param_2); + } + *(uint *)(param_1 + 4) = *(int *)(param_1 + 4) + uVar2 * 4; + FUN_00422d00(param_2,_Dst,¶m_3); + return; + } + param_4 = (undefined4 *)(param_3 * 4); + puVar4 = _Dst + -param_3; + param_3 = uVar1; + if (_Dst != puVar4) { + memmove(_Dst,puVar4,(int)_Dst - (int)puVar4); + } + _Size = (int)puVar4 - (int)param_2; + *(int *)(param_1 + 4) = *(int *)(param_1 + 4) + (int)param_4; + if (0 < (int)_Size) { + memmove((void *)((int)_Dst - _Size),param_2,_Size); + } + FUN_00422d00(param_2,(int)param_4 + (int)param_2,¶m_3); + return; + } + FUN_004052a0(param_2,param_4,¶m_4,param_3,0); + } + return; +} + + + +// --- FUN_00423040 at 0x00423040 (size: 205) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __fastcall FUN_00423040(int param_1) + +{ + undefined4 *puVar1; + undefined4 *puVar2; + LONG LVar3; + undefined4 *puVar4; + uint local_8; + + local_8 = 0; + if (*(int *)(param_1 + 8) - *(int *)(param_1 + 4) >> 2 != 0) { + do { + puVar1 = *(undefined4 **)(*(int *)(param_1 + 4) + local_8 * 4); + while (puVar2 = puVar1, puVar2 != (undefined4 *)0x0) { + puVar1 = (undefined4 *)*puVar2; + puVar4 = (undefined4 *)(puVar2[2] + -0x14); + LVar3 = InterlockedDecrement((LONG *)(puVar2[2] + -0x10)); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + puVar4 = (undefined4 *)(puVar2[1] + -0x14); + LVar3 = InterlockedDecrement((LONG *)(puVar2[1] + -0x10)); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + FUN_00404d90(&DAT_008376c0); + *puVar2 = DAT_008376cc; + _DAT_008376c0 = 0; + DAT_008376cc = puVar2; + } + *(undefined4 *)(*(int *)(param_1 + 4) + local_8 * 4) = 0; + local_8 = local_8 + 1; + } while (local_8 < (uint)(*(int *)(param_1 + 8) - *(int *)(param_1 + 4) >> 2)); + } + *(undefined4 *)(param_1 + 0x10) = 0; + return; +} + + + +// --- FUN_00423110 at 0x00423110 (size: 271) --- + +void __thiscall FUN_00423110(int param_1,uint param_2) + +{ + undefined4 *puVar1; + int iVar2; + int iVar3; + uint *puVar4; + uint uVar5; + uint uVar6; + undefined4 local_14; + uint local_10; + int local_c; + undefined4 local_8; + undefined4 local_4; + + uVar6 = *(int *)(param_1 + 8) - *(int *)(param_1 + 4) >> 2; + if (uVar6 < param_2) { + uVar5 = 0; + local_10 = uVar6; + puVar4 = (uint *)FUN_00422d20(&DAT_00796b78,"config/ProjectSettings.xml",¶m_2,param_2,0); + if (puVar4 == (uint *)"config/ProjectSettings.xml") { + param_2 = 0xfffffffb; + } + else { + param_2 = *puVar4; + } + if (uVar6 < param_2) { + local_14 = 0; + FUN_00422eb0(param_2,&local_14,¶m_2); + if (uVar6 != 0) { + do { + puVar1 = *(undefined4 **)(*(int *)(param_1 + 4) + uVar5 * 4); + while (puVar1 != (undefined4 *)0x0) { + iVar2 = puVar1[1]; + uVar6 = *(uint *)(iVar2 + -8); + if (uVar6 == 0xffffffff) { + uVar6 = FUN_004016b0(iVar2); + *(uint *)(iVar2 + -8) = uVar6; + } + *(undefined4 *)(*(int *)(param_1 + 4) + uVar5 * 4) = *puVar1; + *puVar1 = *(undefined4 *)(local_c + (uVar6 % param_2) * 4); + *(undefined4 **)(local_c + (uVar6 % param_2) * 4) = puVar1; + uVar6 = local_10; + puVar1 = *(undefined4 **)(*(int *)(param_1 + 4) + uVar5 * 4); + } + uVar5 = uVar5 + 1; + } while (uVar5 < uVar6); + } + iVar2 = *(int *)(param_1 + 4); + *(int *)(param_1 + 4) = local_c; + *(undefined4 *)(param_1 + 8) = local_8; + iVar3 = *(int *)(param_1 + 0xc); + *(undefined4 *)(param_1 + 0xc) = local_4; + if (iVar2 != 0) { + FUN_004051c0(iVar2,(iVar3 - iVar2 >> 2) << 2); + } + } + } + return; +} + + + +// --- FUN_00423220 at 0x00423220 (size: 162) --- + +int * __thiscall FUN_00423220(int param_1,int *param_2) + +{ + int *piVar1; + int iVar2; + int iVar3; + int iVar4; + undefined4 uVar5; + uint uVar6; + undefined4 *puVar7; + + FUN_00423110(*(int *)(param_1 + 0x10) + 1); + iVar2 = *(int *)(param_1 + 4); + iVar3 = *(int *)(param_1 + 8); + iVar4 = *param_2; + uVar6 = *(uint *)(iVar4 + -8); + if (uVar6 == 0xffffffff) { + uVar6 = FUN_004016b0(iVar4); + *(uint *)(iVar4 + -8) = uVar6; + } + uVar6 = uVar6 % (uint)(iVar3 - iVar2 >> 2); + uVar5 = *(undefined4 *)(*(int *)(param_1 + 4) + uVar6 * 4); + puVar7 = (undefined4 *)FUN_004050d0(0xc); + piVar1 = puVar7 + 1; + *puVar7 = 0; + if (piVar1 != (int *)0x0) { + iVar2 = *param_2; + *piVar1 = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + iVar2 = param_2[1]; + puVar7[2] = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + } + *puVar7 = uVar5; + *(undefined4 **)(*(int *)(param_1 + 4) + uVar6 * 4) = puVar7; + *(int *)(param_1 + 0x10) = *(int *)(param_1 + 0x10) + 1; + return piVar1; +} + + + +// --- FUN_004232d0 at 0x004232D0 (size: 229) --- + +int FUN_004232d0(int *param_1) + +{ + LONG *lpAddend; + undefined *puVar1; + int *piVar2; + int iVar3; + LONG LVar4; + int iVar5; + undefined4 *puVar6; + bool bVar7; + int local_8; + undefined *local_4; + + piVar2 = param_1; + iVar3 = FUN_00422d60(param_1); + puVar1 = PTR_DAT_00818344; + bVar7 = iVar3 != 0; + if (bVar7) { + iVar3 = iVar3 + 8; + iVar5 = local_8; + } + else { + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1 = (int *)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + iVar5 = *piVar2; + local_8 = iVar5; + InterlockedIncrement((LONG *)(iVar5 + -0x10)); + local_4 = puVar1; + InterlockedIncrement(lpAddend); + iVar3 = FUN_00423220(&local_8); + iVar3 = iVar3 + 4; + } + if (!bVar7) { + puVar6 = (undefined4 *)(local_4 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar4 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + LVar4 = InterlockedDecrement((LONG *)(iVar5 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(iVar5 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar5 + -0x14))(1); + } + } + if (!bVar7) { + LVar4 = InterlockedDecrement(param_1 + -4); + if ((LVar4 == 0) && (param_1 + -5 != (int *)0x0)) { + (**(code **)param_1[-5])(1); + } + } + return iVar3; +} + + + +// --- FUN_004233c0 at 0x004233C0 (size: 106) --- + +void __thiscall FUN_004233c0(int param_1,undefined4 param_2) + +{ + char *pcVar1; + undefined4 uVar2; + + pcVar1 = (char *)FUN_00422d20(&DAT_00796b78,"config/ProjectSettings.xml",¶m_2,param_2,0); + uVar2 = 0xfffffffb; + if (pcVar1 != "config/ProjectSettings.xml") { + uVar2 = *(undefined4 *)pcVar1; + } + FUN_00422e10(uVar2); + param_2 = 0; + FUN_00422f20(*(undefined4 *)(param_1 + 8),uVar2,¶m_2); + *(undefined4 *)(param_1 + 0x10) = 0; + return; +} + + + +// --- FUN_00423430 at 0x00423430 (size: 109) --- + +int * FUN_00423430(int *param_1,undefined4 param_2) + +{ + LONG LVar1; + int *piVar2; + int local_4; + + piVar2 = &local_4; + FUN_004232d0(&DAT_00837ce4); + FUN_0040bbc0(piVar2,param_2); + thunk_FUN_0040da10(&local_4,0); + *param_1 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + return param_1; +} + + + +// --- FUN_004234a0 at 0x004234A0 (size: 8) --- + +void FUN_004234a0(void) + +{ + FUN_0041af60(); + return; +} + + + +// --- FUN_004234b0 at 0x004234B0 (size: 18) --- + +int __fastcall FUN_004234b0(undefined4 *param_1) + +{ + int iVar1; + + iVar1 = param_1[1] + -1; + param_1[1] = iVar1; + if (iVar1 == 0) { + (**(code **)*param_1)(1); + iVar1 = 0; + } + return iVar1; +} + + + +// --- FUN_004234d0 at 0x004234D0 (size: 53) --- + +void __fastcall FUN_004234d0(int *param_1) + +{ + int *piVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)*param_1; + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + *param_1 = 0; + } + puVar2 = (undefined4 *)param_1[1]; + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + param_1[1] = 0; + } + return; +} + + + +// --- FUN_00423550 at 0x00423550 (size: 52) --- + +uint __thiscall FUN_00423550(int param_1,int *param_2) + +{ + uint in_EAX; + int unaff_retaddr; + + if (param_2 != (int *)0x0) { + in_EAX = (**(code **)(*param_2 + 0xe0))(¶m_2); + if ((char)in_EAX != '\0') { + return (uint)(*(int *)(param_1 + 8) == unaff_retaddr); + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00423590 at 0x00423590 (size: 54) --- + +uint __thiscall FUN_00423590(int param_1,int *param_2) + +{ + uint uVar1; + uint unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0xe0))(¶m_2); + if ((char)uVar1 != '\0') { + uVar1 = *(uint *)(param_1 + 8); + *(bool *)param_2 = uVar1 < unaff_retaddr; + return CONCAT31((int3)(uVar1 >> 8),1); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_004235d0 at 0x004235D0 (size: 40) --- + +void __thiscall FUN_004235d0(int param_1,int *param_2) + +{ + char cVar1; + uint unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0xe0))(¶m_2); + if (cVar1 != '\0') { + *(uint *)(param_1 + 8) = *(uint *)(param_1 + 8) & unaff_retaddr; + } + return; +} + + + +// --- FUN_00423600 at 0x00423600 (size: 40) --- + +void __thiscall FUN_00423600(int param_1,int *param_2) + +{ + char cVar1; + uint unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0xe0))(¶m_2); + if (cVar1 != '\0') { + *(uint *)(param_1 + 8) = *(uint *)(param_1 + 8) | unaff_retaddr; + } + return; +} + + + +// --- FUN_00423630 at 0x00423630 (size: 40) --- + +void __thiscall FUN_00423630(int param_1,int *param_2) + +{ + char cVar1; + uint unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0xe0))(¶m_2); + if (cVar1 != '\0') { + *(uint *)(param_1 + 8) = *(uint *)(param_1 + 8) ^ unaff_retaddr; + } + return; +} + + + +// --- FUN_00423660 at 0x00423660 (size: 48) --- + +uint __thiscall FUN_00423660(int param_1,int *param_2) + +{ + uint uVar1; + int unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0xe0))(¶m_2); + if ((char)uVar1 != '\0') { + return (uint)(*(int *)(param_1 + 8) != unaff_retaddr); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_00423690 at 0x00423690 (size: 48) --- + +uint __thiscall FUN_00423690(int param_1,int *param_2) + +{ + uint uVar1; + int unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0xe0))(¶m_2); + if ((char)uVar1 != '\0') { + return (uint)(*(int *)(param_1 + 8) == unaff_retaddr); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_004236c0 at 0x004236C0 (size: 50) --- + +uint __thiscall FUN_004236c0(int param_1,int *param_2) + +{ + uint uVar1; + uint unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0xe0))(¶m_2); + if ((char)uVar1 != '\0') { + return (uint)((*(uint *)(param_1 + 8) & unaff_retaddr) == unaff_retaddr); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_00423700 at 0x00423700 (size: 42) --- + +void __thiscall FUN_00423700(int param_1,int *param_2) + +{ + char cVar1; + uint unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0xe0))(¶m_2); + if (cVar1 != '\0') { + *(uint *)(param_1 + 8) = *(uint *)(param_1 + 8) & ~unaff_retaddr; + } + return; +} + + + +// --- FUN_00423b30 at 0x00423B30 (size: 49) --- + +uint __thiscall FUN_00423b30(int param_1,int *param_2) + +{ + uint in_EAX; + char unaff_retaddr; + + if (param_2 != (int *)0x0) { + in_EAX = (**(code **)(*param_2 + 0x70))(¶m_2); + if ((char)in_EAX != '\0') { + return (uint)(*(char *)(param_1 + 8) == unaff_retaddr); + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00423b70 at 0x00423B70 (size: 51) --- + +undefined4 __thiscall FUN_00423b70(int param_1,int *param_2) + +{ + char cVar1; + byte unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0x70))(¶m_2); + if (cVar1 != '\0') { + *(bool *)param_2 = *(byte *)(param_1 + 8) < unaff_retaddr; + return 1; + } + return 0; +} + + + +// --- FUN_00423bb0 at 0x00423BB0 (size: 45) --- + +uint __thiscall FUN_00423bb0(int param_1,int *param_2) + +{ + uint uVar1; + char unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x70))(¶m_2); + if ((char)uVar1 != '\0') { + return (uint)(*(char *)(param_1 + 8) != unaff_retaddr); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_00423be0 at 0x00423BE0 (size: 45) --- + +uint __thiscall FUN_00423be0(int param_1,int *param_2) + +{ + uint uVar1; + char unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x70))(¶m_2); + if ((char)uVar1 != '\0') { + return (uint)(*(char *)(param_1 + 8) == unaff_retaddr); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_00423c10 at 0x00423C10 (size: 37) --- + +void __thiscall FUN_00423c10(int param_1,int *param_2) + +{ + char cVar1; + byte unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0x70))(¶m_2); + if (cVar1 != '\0') { + *(byte *)(param_1 + 8) = *(byte *)(param_1 + 8) & unaff_retaddr; + } + return; +} + + + +// --- FUN_00423c40 at 0x00423C40 (size: 37) --- + +void __thiscall FUN_00423c40(int param_1,int *param_2) + +{ + char cVar1; + byte unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0x70))(¶m_2); + if (cVar1 != '\0') { + *(byte *)(param_1 + 8) = *(byte *)(param_1 + 8) | unaff_retaddr; + } + return; +} + + + +// --- FUN_00423c70 at 0x00423C70 (size: 37) --- + +void __thiscall FUN_00423c70(int param_1,int *param_2) + +{ + char cVar1; + byte unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0x70))(¶m_2); + if (cVar1 != '\0') { + *(byte *)(param_1 + 8) = *(byte *)(param_1 + 8) ^ unaff_retaddr; + } + return; +} + + + +// --- FUN_00423d30 at 0x00423D30 (size: 66) --- + +void __thiscall FUN_00423d30(int param_1,undefined1 param_2) + +{ + undefined4 *puVar1; + + if (*(undefined4 **)(param_1 + 8) != (undefined4 *)0x0) { + (**(code **)**(undefined4 **)(param_1 + 8))(1); + } + *(undefined4 *)(param_1 + 8) = 0; + puVar1 = (undefined4 *)FUN_005df0f5(8); + if (puVar1 != (undefined4 *)0x0) { + *puVar1 = &PTR_FUN_00797010; + *(undefined1 *)(puVar1 + 1) = param_2; + *(undefined4 **)(param_1 + 8) = puVar1; + return; + } + *(undefined4 *)(param_1 + 8) = 0; + return; +} + + + +// --- FUN_00423db0 at 0x00423DB0 (size: 54) --- + +void __fastcall FUN_00423db0(undefined4 *param_1) + +{ + param_1[1] = 1; + *param_1 = &PTR_LAB_00797048; + param_1[2] = DAT_00818874; + param_1[3] = DAT_00818878; + param_1[4] = DAT_0081887c; + param_1[5] = DAT_00818880; + return; +} + + + +// --- FUN_00423e60 at 0x00423E60 (size: 34) --- + +undefined4 __thiscall FUN_00423e60(int param_1,undefined4 *param_2) + +{ + undefined4 uVar1; + + *(undefined4 *)(param_1 + 8) = *param_2; + *(undefined4 *)(param_1 + 0xc) = param_2[1]; + *(undefined4 *)(param_1 + 0x10) = param_2[2]; + uVar1 = param_2[3]; + *(undefined4 *)(param_1 + 0x14) = uVar1; + return CONCAT31((int3)((uint)uVar1 >> 8),1); +} + + + +// --- FUN_00423f00 at 0x00423F00 (size: 60) --- + +uint FUN_00423f00(int *param_1) + +{ + uint in_EAX; + uint uVar1; + undefined1 local_10 [16]; + + if (param_1 != (int *)0x0) { + in_EAX = (**(code **)(*param_1 + 0x98))(local_10); + if ((char)in_EAX != '\0') { + uVar1 = FUN_00423f40(&stack0xffffffec); + return uVar1; + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00423f40 at 0x00423F40 (size: 99) --- + +undefined4 __thiscall FUN_00423f40(float *param_1,float *param_2) + +{ + if ((((ABS(*param_1 - *param_2) < DAT_00796c48 != (ABS(*param_1 - *param_2) == DAT_00796c48)) && + (ABS(param_1[1] - param_2[1]) < DAT_00796c48 != + (ABS(param_1[1] - param_2[1]) == DAT_00796c48))) && + (ABS(param_1[2] - param_2[2]) < DAT_00796c48 != (ABS(param_1[2] - param_2[2]) == DAT_00796c48) + )) && (ABS(param_1[3] - param_2[3]) < DAT_00796c48 != + (ABS(param_1[3] - param_2[3]) == DAT_00796c48))) { + return 1; + } + return 0; +} + + + +// --- FUN_00424000 at 0x00424000 (size: 79) --- + +uint FUN_00424000(void) + +{ + int iVar1; + uint uVar2; + uint uVar3; + uint uVar4; + + iVar1 = FUN_005df4c4(); + uVar2 = FUN_005df4c4(); + uVar3 = FUN_005df4c4(); + uVar4 = FUN_005df4c4(); + return uVar4 | ((iVar1 << 8 | uVar2) << 8 | uVar3) << 8; +} + + + +// --- FUN_004240c0 at 0x004240C0 (size: 48) --- + +uint __thiscall FUN_004240c0(int param_1,int *param_2) + +{ + uint in_EAX; + int unaff_retaddr; + + if (param_2 != (int *)0x0) { + in_EAX = (**(code **)(*param_2 + 0xb0))(¶m_2); + if ((char)in_EAX != '\0') { + return CONCAT31((int3)((uint)*(int *)(param_1 + 8) >> 8), + *(int *)(param_1 + 8) == unaff_retaddr); + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_004240f0 at 0x004240F0 (size: 44) --- + +uint __thiscall FUN_004240f0(int param_1,int *param_2) + +{ + uint uVar1; + int unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0xb0))(¶m_2); + if ((char)uVar1 != '\0') { + return CONCAT31((int3)((uint)*(int *)(param_1 + 8) >> 8),*(int *)(param_1 + 8) != unaff_retaddr) + ; + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_00424120 at 0x00424120 (size: 44) --- + +uint __thiscall FUN_00424120(int param_1,int *param_2) + +{ + uint uVar1; + int unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0xb0))(¶m_2); + if ((char)uVar1 != '\0') { + return CONCAT31((int3)((uint)*(int *)(param_1 + 8) >> 8),*(int *)(param_1 + 8) == unaff_retaddr) + ; + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_00424150 at 0x00424150 (size: 11) --- + +bool __fastcall FUN_00424150(int param_1) + +{ + return *(int *)(param_1 + 8) != 0; +} + + + +// --- FUN_00424180 at 0x00424180 (size: 52) --- + +uint __thiscall FUN_00424180(int param_1,int *param_2) + +{ + uint in_EAX; + int unaff_retaddr; + + if (param_2 != (int *)0x0) { + in_EAX = (**(code **)(*param_2 + 0xa8))(¶m_2); + if ((char)in_EAX != '\0') { + return (uint)(*(int *)(param_1 + 8) == unaff_retaddr); + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_004241c0 at 0x004241C0 (size: 48) --- + +uint __thiscall FUN_004241c0(int param_1,int *param_2) + +{ + uint uVar1; + int unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0xa8))(¶m_2); + if ((char)uVar1 != '\0') { + return (uint)(*(int *)(param_1 + 8) != unaff_retaddr); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_004241f0 at 0x004241F0 (size: 48) --- + +uint __thiscall FUN_004241f0(int param_1,int *param_2) + +{ + uint uVar1; + int unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0xa8))(¶m_2); + if ((char)uVar1 != '\0') { + return (uint)(*(int *)(param_1 + 8) == unaff_retaddr); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_00424270 at 0x00424270 (size: 73) --- + +uint __thiscall FUN_00424270(int param_1,int *param_2) + +{ + uint uVar1; + float unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x88))(¶m_2); + if ((char)uVar1 == '\0') { + return uVar1 & 0xffffff00; + } + if (*(float *)(param_1 + 8) < unaff_retaddr) { + *(undefined1 *)param_2 = 1; + return 1; + } + *(undefined1 *)param_2 = 0; + return 1; +} + + + +// --- FUN_004242c0 at 0x004242C0 (size: 38) --- + +void __thiscall FUN_004242c0(int param_1,int *param_2) + +{ + char cVar1; + float unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0x88))(¶m_2); + if (cVar1 != '\0') { + *(float *)(param_1 + 8) = unaff_retaddr + *(float *)(param_1 + 8); + } + return; +} + + + +// --- FUN_004242f0 at 0x004242F0 (size: 38) --- + +void __thiscall FUN_004242f0(int param_1,int *param_2) + +{ + char cVar1; + float unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0x88))(¶m_2); + if (cVar1 != '\0') { + *(float *)(param_1 + 8) = *(float *)(param_1 + 8) - unaff_retaddr; + } + return; +} + + + +// --- FUN_00424320 at 0x00424320 (size: 38) --- + +void __thiscall FUN_00424320(int param_1,int *param_2) + +{ + char cVar1; + float unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0x88))(¶m_2); + if (cVar1 != '\0') { + *(float *)(param_1 + 8) = unaff_retaddr * *(float *)(param_1 + 8); + } + return; +} + + + +// --- FUN_00424350 at 0x00424350 (size: 38) --- + +void __thiscall FUN_00424350(int param_1,int *param_2) + +{ + char cVar1; + float unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0x88))(¶m_2); + if (cVar1 != '\0') { + *(float *)(param_1 + 8) = *(float *)(param_1 + 8) / unaff_retaddr; + } + return; +} + + + +// --- FUN_00424380 at 0x00424380 (size: 59) --- + +uint __thiscall FUN_00424380(int param_1,int *param_2) + +{ + uint uVar1; + float unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x88))(¶m_2); + if ((char)uVar1 == '\0') { + return uVar1 & 0xffffff00; + } + if (unaff_retaddr < *(float *)(param_1 + 8)) { + return 1; + } + return 0; +} + + + +// --- FUN_004243c0 at 0x004243C0 (size: 59) --- + +uint __thiscall FUN_004243c0(int param_1,int *param_2) + +{ + uint uVar1; + float unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x88))(¶m_2); + if ((char)uVar1 == '\0') { + return uVar1 & 0xffffff00; + } + if (unaff_retaddr <= *(float *)(param_1 + 8)) { + return 1; + } + return 0; +} + + + +// --- FUN_00424400 at 0x00424400 (size: 59) --- + +uint __thiscall FUN_00424400(int param_1,int *param_2) + +{ + uint uVar1; + float unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x88))(¶m_2); + if ((char)uVar1 == '\0') { + return uVar1 & 0xffffff00; + } + if (*(float *)(param_1 + 8) < unaff_retaddr) { + return 1; + } + return 0; +} + + + +// --- FUN_00424440 at 0x00424440 (size: 59) --- + +uint __thiscall FUN_00424440(int param_1,int *param_2) + +{ + uint uVar1; + float unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x88))(¶m_2); + if ((char)uVar1 == '\0') { + return uVar1 & 0xffffff00; + } + if (*(float *)(param_1 + 8) < unaff_retaddr != (*(float *)(param_1 + 8) == unaff_retaddr)) { + return 1; + } + return 0; +} + + + +// --- FUN_00424480 at 0x00424480 (size: 59) --- + +uint __thiscall FUN_00424480(int param_1,int *param_2) + +{ + uint uVar1; + float unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x88))(¶m_2); + if ((char)uVar1 == '\0') { + return uVar1 & 0xffffff00; + } + if (*(float *)(param_1 + 8) != unaff_retaddr) { + return 1; + } + return 0; +} + + + +// --- FUN_004244c0 at 0x004244C0 (size: 59) --- + +uint __thiscall FUN_004244c0(int param_1,int *param_2) + +{ + uint uVar1; + float unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x88))(¶m_2); + if ((char)uVar1 == '\0') { + return uVar1 & 0xffffff00; + } + if (*(float *)(param_1 + 8) == unaff_retaddr) { + return 1; + } + return 0; +} + + + +// --- FUN_00424570 at 0x00424570 (size: 71) --- + +uint __thiscall FUN_00424570(int param_1,int *param_2) + +{ + float fVar1; + uint in_EAX; + float unaff_retaddr; + + if (param_2 != (int *)0x0) { + in_EAX = (**(code **)(*param_2 + 0x88))(¶m_2); + if ((char)in_EAX != '\0') { + fVar1 = ABS(*(float *)(param_1 + 8) - unaff_retaddr); + if (fVar1 < DAT_00796c48 != (fVar1 == DAT_00796c48)) { + return 1; + } + return 0; + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_004245e0 at 0x004245E0 (size: 52) --- + +uint __thiscall FUN_004245e0(int param_1,int *param_2) + +{ + uint in_EAX; + int unaff_retaddr; + + if (param_2 != (int *)0x0) { + in_EAX = (**(code **)(*param_2 + 200))(¶m_2); + if ((char)in_EAX != '\0') { + return (uint)(*(int *)(param_1 + 8) == unaff_retaddr); + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00424670 at 0x00424670 (size: 49) --- + +uint __thiscall FUN_00424670(int param_1,int *param_2) + +{ + uint in_EAX; + int unaff_retaddr; + + if (param_2 != (int *)0x0) { + in_EAX = (**(code **)(*param_2 + 0x78))(¶m_2); + if ((char)in_EAX != '\0') { + return (uint)(*(int *)(param_1 + 8) == unaff_retaddr); + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_004246b0 at 0x004246B0 (size: 51) --- + +uint __thiscall FUN_004246b0(int param_1,int *param_2) + +{ + int iVar1; + uint uVar2; + int unaff_retaddr; + + uVar2 = (**(code **)(*param_2 + 0x78))(¶m_2); + if ((char)uVar2 != '\0') { + iVar1 = *(int *)(param_1 + 8); + *(bool *)param_2 = iVar1 < unaff_retaddr; + return CONCAT31((int3)((uint)iVar1 >> 8),1); + } + return uVar2 & 0xffffff00; +} + + + +// --- FUN_004246f0 at 0x004246F0 (size: 37) --- + +void __thiscall FUN_004246f0(int param_1,int *param_2) + +{ + char cVar1; + int unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0x78))(¶m_2); + if (cVar1 != '\0') { + *(int *)(param_1 + 8) = *(int *)(param_1 + 8) + unaff_retaddr; + } + return; +} + + + +// --- FUN_00424720 at 0x00424720 (size: 37) --- + +void __thiscall FUN_00424720(int param_1,int *param_2) + +{ + char cVar1; + int unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0x78))(¶m_2); + if (cVar1 != '\0') { + *(int *)(param_1 + 8) = *(int *)(param_1 + 8) - unaff_retaddr; + } + return; +} + + + +// --- FUN_00424750 at 0x00424750 (size: 36) --- + +void __thiscall FUN_00424750(int param_1,int *param_2) + +{ + char cVar1; + int unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0x78))(¶m_2); + if (cVar1 != '\0') { + *(int *)(param_1 + 8) = *(int *)(param_1 + 8) * unaff_retaddr; + } + return; +} + + + +// --- FUN_00424780 at 0x00424780 (size: 36) --- + +void __thiscall FUN_00424780(int param_1,int *param_2) + +{ + char cVar1; + int unaff_retaddr; + + cVar1 = (**(code **)(*param_2 + 0x78))(¶m_2); + if (cVar1 != '\0') { + *(int *)(param_1 + 8) = *(int *)(param_1 + 8) / unaff_retaddr; + } + return; +} + + + +// --- FUN_004247b0 at 0x004247B0 (size: 45) --- + +uint __thiscall FUN_004247b0(int param_1,int *param_2) + +{ + uint uVar1; + int unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x78))(¶m_2); + if ((char)uVar1 != '\0') { + return (uint)(unaff_retaddr < *(int *)(param_1 + 8)); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_004247e0 at 0x004247E0 (size: 45) --- + +uint __thiscall FUN_004247e0(int param_1,int *param_2) + +{ + uint uVar1; + int unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x78))(¶m_2); + if ((char)uVar1 != '\0') { + return (uint)(unaff_retaddr <= *(int *)(param_1 + 8)); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_00424810 at 0x00424810 (size: 45) --- + +uint __thiscall FUN_00424810(int param_1,int *param_2) + +{ + uint uVar1; + int unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x78))(¶m_2); + if ((char)uVar1 != '\0') { + return (uint)(*(int *)(param_1 + 8) < unaff_retaddr); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_00424840 at 0x00424840 (size: 45) --- + +uint __thiscall FUN_00424840(int param_1,int *param_2) + +{ + uint uVar1; + int unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x78))(¶m_2); + if ((char)uVar1 != '\0') { + return (uint)(*(int *)(param_1 + 8) <= unaff_retaddr); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_00424870 at 0x00424870 (size: 45) --- + +uint __thiscall FUN_00424870(int param_1,int *param_2) + +{ + uint uVar1; + int unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x78))(¶m_2); + if ((char)uVar1 != '\0') { + return (uint)(*(int *)(param_1 + 8) != unaff_retaddr); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_004248a0 at 0x004248A0 (size: 45) --- + +uint __thiscall FUN_004248a0(int param_1,int *param_2) + +{ + uint uVar1; + int unaff_retaddr; + + uVar1 = (**(code **)(*param_2 + 0x78))(¶m_2); + if ((char)uVar1 != '\0') { + return (uint)(*(int *)(param_1 + 8) == unaff_retaddr); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_00424ce0 at 0x00424CE0 (size: 38) --- + +undefined4 * __fastcall FUN_00424ce0(undefined4 *param_1) + +{ + *param_1 = 0x3f800000; + param_1[1] = 0; + param_1[2] = 0; + param_1[3] = 0; + param_1[0xd] = 0; + param_1[0xe] = 0; + param_1[0xf] = 0; + FUN_00535b30(); + return param_1; +} + + + +// --- FUN_00424d10 at 0x00424D10 (size: 50) --- + +undefined4 * __fastcall FUN_00424d10(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_00797910; + param_1[1] = 0; + param_1[2] = 0x3f800000; + param_1[3] = 0; + param_1[4] = 0; + param_1[5] = 0; + param_1[0xf] = 0; + param_1[0x10] = 0; + param_1[0x11] = 0; + FUN_00535b30(); + return param_1; +} + + + +// --- FUN_00424d50 at 0x00424D50 (size: 64) --- + +undefined4 * __fastcall FUN_00424d50(undefined4 *param_1) + +{ + param_1[1] = 1; + *param_1 = &PTR_LAB_00797928; + param_1[2] = &PTR_LAB_00797910; + param_1[3] = 0; + param_1[4] = 0x3f800000; + param_1[5] = 0; + param_1[6] = 0; + param_1[7] = 0; + param_1[0x11] = 0; + param_1[0x12] = 0; + param_1[0x13] = 0; + FUN_00535b30(); + return param_1; +} + + + +// --- FUN_00424dd0 at 0x00424DD0 (size: 178) --- + +uint __thiscall FUN_00424dd0(int param_1,int *param_2) + +{ + uint uVar1; + int iVar2; + undefined **local_48; + undefined4 local_44; + undefined4 local_40; + undefined4 local_3c; + undefined4 local_38; + undefined4 local_34; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + local_48 = &PTR_LAB_00797910; + local_44 = 0; + local_40 = 0x3f800000; + local_3c = 0; + local_38 = 0; + local_34 = 0; + local_c = 0; + local_8 = 0; + local_4 = 0; + uVar1 = FUN_00535b30(); + if (param_2 != (int *)0x0) { + uVar1 = (**(code **)(*param_2 + 0xd0))(&local_48); + if ((char)uVar1 != '\0') { + if (*(undefined ***)(param_1 + 0xc) == local_48) { + iVar2 = FUN_00424e90(&local_44); + if (iVar2 != 0) { + return 1; + } + } + return 0; + } + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_00424e90 at 0x00424E90 (size: 63) --- + +undefined4 __thiscall FUN_00424e90(int param_1,int param_2) + +{ + char cVar1; + int iVar2; + + cVar1 = FUN_00424f40(param_1 + 0x34,param_2 + 0x34,DAT_00796c48); + if (cVar1 != '\0') { + iVar2 = FUN_00424ed0(param_2); + if (iVar2 != 0) { + return 1; + } + } + return 0; +} + + + +// --- FUN_00424ed0 at 0x00424ED0 (size: 107) --- + +undefined4 __thiscall FUN_00424ed0(float *param_1,float *param_2) + +{ + if ((((ABS(*param_1 - *param_2) < DAT_00796c48) && (ABS(param_1[1] - param_2[1]) < DAT_00796c48)) + && (ABS(param_1[2] - param_2[2]) < DAT_00796c48)) && + (ABS(param_1[3] - param_2[3]) < DAT_00796c48)) { + return 1; + } + return 0; +} + + + +// --- FUN_00424f40 at 0x00424F40 (size: 72) --- + +undefined4 FUN_00424f40(float *param_1,float *param_2,float param_3) + +{ + if (((ABS(*param_1 - *param_2) < param_3 != (ABS(*param_1 - *param_2) == param_3)) && + (ABS(param_1[1] - param_2[1]) < param_3 != (ABS(param_1[1] - param_2[1]) == param_3))) && + (ABS(param_1[2] - param_2[2]) < param_3 != (ABS(param_1[2] - param_2[2]) == param_3))) { + return 1; + } + return 0; +} + + + +// --- FUN_00424fc0 at 0x00424FC0 (size: 28) --- + +undefined4 * __fastcall FUN_00424fc0(undefined4 *param_1) + +{ + param_1[1] = 1; + *param_1 = &PTR_FUN_00797a68; + FUN_0042dc80(); + return param_1; +} + + + +// --- FUN_00425170 at 0x00425170 (size: 45) --- + +undefined4 * __thiscall FUN_00425170(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00797a68; + FUN_0042e590(); + *param_1 = &PTR_LAB_00796c4c; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004251c0 at 0x004251C0 (size: 52) --- + +uint __thiscall FUN_004251c0(int param_1,int *param_2) + +{ + uint in_EAX; + int unaff_retaddr; + + if (param_2 != (int *)0x0) { + in_EAX = (**(code **)(*param_2 + 0x138))(¶m_2); + if ((char)in_EAX != '\0') { + return (uint)(*(int *)(param_1 + 8) == unaff_retaddr); + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00425200 at 0x00425200 (size: 54) --- + +uint __thiscall FUN_00425200(int param_1,int *param_2) + +{ + int iVar1; + uint uVar2; + int unaff_retaddr; + + uVar2 = (**(code **)(*param_2 + 0x138))(¶m_2); + if ((char)uVar2 != '\0') { + iVar1 = *(int *)(param_1 + 8); + *(bool *)param_2 = iVar1 < unaff_retaddr; + return CONCAT31((int3)((uint)iVar1 >> 8),1); + } + return uVar2 & 0xffffff00; +} + + + +// --- FUN_00425270 at 0x00425270 (size: 34) --- + +void __fastcall FUN_00425270(undefined4 *param_1) + +{ + undefined4 uVar1; + undefined4 uVar2; + + uVar2 = DAT_00796c44; + uVar1 = DAT_00796c40; + param_1[1] = 1; + *param_1 = &PTR_LAB_00797ce8; + param_1[2] = uVar1; + param_1[3] = uVar2; + return; +} + + + +// --- FUN_00425410 at 0x00425410 (size: 73) --- + +void __thiscall FUN_00425410(int param_1,undefined4 param_2,undefined4 param_3) + +{ + undefined4 *puVar1; + + if (*(undefined4 **)(param_1 + 8) != (undefined4 *)0x0) { + (**(code **)**(undefined4 **)(param_1 + 8))(1); + } + *(undefined4 *)(param_1 + 8) = 0; + puVar1 = (undefined4 *)FUN_005df0f5(0x10); + if (puVar1 != (undefined4 *)0x0) { + *puVar1 = &PTR_FUN_00797e28; + puVar1[2] = param_2; + puVar1[3] = param_3; + *(undefined4 **)(param_1 + 8) = puVar1; + return; + } + *(undefined4 *)(param_1 + 8) = 0; + return; +} + + + +// --- FUN_004254b0 at 0x004254B0 (size: 61) --- + +void FUN_004254b0(undefined4 *param_1,int param_2) + +{ + undefined4 *puVar1; + + FUN_0040ad10(8); + puVar1 = (undefined4 *)FUN_0040acf0(8); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *puVar1 = *param_1; + puVar1[1] = param_1[1]; + return; + } + *param_1 = *puVar1; + param_1[1] = puVar1[1]; + } + return; +} + + + +// --- FUN_004254f0 at 0x004254F0 (size: 43) --- + +void __fastcall FUN_004254f0(undefined4 *param_1) + +{ + param_1[1] = 1; + *param_1 = &PTR_LAB_00797e48; + param_1[2] = DAT_00837d6c; + param_1[3] = DAT_00837d70; + param_1[4] = DAT_00837d74; + return; +} + + + +// --- FUN_004256e0 at 0x004256E0 (size: 39) --- + +undefined4 * __fastcall FUN_004256e0(undefined4 *param_1) + +{ + param_1[1] = 1; + *param_1 = &PTR_LAB_00797f88; + FUN_005b2250(); + FUN_005b1fe0(); + return param_1; +} + + + +// --- FUN_00425710 at 0x00425710 (size: 42) --- + +bool FUN_00425710(undefined4 param_1,int *param_2) + +{ + char cVar1; + undefined4 uVar2; + + if (param_2 != (int *)0x0) { + uVar2 = (**(code **)(*param_2 + 0xc))(0); + cVar1 = FUN_005b2300(uVar2); + return cVar1 != '\0'; + } + return false; +} + + + +// --- FUN_00425780 at 0x00425780 (size: 73) --- + +void __thiscall FUN_00425780(undefined4 *param_1,undefined4 *param_2) + +{ + *param_1 = *param_2; + param_1[1] = param_2[1]; + param_1[2] = param_2[2]; + param_1[3] = param_2[3]; + param_1[4] = param_2[4]; + param_1[5] = param_2[5]; + param_1[6] = param_2[6]; + param_1[7] = param_2[7]; + param_1[8] = param_2[8]; + param_1[9] = param_2[9]; + param_1[10] = param_2[10]; + return; +} + + + +// --- FUN_004257d0 at 0x004257D0 (size: 74) --- + +undefined4 __thiscall FUN_004257d0(int param_1,undefined4 *param_2) + +{ + undefined4 uVar1; + + *(undefined4 *)(param_1 + 8) = *param_2; + *(undefined4 *)(param_1 + 0xc) = param_2[1]; + *(undefined4 *)(param_1 + 0x10) = param_2[2]; + *(undefined4 *)(param_1 + 0x14) = param_2[3]; + *(undefined4 *)(param_1 + 0x18) = param_2[4]; + *(undefined4 *)(param_1 + 0x1c) = param_2[5]; + *(undefined4 *)(param_1 + 0x20) = param_2[6]; + *(undefined4 *)(param_1 + 0x24) = param_2[7]; + *(undefined4 *)(param_1 + 0x28) = param_2[8]; + *(undefined4 *)(param_1 + 0x2c) = param_2[9]; + uVar1 = param_2[10]; + *(undefined4 *)(param_1 + 0x30) = uVar1; + return CONCAT31((int3)((uint)uVar1 >> 8),1); +} + + + +// --- FUN_00425890 at 0x00425890 (size: 253) --- + +undefined4 __thiscall FUN_00425890(int *param_1,int *param_2) + +{ + if ((((((*param_1 == *param_2) && + (ABS((float)param_1[1] - (float)param_2[1]) < DAT_00796c48 != + (ABS((float)param_1[1] - (float)param_2[1]) == DAT_00796c48))) && + (ABS((float)param_1[2] - (float)param_2[2]) < DAT_00796c48 != + (ABS((float)param_1[2] - (float)param_2[2]) == DAT_00796c48))) && + ((ABS((float)param_1[3] - (float)param_2[3]) < DAT_00796c48 != + (ABS((float)param_1[3] - (float)param_2[3]) == DAT_00796c48) && + (ABS((float)param_1[4] - (float)param_2[4]) < DAT_00796c48 != + (ABS((float)param_1[4] - (float)param_2[4]) == DAT_00796c48))))) && + ((ABS((float)param_1[5] - (float)param_2[5]) < DAT_00796c48 != + (ABS((float)param_1[5] - (float)param_2[5]) == DAT_00796c48) && + ((ABS((float)param_1[6] - (float)param_2[6]) < DAT_00796c48 != + (ABS((float)param_1[6] - (float)param_2[6]) == DAT_00796c48) && + (ABS((float)param_1[7] - (float)param_2[7]) < DAT_00796c48 != + (ABS((float)param_1[7] - (float)param_2[7]) == DAT_00796c48))))))) && + ((ABS((float)param_1[8] - (float)param_2[8]) < DAT_00796c48 != + (ABS((float)param_1[8] - (float)param_2[8]) == DAT_00796c48) && + ((ABS((float)param_1[9] - (float)param_2[9]) < DAT_00796c48 != + (ABS((float)param_1[9] - (float)param_2[9]) == DAT_00796c48) && + (ABS((float)param_1[10] - (float)param_2[10]) < DAT_00796c48 != + (ABS((float)param_1[10] - (float)param_2[10]) == DAT_00796c48))))))) { + return 1; + } + return 0; +} + + + +// --- FUN_00425a60 at 0x00425A60 (size: 64) --- + +undefined4 * __thiscall FUN_00425a60(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007980c8; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00425aa0 at 0x00425AA0 (size: 64) --- + +undefined4 * __thiscall FUN_00425aa0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007980cc; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00425ae0 at 0x00425AE0 (size: 178) --- + +int * __thiscall FUN_00425ae0(int *param_1,byte param_2) + +{ + int *piVar1; + undefined4 *puVar2; + int iVar3; + int *piVar4; + + if ((param_2 & 2) == 0) { + puVar2 = (undefined4 *)*param_1; + if (puVar2 != (undefined4 *)0x0) { + piVar4 = puVar2 + 1; + *piVar4 = *piVar4 + -1; + if (*piVar4 == 0) { + (**(code **)*puVar2)(1); + } + *param_1 = 0; + } + puVar2 = (undefined4 *)param_1[1]; + if (puVar2 != (undefined4 *)0x0) { + piVar4 = puVar2 + 1; + *piVar4 = *piVar4 + -1; + if (*piVar4 == 0) { + (**(code **)*puVar2)(1); + } + param_1[1] = 0; + } + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; + } + iVar3 = param_1[-1]; + piVar4 = param_1 + iVar3 * 2; + if (-1 < iVar3 + -1) { + do { + puVar2 = (undefined4 *)piVar4[-2]; + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + piVar4[-2] = 0; + } + puVar2 = (undefined4 *)piVar4[-1]; + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + piVar4[-1] = 0; + } + iVar3 = iVar3 + -1; + piVar4 = piVar4 + -2; + } while (iVar3 != 0); + } + if ((param_2 & 1) != 0) { + operator_delete__(param_1 + -1); + } + return param_1 + -1; +} + + + +// --- FUN_00425ba0 at 0x00425BA0 (size: 127) --- + +int * __fastcall FUN_00425ba0(int *param_1) + +{ + int *piVar1; + + *param_1 = 0; + if (DAT_00837db8 == (int *)0x0) { + piVar1 = (int *)FUN_00415730(0xf,2,0x2d); + if (DAT_00837db8 != (int *)0x0) { + (**(code **)(*DAT_00837db8 + 0x14))(); + DAT_00837db8 = (int *)0x0; + } + if (piVar1 != (int *)0x0) { + DAT_00837db8 = piVar1; + (**(code **)(*piVar1 + 0x10))(); + (**(code **)(*piVar1 + 0x14))(); + } + if ((int *)*param_1 != (int *)0x0) { + (**(code **)(*(int *)*param_1 + 0x14))(); + *param_1 = 0; + } + if (DAT_00837db8 == (int *)0x0) { + return param_1; + } + } + piVar1 = DAT_00837db8; + *param_1 = (int)DAT_00837db8; + (**(code **)(*piVar1 + 0x10))(); + return param_1; +} + + + +// --- FUN_00425c50 at 0x00425C50 (size: 66) --- + +void __thiscall FUN_00425c50(int param_1,undefined4 param_2) + +{ + undefined4 *puVar1; + + if (*(undefined4 **)(param_1 + 8) != (undefined4 *)0x0) { + (**(code **)**(undefined4 **)(param_1 + 8))(1); + } + *(undefined4 *)(param_1 + 8) = 0; + puVar1 = (undefined4 *)FUN_005df0f5(8); + if (puVar1 != (undefined4 *)0x0) { + *puVar1 = &PTR_FUN_007980d0; + puVar1[1] = param_2; + *(undefined4 **)(param_1 + 8) = puVar1; + return; + } + *(undefined4 *)(param_1 + 8) = 0; + return; +} + + + +// --- FUN_00425d00 at 0x00425D00 (size: 66) --- + +void __thiscall FUN_00425d00(int param_1,undefined4 param_2) + +{ + undefined4 *puVar1; + + if (*(undefined4 **)(param_1 + 8) != (undefined4 *)0x0) { + (**(code **)**(undefined4 **)(param_1 + 8))(1); + } + *(undefined4 *)(param_1 + 8) = 0; + puVar1 = (undefined4 *)FUN_005df0f5(8); + if (puVar1 != (undefined4 *)0x0) { + puVar1[1] = param_2; + *puVar1 = &PTR_FUN_007980ec; + *(undefined4 **)(param_1 + 8) = puVar1; + return; + } + *(undefined4 *)(param_1 + 8) = 0; + return; +} + + + +// --- FUN_00425de0 at 0x00425DE0 (size: 66) --- + +void __thiscall FUN_00425de0(int param_1,undefined4 param_2) + +{ + undefined4 *puVar1; + + if (*(undefined4 **)(param_1 + 8) != (undefined4 *)0x0) { + (**(code **)**(undefined4 **)(param_1 + 8))(1); + } + *(undefined4 *)(param_1 + 8) = 0; + puVar1 = (undefined4 *)FUN_005df0f5(8); + if (puVar1 != (undefined4 *)0x0) { + *puVar1 = &PTR_FUN_00798124; + puVar1[1] = param_2; + *(undefined4 **)(param_1 + 8) = puVar1; + return; + } + *(undefined4 *)(param_1 + 8) = 0; + return; +} + + + +// --- FUN_00425e60 at 0x00425E60 (size: 31) --- + +undefined4 * __thiscall FUN_00425e60(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079702c; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00425ed0 at 0x00425ED0 (size: 51) --- + +undefined4 * __thiscall FUN_00425ed0(undefined4 *param_1,int param_2) + +{ + param_1[1] = 1; + *param_1 = &PTR_LAB_00797928; + param_1[2] = &PTR_LAB_00797910; + param_1[3] = *(undefined4 *)(param_2 + 4); + FUN_00425f10(param_2 + 8); + return param_1; +} + + + +// --- FUN_00425f10 at 0x00425F10 (size: 111) --- + +void __thiscall FUN_00425f10(undefined4 *param_1,undefined4 *param_2) + +{ + param_1[0xd] = param_2[0xd]; + param_1[0xe] = param_2[0xe]; + param_1[0xf] = param_2[0xf]; + *param_1 = *param_2; + param_1[1] = param_2[1]; + param_1[2] = param_2[2]; + param_1[3] = param_2[3]; + param_1[4] = param_2[4]; + param_1[5] = param_2[5]; + param_1[6] = param_2[6]; + param_1[7] = param_2[7]; + param_1[8] = param_2[8]; + param_1[9] = param_2[9]; + param_1[10] = param_2[10]; + param_1[0xb] = param_2[0xb]; + param_1[0xc] = param_2[0xc]; + return; +} + + + +// --- FUN_00426020 at 0x00426020 (size: 195) --- + +undefined1 __fastcall FUN_00426020(int param_1) + +{ + char cVar1; + int iVar2; + int *piVar3; + LONG LVar4; + undefined1 uVar5; + int unaff_ESI; + int iStack_4; + + uVar5 = 0; + if (*(int **)(param_1 + 8) != (int *)0x0) { + iStack_4 = param_1; + iVar2 = (**(code **)(**(int **)(param_1 + 8) + 4))(); + if (iVar2 == 0) { + FUN_00401700(*(int **)(param_1 + 8) + 1); + return 1; + } + (**(code **)(**(int **)(param_1 + 8) + 0x14))(&iStack_4); + piVar3 = (int *)FUN_005df0f5(8); + if (piVar3 == (int *)0x0) { + piVar3 = (int *)0x0; + } + else { + *piVar3 = (int)&PTR_FUN_00798140; + FUN_00401a40(); + } + cVar1 = (**(code **)(*piVar3 + 0x10))(&stack0xfffffff8); + if (cVar1 == '\0') { + (**(code **)*piVar3)(1); + uVar5 = 0; + } + else { + FUN_00401700(piVar3 + 1); + if (*(undefined4 **)(param_1 + 8) != (undefined4 *)0x0) { + (**(code **)**(undefined4 **)(param_1 + 8))(1); + } + *(int **)(param_1 + 8) = piVar3; + uVar5 = 1; + } + LVar4 = InterlockedDecrement((LONG *)(unaff_ESI + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(unaff_ESI + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(unaff_ESI + -0x14))(1); + } + } + return uVar5; +} + + + +// --- FUN_00426120 at 0x00426120 (size: 18) --- + +undefined4 FUN_00426120(undefined4 param_1) + +{ + FUN_00401700(param_1); + return 1; +} + + + +// --- FUN_00426160 at 0x00426160 (size: 45) --- + +undefined4 * __thiscall FUN_00426160(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00798140; + FUN_004011b0(); + *param_1 = &PTR_FUN_0079702c; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004262b0 at 0x004262B0 (size: 40) --- + +undefined4 * __fastcall FUN_004262b0(undefined4 *param_1) + +{ + LONG *lpAddend; + + param_1[1] = 1; + *param_1 = &PTR_FUN_00798160; + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[2] = PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + return param_1; +} + + + +// --- FUN_00426360 at 0x00426360 (size: 41) --- + +uint __thiscall FUN_00426360(int param_1,undefined4 param_2,int param_3) + +{ + uint in_EAX; + int iVar1; + uint uVar2; + + if (param_3 != 0) { + iVar1 = FUN_0065ca90(); + in_EAX = 0; + if (iVar1 != 0) { + uVar2 = FUN_00426020(param_1 + 8); + return uVar2; + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00426520 at 0x00426520 (size: 119) --- + +undefined4 __thiscall FUN_00426520(undefined4 *param_1,undefined4 *param_2) + +{ + byte bVar1; + byte *pbVar2; + int iVar3; + byte *pbVar4; + bool bVar5; + + pbVar4 = (byte *)*param_2; + pbVar2 = (byte *)*param_1; + if (*(int *)(pbVar2 + -4) == *(int *)(pbVar4 + -4)) { + if (((*(int *)(pbVar2 + -8) == *(int *)(pbVar4 + -8)) || (*(int *)(pbVar2 + -8) == -1)) || + (*(int *)(pbVar4 + -8) == -1)) { + while( true ) { + bVar1 = *pbVar2; + bVar5 = bVar1 < *pbVar4; + if (bVar1 != *pbVar4) break; + if (bVar1 == 0) { + return 0; + } + bVar1 = pbVar2[1]; + bVar5 = bVar1 < pbVar4[1]; + if (bVar1 != pbVar4[1]) break; + pbVar2 = pbVar2 + 2; + pbVar4 = pbVar4 + 2; + if (bVar1 == 0) { + return 0; + } + } + iVar3 = (1 - (uint)bVar5) - (uint)(bVar5 != 0); + return CONCAT31((int3)((uint)iVar3 >> 8),iVar3 != 0); + } + } + return CONCAT31((int3)((uint)pbVar2 >> 8),1); +} + + + +// --- FUN_00426630 at 0x00426630 (size: 45) --- + +undefined4 * __thiscall FUN_00426630(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00798160; + FUN_004011b0(); + *param_1 = &PTR_LAB_00796c4c; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00426660 at 0x00426660 (size: 47) --- + +undefined4 * __fastcall FUN_00426660(undefined4 *param_1) + +{ + LONG *lpAddend; + + param_1[1] = 1; + *param_1 = &PTR_FUN_007982a0; + param_1[2] = 0; + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[3] = PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + return param_1; +} + + + +// --- FUN_004266b0 at 0x004266B0 (size: 52) --- + +uint __thiscall FUN_004266b0(int param_1,int *param_2) + +{ + uint in_EAX; + int unaff_retaddr; + + if (param_2 != (int *)0x0) { + in_EAX = (**(code **)(*param_2 + 0x130))(¶m_2); + if ((char)in_EAX != '\0') { + return (uint)(*(int *)(param_1 + 8) == unaff_retaddr); + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_004266f0 at 0x004266F0 (size: 56) --- + +void __thiscall FUN_004266f0(int param_1,int param_2) + +{ + undefined4 *puVar1; + + FUN_0040ad10(4); + puVar1 = (undefined4 *)FUN_0040acf0(4); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *puVar1 = *(undefined4 *)(param_1 + 8); + return; + } + *(undefined4 *)(param_1 + 8) = *puVar1; + } + return; +} + + + +// --- FUN_00426770 at 0x00426770 (size: 60) --- + +undefined4 __thiscall FUN_00426770(int param_1,undefined4 param_2,int param_3) + +{ + char cVar1; + int iVar2; + undefined4 uVar3; + + if (param_3 != 0) { + iVar2 = FUN_0065ca90(); + if (iVar2 != 0) { + cVar1 = FUN_00426020(param_1 + 0xc); + if (cVar1 != '\0') { + uVar3 = FUN_004134b0(); + *(undefined4 *)(param_1 + 8) = uVar3; + return 1; + } + } + } + return 0; +} + + + +// --- FUN_004267b0 at 0x004267B0 (size: 45) --- + +undefined4 * __thiscall FUN_004267b0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007982a0; + FUN_004011b0(); + *param_1 = &PTR_LAB_00796c4c; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004268d0 at 0x004268D0 (size: 58) --- + +undefined1 __thiscall FUN_004268d0(int *param_1,undefined4 param_2,undefined4 param_3) + +{ + undefined1 uVar1; + + FUN_00425ba0(); + if (param_1 == (int *)0x0) { + return 0; + } + uVar1 = FUN_0041af60(param_2,param_3); + (**(code **)(*param_1 + 0x14))(); + return uVar1; +} + + + +// --- FUN_00426910 at 0x00426910 (size: 60) --- + +undefined1 __thiscall FUN_00426910(int *param_1,undefined4 param_2,undefined4 param_3) + +{ + undefined1 uVar1; + + FUN_00425ba0(); + if (param_1 == (int *)0x0) { + return 0; + } + uVar1 = FUN_0041b060(10,param_2,param_3); + (**(code **)(*param_1 + 0x14))(); + return uVar1; +} + + + +// --- FUN_00426950 at 0x00426950 (size: 29) --- + +void __fastcall FUN_00426950(int *param_1) + +{ + if (((param_1[1] & 0x80000000U) == 0x80000000) && (*param_1 != 0)) { + FUN_00425ae0(3); + } + return; +} + + + +// --- FUN_00426970 at 0x00426970 (size: 27) --- + +void __fastcall FUN_00426970(undefined4 *param_1) + +{ + param_1[1] = 1; + *param_1 = &PTR_FUN_007983e0; + param_1[2] = 0; + param_1[3] = 0; + param_1[4] = 0; + return; +} + + + +// --- FUN_00426990 at 0x00426990 (size: 4) --- + +int __fastcall FUN_00426990(int param_1) + +{ + return param_1 + 8; +} + + + +// --- FUN_00426b60 at 0x00426B60 (size: 45) --- + +undefined4 * __thiscall FUN_00426b60(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007983e0; + FUN_00426950(); + *param_1 = &PTR_LAB_00796c4c; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00426b90 at 0x00426B90 (size: 41) --- + +uint __thiscall FUN_00426b90(int param_1,undefined4 param_2,int param_3) + +{ + uint in_EAX; + int iVar1; + uint uVar2; + + if (param_3 != 0) { + iVar1 = FUN_0065ca90(); + in_EAX = 0; + if (iVar1 != 0) { + uVar2 = FUN_00426bc0(param_1 + 8); + return uVar2; + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00426bc0 at 0x00426BC0 (size: 180) --- + +undefined1 __thiscall FUN_00426bc0(undefined1 *param_1,undefined1 *param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + LONG LVar4; + undefined1 uVar5; + int unaff_ESI; + undefined1 *puStack_4; + + uVar5 = 0; + if (*(int **)(param_1 + 8) != (int *)0x0) { + puStack_4 = param_1; + iVar2 = (**(code **)(**(int **)(param_1 + 8) + 4))(); + if (iVar2 == 7) { + *param_2 = (char)(*(int **)(param_1 + 8))[1]; + return 1; + } + (**(code **)(**(int **)(param_1 + 8) + 0x14))(&puStack_4); + piVar3 = (int *)FUN_005df0f5(8); + if (piVar3 == (int *)0x0) { + piVar3 = (int *)0x0; + } + else { + *piVar3 = (int)&PTR_FUN_00797010; + } + cVar1 = (**(code **)(*piVar3 + 0x10))(&stack0xfffffff8); + if (cVar1 == '\0') { + (**(code **)*piVar3)(1); + uVar5 = 0; + } + else { + *puStack_4 = (char)piVar3[1]; + if (*(undefined4 **)(param_1 + 8) != (undefined4 *)0x0) { + (**(code **)**(undefined4 **)(param_1 + 8))(1); + } + *(int **)(param_1 + 8) = piVar3; + uVar5 = 1; + } + LVar4 = InterlockedDecrement((LONG *)(unaff_ESI + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(unaff_ESI + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(unaff_ESI + -0x14))(1); + } + } + return uVar5; +} + + + +// --- FUN_00426c80 at 0x00426C80 (size: 41) --- + +uint __thiscall FUN_00426c80(int param_1,undefined4 param_2,int param_3) + +{ + uint in_EAX; + int iVar1; + uint uVar2; + + if (param_3 != 0) { + iVar1 = FUN_0065ca90(); + in_EAX = 0; + if (iVar1 != 0) { + uVar2 = FUN_00426cb0(param_1 + 8); + return uVar2; + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00426cb0 at 0x00426CB0 (size: 180) --- + +undefined1 __thiscall FUN_00426cb0(int *param_1,int *param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + LONG LVar4; + undefined1 uVar5; + int unaff_ESI; + int *piStack_4; + + uVar5 = 0; + if ((int *)param_1[2] != (int *)0x0) { + piStack_4 = param_1; + iVar2 = (**(code **)(*(int *)param_1[2] + 4))(); + if (iVar2 == 4) { + *param_2 = ((int *)param_1[2])[1]; + return 1; + } + (**(code **)(*(int *)param_1[2] + 0x14))(&piStack_4); + piVar3 = (int *)FUN_005df0f5(8); + if (piVar3 == (int *)0x0) { + piVar3 = (int *)0x0; + } + else { + *piVar3 = (int)&PTR_FUN_007980d0; + } + cVar1 = (**(code **)(*piVar3 + 0x10))(&stack0xfffffff8); + if (cVar1 == '\0') { + (**(code **)*piVar3)(1); + uVar5 = 0; + } + else { + *piStack_4 = piVar3[1]; + if ((undefined4 *)param_1[2] != (undefined4 *)0x0) { + (*(code *)**(undefined4 **)param_1[2])(1); + } + param_1[2] = (int)piVar3; + uVar5 = 1; + } + LVar4 = InterlockedDecrement((LONG *)(unaff_ESI + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(unaff_ESI + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(unaff_ESI + -0x14))(1); + } + } + return uVar5; +} + + + +// --- FUN_00426d70 at 0x00426D70 (size: 41) --- + +uint __thiscall FUN_00426d70(int param_1,undefined4 param_2,int param_3) + +{ + uint in_EAX; + int iVar1; + uint uVar2; + + if (param_3 != 0) { + iVar1 = FUN_0065ca90(); + in_EAX = 0; + if (iVar1 != 0) { + uVar2 = FUN_00426da0(param_1 + 8); + return uVar2; + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00426da0 at 0x00426DA0 (size: 180) --- + +undefined1 __thiscall FUN_00426da0(int *param_1,int *param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + LONG LVar4; + undefined1 uVar5; + int unaff_ESI; + int *piStack_4; + + uVar5 = 0; + if ((int *)param_1[2] != (int *)0x0) { + piStack_4 = param_1; + iVar2 = (**(code **)(*(int *)param_1[2] + 4))(); + if (iVar2 == 8) { + *param_2 = ((int *)param_1[2])[1]; + return 1; + } + (**(code **)(*(int *)param_1[2] + 0x14))(&piStack_4); + piVar3 = (int *)FUN_005df0f5(8); + if (piVar3 == (int *)0x0) { + piVar3 = (int *)0x0; + } + else { + *piVar3 = (int)&PTR_FUN_007980ec; + } + cVar1 = (**(code **)(*piVar3 + 0x10))(&stack0xfffffff8); + if (cVar1 == '\0') { + (**(code **)*piVar3)(1); + uVar5 = 0; + } + else { + *piStack_4 = piVar3[1]; + if ((undefined4 *)param_1[2] != (undefined4 *)0x0) { + (*(code *)**(undefined4 **)param_1[2])(1); + } + param_1[2] = (int)piVar3; + uVar5 = 1; + } + LVar4 = InterlockedDecrement((LONG *)(unaff_ESI + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(unaff_ESI + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(unaff_ESI + -0x14))(1); + } + } + return uVar5; +} + + + +// --- FUN_00426e60 at 0x00426E60 (size: 41) --- + +uint __thiscall FUN_00426e60(int param_1,undefined4 param_2,int param_3) + +{ + uint in_EAX; + int iVar1; + uint uVar2; + + if (param_3 != 0) { + iVar1 = FUN_0065ca90(); + in_EAX = 0; + if (iVar1 != 0) { + uVar2 = FUN_00426e90(param_1 + 8); + return uVar2; + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00426e90 at 0x00426E90 (size: 180) --- + +undefined1 __thiscall FUN_00426e90(int *param_1,int *param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + LONG LVar4; + undefined1 uVar5; + int unaff_ESI; + int *piStack_4; + + uVar5 = 0; + if ((int *)param_1[2] != (int *)0x0) { + piStack_4 = param_1; + iVar2 = (**(code **)(*(int *)param_1[2] + 4))(); + if (iVar2 == 2) { + *param_2 = ((int *)param_1[2])[1]; + return 1; + } + (**(code **)(*(int *)param_1[2] + 0x14))(&piStack_4); + piVar3 = (int *)FUN_005df0f5(8); + if (piVar3 == (int *)0x0) { + piVar3 = (int *)0x0; + } + else { + *piVar3 = (int)&PTR_FUN_00798124; + } + cVar1 = (**(code **)(*piVar3 + 0x10))(&stack0xfffffff8); + if (cVar1 == '\0') { + (**(code **)*piVar3)(1); + uVar5 = 0; + } + else { + *piStack_4 = piVar3[1]; + if ((undefined4 *)param_1[2] != (undefined4 *)0x0) { + (*(code *)**(undefined4 **)param_1[2])(1); + } + param_1[2] = (int)piVar3; + uVar5 = 1; + } + LVar4 = InterlockedDecrement((LONG *)(unaff_ESI + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(unaff_ESI + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(unaff_ESI + -0x14))(1); + } + } + return uVar5; +} + + + +// --- FUN_00426f50 at 0x00426F50 (size: 49) --- + +bool __thiscall FUN_00426f50(int param_1,undefined4 param_2,int param_3) + +{ + int iVar1; + + if (param_3 != 0) { + iVar1 = *(int *)(param_1 + 8); + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + iVar1 = FUN_00426f90(iVar1); + return iVar1 != 0; + } + return false; +} + + + +// --- FUN_00426f90 at 0x00426F90 (size: 68) --- + +undefined4 FUN_00426f90(int param_1) + +{ + undefined4 uVar1; + LONG LVar2; + int iVar3; + + iVar3 = param_1; + InterlockedIncrement((LONG *)(param_1 + -0x10)); + uVar1 = FUN_00426fe0(iVar3); + LVar2 = InterlockedDecrement((LONG *)(param_1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(param_1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_1 + -0x14))(1); + } + return uVar1; +} + + + +// --- FUN_00426fe0 at 0x00426FE0 (size: 111) --- + +int __thiscall FUN_00426fe0(int *param_1,int param_2) + +{ + int iVar1; + LONG LVar2; + int iVar3; + + iVar1 = (**(code **)(*param_1 + 4))(); + if (iVar1 == 0) { + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(param_2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_2 + -0x14))(1); + } + return 0; + } + iVar3 = param_2; + InterlockedIncrement((LONG *)(param_2 + -0x10)); + FUN_00427050(iVar3); + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(param_2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_2 + -0x14))(1); + } + return iVar1; +} + + + +// --- FUN_00427050 at 0x00427050 (size: 104) --- + +void __thiscall FUN_00427050(int param_1,int param_2) + +{ + undefined4 *puVar1; + LONG LVar2; + + if (*(undefined4 **)(param_1 + 8) != (undefined4 *)0x0) { + (**(code **)**(undefined4 **)(param_1 + 8))(1); + } + *(undefined4 *)(param_1 + 8) = 0; + puVar1 = (undefined4 *)FUN_005df0f5(8); + if (puVar1 == (undefined4 *)0x0) { + puVar1 = (undefined4 *)0x0; + } + else { + *puVar1 = &PTR_FUN_00798140; + FUN_0041ab80(¶m_2); + } + *(undefined4 **)(param_1 + 8) = puVar1; + puVar1 = (undefined4 *)(param_2 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + return; +} + + + +// --- FUN_00427160 at 0x00427160 (size: 134) --- + +undefined4 __thiscall FUN_00427160(int param_1,undefined4 param_2,int param_3) + +{ + int iVar1; + int iVar2; + + if (param_3 != 0) { + iVar1 = *(int *)(param_1 + 8); + if (iVar1 == 0) { + iVar1 = DAT_00837d8c; + InterlockedIncrement((LONG *)(DAT_00837d8c + -0x10)); + iVar1 = FUN_00426f90(iVar1); + } + else { + iVar2 = DAT_00837d88; + if ((iVar1 != 1) && (iVar2 = DAT_00837d90, iVar1 != 0xff)) { + return 0; + } + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + iVar1 = FUN_00426f90(iVar2); + } + if (iVar1 != 0) { + return 1; + } + } + return 0; +} + + + +// --- FUN_004271f0 at 0x004271F0 (size: 75) --- + +undefined1 __thiscall FUN_004271f0(int *param_1,int *param_2,undefined4 param_3) + +{ + undefined1 uVar1; + int iVar2; + + FUN_00425ba0(); + if (param_1 == (int *)0x0) { + return 0; + } + iVar2 = *param_2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + uVar1 = FUN_0041b7e0(iVar2,param_3); + (**(code **)(*param_1 + 0x14))(); + return uVar1; +} + + + +// --- FUN_00427240 at 0x00427240 (size: 128) --- + +undefined4 FUN_00427240(int param_1) + +{ + int iVar1; + char cVar2; + int *piVar3; + undefined4 *puVar4; + undefined4 *puVar5; + undefined1 local_c [12]; + + piVar3 = (int *)FUN_0052dcf0(local_c); + puVar4 = (undefined4 *)piVar3[2]; + iVar1 = *piVar3; + puVar5 = (undefined4 *)piVar3[1]; + do { + if (puVar4 == (undefined4 *)0x0) { + return 1; + } + do { + if (((puVar4[2] != 0) && (*(int *)(puVar4[2] + 0x10) == param_1)) && + (cVar2 = FUN_0042be30(*puVar4), cVar2 == '\0')) { + return 0; + } + puVar4 = (undefined4 *)puVar4[1]; + } while (puVar4 != (undefined4 *)0x0); + do { + puVar5 = puVar5 + 1; + if (puVar5 == (undefined4 *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) { + return 1; + } + puVar4 = (undefined4 *)*puVar5; + } while (puVar4 == (undefined4 *)0x0); + } while( true ); +} + + + +// --- FUN_004272c0 at 0x004272C0 (size: 97) --- + +void FUN_004272c0(undefined4 param_1) + +{ + int iVar1; + int *piVar2; + int iVar3; + undefined1 local_c [12]; + + piVar2 = (int *)FUN_0052dcf0(local_c); + iVar3 = piVar2[2]; + iVar1 = *piVar2; + piVar2 = (int *)piVar2[1]; + do { + if (iVar3 == 0) { + return; + } + do { + if (*(int *)(iVar3 + 8) != 0) { + FUN_0042a580(param_1); + } + iVar3 = *(int *)(iVar3 + 4); + } while (iVar3 != 0); + do { + piVar2 = piVar2 + 1; + if (piVar2 == (int *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) { + return; + } + iVar3 = *piVar2; + } while (iVar3 == 0); + } while( true ); +} + + + +// --- FUN_00427330 at 0x00427330 (size: 32) --- + +void FUN_00427330(int *param_1) + +{ + int iVar1; + + iVar1 = (**(code **)(*param_1 + 0x108))(); + if (iVar1 != 0) { + FUN_00427350(iVar1); + } + return; +} + + + +// --- FUN_00427350 at 0x00427350 (size: 70) --- + +undefined4 __thiscall FUN_00427350(int param_1,int *param_2) + +{ + int iVar1; + + FUN_004273a0(*(int *)(param_1 + 8) + param_2[2]); + iVar1 = param_2[2]; + while (iVar1 = iVar1 + -1, -1 < iVar1) { + FUN_00429ab0(*param_2 + iVar1 * 8); + } + *(int *)(param_1 + 8) = *(int *)(param_1 + 8) + param_2[2]; + return 1; +} + + + +// --- FUN_004273a0 at 0x004273A0 (size: 191) --- + +undefined4 __thiscall FUN_004273a0(int *param_1,uint param_2) + +{ + uint *puVar1; + int iVar2; + uint *puVar3; + + if ((uint)param_1[2] <= param_2) { + if (param_2 <= (param_1[1] & 0x7fffffffU)) { + return 1; + } + if (param_2 == 0) { + FUN_00427460(); + return 1; + } + puVar3 = (uint *)thunk_FUN_005df0f5(param_2 * 8 + 4); + if (puVar3 != (uint *)0x0) { + puVar1 = puVar3 + 1; + *puVar3 = param_2; + FUN_00401000(puVar1,8,param_2,&LAB_004175f0); + if (puVar1 != (uint *)0x0) { + if (*param_1 != 0) { + iVar2 = param_1[2]; + while (iVar2 = iVar2 + -1, -1 < iVar2) { + FUN_00429ab0(*param_1 + iVar2 * 8); + } + if (((param_1[1] & 0x80000000U) == 0x80000000) && (*param_1 != 0)) { + FUN_00425ae0(3); + } + } + *param_1 = (int)puVar1; + param_1[1] = param_2 | 0x80000000; + return 1; + } + } + } + return 0; +} + + + +// --- FUN_00427460 at 0x00427460 (size: 169) --- + +void __fastcall FUN_00427460(int *param_1) + +{ + int iVar1; + uint uVar2; + undefined4 *local_8; + undefined4 *local_4; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) == 0x80000000) { + if (*param_1 != 0) { + FUN_00425ae0(3); + } + *param_1 = 0; + param_1[1] = 0; + return; + } + if (*param_1 != 0) { + uVar2 = param_1[1] & 0x7fffffff; + while (uVar2 = uVar2 - 1, -1 < (int)uVar2) { + local_8 = (undefined4 *)0x0; + local_4 = (undefined4 *)0x0; + FUN_00429ab0(&local_8); + if (local_8 != (undefined4 *)0x0) { + iVar1 = local_8[1]; + local_8[1] = iVar1 + -1; + if (iVar1 + -1 == 0) { + (**(code **)*local_8)(1); + } + local_8 = (undefined4 *)0x0; + } + if ((local_4 != (undefined4 *)0x0) && + (iVar1 = local_4[1], local_4[1] = iVar1 + -1, iVar1 + -1 == 0)) { + (**(code **)*local_4)(1); + } + } + } + return; +} + + + +// --- FUN_00427510 at 0x00427510 (size: 40) --- + +undefined4 FUN_00427510(int *param_1) + +{ + int iVar1; + + iVar1 = (**(code **)(*param_1 + 0x108))(); + if (iVar1 != 0) { + FUN_00427540(iVar1); + return 1; + } + return 0; +} + + + +// --- FUN_00427540 at 0x00427540 (size: 229) --- + +int __thiscall FUN_00427540(int param_1,uint *param_2) + +{ + int iVar1; + char cVar2; + uint uVar3; + uint uVar4; + undefined4 *local_8; + undefined4 *local_4; + + if ((*(uint *)(param_1 + 4) & 0x7fffffff) < (param_2[1] & 0x7fffffff)) { + *(undefined4 *)(param_1 + 8) = 0; + cVar2 = FUN_004273a0(param_2[1] & 0x7fffffff); + if (cVar2 == '\0') { + return param_1; + } + } + uVar3 = *param_2; + uVar4 = uVar3 + param_2[2] * 8; + for (; uVar3 < uVar4; uVar3 = uVar3 + 8) { + FUN_00429ab0(uVar3); + } + uVar4 = param_2[2]; + if (uVar4 < *(uint *)(param_1 + 8)) { + do { + local_8 = (undefined4 *)0x0; + local_4 = (undefined4 *)0x0; + FUN_00429ab0(&local_8); + if (local_8 != (undefined4 *)0x0) { + iVar1 = local_8[1]; + local_8[1] = iVar1 + -1; + if (iVar1 + -1 == 0) { + (**(code **)*local_8)(1); + } + local_8 = (undefined4 *)0x0; + } + if ((local_4 != (undefined4 *)0x0) && + (iVar1 = local_4[1], local_4[1] = iVar1 + -1, iVar1 + -1 == 0)) { + (**(code **)*local_4)(1); + } + uVar4 = uVar4 + 1; + } while (uVar4 < *(uint *)(param_1 + 8)); + } + *(uint *)(param_1 + 8) = param_2[2]; + return param_1; +} + + + +// --- FUN_00427860 at 0x00427860 (size: 105) --- + +undefined1 FUN_00427860(int param_1) + +{ + int *piVar1; + LONG LVar2; + undefined1 uVar3; + char *local_4; + + local_4 = (char *)0x0; + piVar1 = _errno(); + *piVar1 = 0; + FUN_0065de30(param_1,&local_4,0); + if (*local_4 == '\0') { + piVar1 = _errno(); + if (*piVar1 != 0x22) { + uVar3 = 1; + goto LAB_004278a5; + } + } + uVar3 = 0; +LAB_004278a5: + LVar2 = InterlockedDecrement((LONG *)(param_1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(param_1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_1 + -0x14))(1); + } + return uVar3; +} + + + +// --- FUN_004279c0 at 0x004279C0 (size: 340) --- + +undefined4 __thiscall FUN_004279c0(int param_1,undefined4 param_2,undefined4 param_3,int param_4) + +{ + undefined4 uVar1; + undefined4 uVar2; + LONG LVar3; + undefined4 *puVar4; + + FUN_00404cd0(); + uVar1 = *(undefined4 *)(param_1 + 8); + if ((char)param_4 != '\0') { + uVar2 = *(undefined4 *)(param_1 + 0xc); + FUN_00401a40(); + FUN_00402710(¶m_4,"%I64d",uVar1,uVar2); + FUN_004064e0(¶m_4); + FUN_004011b0(); + return 1; + } + uVar2 = *(undefined4 *)(param_1 + 0xc); + FUN_00401a40(); + FUN_00402710(¶m_4,"0x%016I64X",uVar1,uVar2); + FUN_004064e0(¶m_4); + FUN_004011b0(); + FUN_00401340(&DAT_00798588); + if (*(int *)(param_4 + -4) != 1) { + FUN_004064e0(¶m_4); + } + puVar4 = (undefined4 *)(param_4 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(param_4 + -0x10)); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + uVar1 = *(undefined4 *)(param_1 + 8); + uVar2 = *(undefined4 *)(param_1 + 0xc); + FUN_00401a40(); + FUN_00402710(¶m_4,"%I64d",uVar1,uVar2); + FUN_004064e0(¶m_4); + FUN_004011b0(); + FUN_00401340(&DAT_00798584); + if (*(int *)(param_4 + -4) != 1) { + FUN_004064e0(¶m_4); + } + puVar4 = (undefined4 *)(param_4 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(param_4 + -0x10)); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + return 1; +} + + + +// --- FUN_00427fa0 at 0x00427FA0 (size: 242) --- + +undefined1 __thiscall FUN_00427fa0(int param_1,undefined4 param_2,char *param_3) + +{ + int iVar1; + char cVar2; + int iVar3; + LONG LVar4; + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined4 uVar5; + undefined4 extraout_ECX_01; + undefined1 uVar6; + char *pcVar7; + + iVar1 = (int)param_3; + if (param_3 == (char *)0x0) { + return 0; + } + param_3 = PTR_DAT_00818344; + uVar6 = 1; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + iVar3 = FUN_0065ca90(); + uVar5 = extraout_ECX; + if (iVar3 == 0) { +LAB_00427fe2: + pcVar7 = "Expecting a leaf string node"; + } + else { + cVar2 = FUN_00426020(¶m_3); + uVar5 = extraout_ECX_00; + if (cVar2 == '\0') goto LAB_00427fe2; + iVar3 = _stricmp(param_3,DAT_00837d88); + if (iVar3 == 0) { + *(undefined4 *)(param_1 + 8) = 1; + goto LAB_0042805f; + } + iVar3 = _stricmp(param_3,DAT_00837d8c); + if (iVar3 == 0) { + *(undefined4 *)(param_1 + 8) = 0; + goto LAB_0042805f; + } + iVar3 = _stricmp(param_3,DAT_00837d90); + if (iVar3 == 0) { + *(undefined4 *)(param_1 + 8) = 0xff; + goto LAB_0042805f; + } + pcVar7 = "Unknown Keyword"; + uVar5 = extraout_ECX_01; + } + FUN_00401340(pcVar7); + FUN_0065d620(iVar1,uVar5); + uVar6 = 0; +LAB_0042805f: + pcVar7 = param_3 + -0x14; + LVar4 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar4 == 0) && (pcVar7 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar7)(1); + } + return uVar6; +} + + + +// --- FUN_00428100 at 0x00428100 (size: 192) --- + +undefined1 __thiscall FUN_00428100(int *param_1,int *param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + LONG LVar4; + undefined1 uVar5; + int unaff_EDI; + int *piStack_4; + + uVar5 = 0; + if ((int *)param_1[2] != (int *)0x0) { + piStack_4 = param_1; + iVar2 = (**(code **)(*(int *)param_1[2] + 4))(); + piVar3 = (int *)param_1[2]; + if (iVar2 == 3) { + *param_2 = piVar3[2]; + param_2[1] = piVar3[3]; + return 1; + } + (**(code **)(*piVar3 + 0x14))(&piStack_4); + piVar3 = (int *)FUN_005df0f5(0x10); + if (piVar3 == (int *)0x0) { + piVar3 = (int *)0x0; + } + else { + *piVar3 = (int)&PTR_FUN_00797e28; + } + cVar1 = (**(code **)(*piVar3 + 0x10))(&stack0xfffffff8); + if (cVar1 == '\0') { + (**(code **)*piVar3)(1); + uVar5 = 0; + } + else { + *piStack_4 = piVar3[2]; + piStack_4[1] = piVar3[3]; + if ((undefined4 *)param_1[2] != (undefined4 *)0x0) { + (*(code *)**(undefined4 **)param_1[2])(1); + } + param_1[2] = (int)piVar3; + uVar5 = 1; + } + LVar4 = InterlockedDecrement((LONG *)(unaff_EDI + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(unaff_EDI + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(unaff_EDI + -0x14))(1); + } + } + return uVar5; +} + + + +// --- FUN_00428210 at 0x00428210 (size: 73) --- + +void __fastcall FUN_00428210(int param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + undefined4 local_4; + + puVar1 = PTR_DAT_00818558; + local_4 = *(undefined4 *)(param_1 + 0x68); + puVar2 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,local_4,0); + if ((puVar2 != (undefined4 *)puVar1) || (puVar2 = puVar2 + -1, puVar2 != (undefined4 *)puVar1)) { + puVar2 = puVar2 + 1; + } + FUN_00428650(*puVar2); + return; +} + + + +// --- FUN_00428290 at 0x00428290 (size: 45) --- + +undefined4 * __thiscall FUN_00428290(undefined4 *param_1,undefined4 param_2) + +{ + param_1[1] = 1; + *param_1 = &PTR_FUN_007983e0; + param_1[2] = 0; + param_1[3] = 0; + param_1[4] = 0; + FUN_00427540(param_2); + return param_1; +} + + + +// --- FUN_004282d0 at 0x004282D0 (size: 137) --- + +void __thiscall FUN_004282d0(int param_1,int param_2) + +{ + uint *puVar1; + uint uVar2; + uint uVar3; + + uVar3 = *(uint *)(param_1 + 8); + FUN_0040ad10(4); + puVar1 = (uint *)FUN_0040acf0(4); + if (puVar1 != (uint *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + uVar3 = *puVar1; + } + else { + *puVar1 = uVar3; + } + } + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + uVar2 = FUN_0040a8f0(); + if (uVar2 < uVar3) { + FUN_0040aa50(); + return; + } + *(undefined4 *)(param_1 + 8) = 0; + FUN_00428360(uVar3,1); + } + uVar3 = 0; + if (*(int *)(param_1 + 8) != 0) { + do { + FUN_0042a330(param_2); + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 8)); + } + return; +} + + + +// --- FUN_00428360 at 0x00428360 (size: 192) --- + +undefined1 __thiscall FUN_00428360(int param_1,uint param_2,char param_3) + +{ + int iVar1; + char cVar2; + uint uVar3; + undefined4 *local_8; + undefined4 *local_4; + + if ((*(uint *)(param_1 + 4) & 0x7fffffff) < param_2) { + uVar3 = param_2; + if (param_3 == '\0') { + uVar3 = FUN_00453850(param_2); + } + cVar2 = FUN_004273a0(uVar3); + if (cVar2 == '\0') { + return 0; + } + } + else { + uVar3 = param_2; + if (param_2 < *(uint *)(param_1 + 8)) { + do { + local_8 = (undefined4 *)0x0; + local_4 = (undefined4 *)0x0; + FUN_00429ab0(&local_8); + if (local_8 != (undefined4 *)0x0) { + iVar1 = local_8[1]; + local_8[1] = iVar1 + -1; + if (iVar1 + -1 == 0) { + (**(code **)*local_8)(1); + } + local_8 = (undefined4 *)0x0; + } + if ((local_4 != (undefined4 *)0x0) && + (iVar1 = local_4[1], local_4[1] = iVar1 + -1, iVar1 + -1 == 0)) { + (**(code **)*local_4)(1); + } + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 8)); + } + } + *(uint *)(param_1 + 8) = param_2; + return 1; +} + + + +// --- FUN_00428460 at 0x00428460 (size: 70) --- + +undefined1 __thiscall FUN_00428460(int param_1,undefined4 param_2) + +{ + char cVar1; + uint uVar2; + undefined4 uVar3; + + uVar2 = *(uint *)(param_1 + 4) & 0x7fffffff; + if (uVar2 <= *(uint *)(param_1 + 8)) { + uVar3 = FUN_00453850(uVar2 + 1); + cVar1 = FUN_004273a0(uVar3); + if (cVar1 == '\0') { + return 0; + } + } + FUN_00429ab0(param_2); + *(int *)(param_1 + 8) = *(int *)(param_1 + 8) + 1; + return 1; +} + + + +// --- FUN_004284b0 at 0x004284B0 (size: 63) --- + +uint __thiscall FUN_004284b0(int param_1,uint param_2) + +{ + uint *puVar1; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x1b4) + (param_2 % *(uint *)(param_1 + 0x1bc)) * 4); + while( true ) { + if (puVar1 == (uint *)0x0) { + return 0; + } + if (*puVar1 == param_2) break; + puVar1 = (uint *)puVar1[1]; + } + if (puVar1 == (uint *)0x0) { + return 0; + } + return puVar1[2]; +} + + + +// --- FUN_004284f0 at 0x004284F0 (size: 143) --- + +undefined4 * __thiscall FUN_004284f0(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_007980c8; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00428580 at 0x00428580 (size: 143) --- + +undefined4 * __thiscall FUN_00428580(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_007980cc; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00428610 at 0x00428610 (size: 62) --- + +void __thiscall FUN_00428610(int param_1,uint *param_2) + +{ + uint *puVar1; + + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + FUN_00428210(); + } + puVar1 = (uint *)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + param_2[1] = *puVar1; + *puVar1 = (uint)param_2; + if (puVar1 < *(uint **)(param_1 + 100)) { + *(uint **)(param_1 + 100) = puVar1; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + return; +} + + + +// --- FUN_00428650 at 0x00428650 (size: 289) --- + +undefined4 __thiscall FUN_00428650(int param_1,int param_2) + +{ + uint *puVar1; + int iVar2; + uint *puVar3; + int *piVar4; + undefined4 *puVar5; + undefined4 *puVar6; + uint *puVar7; + + if (param_2 == *(int *)(param_1 + 0x68)) { + return 0; + } + iVar2 = *(int *)(param_1 + 0x6c); + puVar3 = (uint *)0x0; + do { + if (iVar2 == 0) { + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_00693b20(param_2); + puVar6 = (undefined4 *)PTR_DAT_00818558; + while (puVar3 != (uint *)0x0) { + param_2 = *(int *)(param_1 + 0x68); + puVar7 = (uint *)puVar3[1]; + PTR_DAT_00818558 = (undefined *)puVar6; + if (param_2 * 2 < *(int *)(param_1 + 0x6c) + 1) { + puVar5 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,puVar6,¶m_2,param_2,0); + if ((puVar5 != puVar6) || (puVar5 = puVar5 + -1, puVar5 != puVar6)) { + puVar5 = puVar5 + 1; + } + FUN_00428650(*puVar5); + } + puVar1 = (uint *)(*(int *)(param_1 + 0x60) + (*puVar3 % *(uint *)(param_1 + 0x68)) * 4); + puVar3[1] = *puVar1; + *puVar1 = (uint)puVar3; + if (puVar1 < *(uint **)(param_1 + 100)) { + *(uint **)(param_1 + 100) = puVar1; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + puVar6 = (undefined4 *)PTR_DAT_00818558; + puVar3 = puVar7; + } + PTR_DAT_00818558 = (undefined *)puVar6; + return 1; + } + piVar4 = *(int **)(param_1 + 100); + while (piVar4 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + puVar6 = *(undefined4 **)(param_1 + 100); + puVar7 = (uint *)*puVar6; + goto LAB_004286a1; + } + piVar4 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar4; + } + puVar6 = (undefined4 *)0x0; + puVar7 = (uint *)0x0; +LAB_004286a1: + FUN_00428ba0(param_1,puVar6,puVar7); + puVar7[1] = (uint)puVar3; + iVar2 = *(int *)(param_1 + 0x6c); + puVar3 = puVar7; + } while( true ); +} + + + +// --- FUN_00428840 at 0x00428840 (size: 184) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_00428840(double *param_1,int param_2,double param_3) + +{ + undefined4 uVar1; + double *pdVar2; + undefined8 local_10; + + if (((byte)*(undefined4 *)(param_2 + 4) & 5) == 1) { + if (*param_1 == (double)CONCAT44(DAT_00796c44,DAT_00796c40)) { + local_10 = 3.4028234663852886e+38; + } + else { + local_10 = *param_1 - param_3; + } + } + FUN_0040ad10(8); + pdVar2 = (double *)FUN_0040acf0(8); + if (pdVar2 != (double *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + local_10 = *pdVar2; + } + else { + *(undefined4 *)pdVar2 = (undefined4)local_10; + *(undefined4 *)((int)pdVar2 + 4) = local_10._4_4_; + } + } + uVar1 = DAT_00796c44; + if ((*(byte *)(param_2 + 4) & 5) == 0) { + if (local_10 == _DAT_00798698) { + *(undefined4 *)param_1 = DAT_00796c40; + *(undefined4 *)((int)param_1 + 4) = uVar1; + return; + } + *param_1 = local_10 + param_3; + } + return; +} + + + +// --- FUN_00428900 at 0x00428900 (size: 661) --- + +void FUN_00428900(undefined4 param_1,int param_2,uint param_3) + +{ + undefined *puVar1; + undefined *puVar2; + uint uVar3; + char cVar4; + undefined *puVar5; + byte *pbVar6; + int *piVar7; + undefined4 *puVar8; + int iVar9; + undefined4 uVar10; + undefined4 *puVar11; + int iVar12; + uint uVar13; + undefined4 *puVar14; + undefined1 local_c [12]; + + uVar3 = param_3; + if ((~*(byte *)(param_3 + 4) & 1) != 0) { + FUN_005c2c80(); + } + puVar2 = PTR_DAT_00818558; + puVar1 = PTR_DAT_00818554; + if (((byte)*(undefined4 *)(uVar3 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x68); + puVar5 = (undefined *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_3,param_3,0); + if (puVar5 == puVar2) { + puVar5 = puVar5 + -4; + } + uVar13 = (int)puVar5 - (int)puVar1 >> 2; + } + else { + uVar13 = param_3 & 0xff; + } + FUN_0040ad10(1); + pbVar6 = (byte *)FUN_0040acf0(1); + if (pbVar6 != (byte *)0x0) { + if ((*(byte *)(uVar3 + 4) & 1) == 0) { + uVar13 = (uint)*pbVar6; + } + else { + *pbVar6 = (byte)uVar13; + } + } + if ((*(byte *)(uVar3 + 4) & 5) == 0) { + if ((uVar13 & 0xff) < DAT_007956cc) { + FUN_0042ab60(*(undefined4 *)(PTR_DAT_00818554 + (uVar13 & 0xff) * 4)); + } + else { + FUN_0040aa50(); + } + } + if (((byte)*(undefined4 *)(uVar3 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x6c); + } + FUN_00401a80(¶m_3,¶m_3,uVar3); + if (((byte)*(undefined4 *)(uVar3 + 4) & 5) == 1) { + piVar7 = (int *)FUN_0052dcf0(local_c); + iVar12 = *piVar7; + puVar14 = (undefined4 *)piVar7[1]; + puVar8 = (undefined4 *)piVar7[2]; +LAB_00428a06: + puVar11 = puVar8; + if (puVar8 != (undefined4 *)0x0) { + do { + FUN_0040ad10(4); + puVar8 = (undefined4 *)FUN_0040acf0(4); + if (puVar8 != (undefined4 *)0x0) { + if ((*(byte *)(uVar3 + 4) & 1) == 0) { + *puVar11 = *puVar8; + } + else { + *puVar8 = *puVar11; + } + } + if ((*(uint *)(uVar3 + 4) >> 2 & 1) == 0) { + if ((~*(byte *)(uVar3 + 4) & 1) != 0) { + iVar9 = FUN_005df0f5(0xcc); + if (iVar9 == 0) { + uVar10 = 0; + } + else { + uVar10 = FUN_0042ac10(); + } + puVar11[2] = uVar10; + } + if (puVar11[2] == 0) { + FUN_0040aa50(); + } + else { + FUN_0042a600(uVar3); + } + } + puVar11 = (undefined4 *)puVar11[1]; + } while (puVar11 != (undefined4 *)0x0); + do { + puVar14 = puVar14 + 1; + puVar8 = puVar11; + if (puVar14 == (undefined4 *)(*(int *)(iVar12 + 0x60) + *(int *)(iVar12 + 0x68) * 4)) break; + puVar8 = (undefined4 *)*puVar14; + } while (puVar8 == (undefined4 *)0x0); + goto LAB_00428a06; + } + } + if ((*(byte *)(uVar3 + 4) & 5) == 0) { + uVar13 = FUN_0040a8f0(); + if (uVar13 < param_3) { +LAB_00428b86: + FUN_0040aa50(); + } + else { + uVar13 = 0; + puVar14 = (undefined4 *)0x0; + if (param_3 != 0) { + while( true ) { + puVar11 = (undefined4 *)FUN_005df0f5(0xc); + puVar8 = (undefined4 *)0x0; + if (puVar11 != (undefined4 *)0x0) { + puVar11[1] = 0; + puVar8 = puVar11; + } + FUN_0040ad10(4); + puVar11 = (undefined4 *)FUN_0040acf0(4); + if (puVar11 != (undefined4 *)0x0) { + if ((*(byte *)(uVar3 + 4) & 1) == 0) { + *puVar8 = *puVar11; + } + else { + *puVar11 = *puVar8; + } + } + if ((*(uint *)(uVar3 + 4) >> 2 & 1) == 0) { + if ((~*(byte *)(uVar3 + 4) & 1) != 0) { + iVar12 = FUN_005df0f5(0xcc); + if (iVar12 == 0) { + uVar10 = 0; + } + else { + uVar10 = FUN_0042ac10(); + } + puVar8[2] = uVar10; + } + if (puVar8[2] == 0) { + FUN_0040aa50(); + } + else { + FUN_0042a600(uVar3); + } + } + if ((*(uint *)(uVar3 + 4) >> 2 & 1) != 0) break; + cVar4 = FUN_00599310(puVar8,puVar14); + if (cVar4 == '\0') goto LAB_00428b86; + uVar13 = uVar13 + 1; + puVar14 = puVar8; + if (param_3 <= uVar13) { + return; + } + } + } + } + } + return; +} + + + +// --- FUN_00428ba0 at 0x00428BA0 (size: 64) --- + +void __thiscall FUN_00428ba0(int param_1,undefined4 param_2,int *param_3,int param_4) + +{ + int iVar1; + int iVar2; + + iVar2 = *param_3; + if (iVar2 != param_4) { + do { + iVar1 = iVar2; + iVar2 = *(int *)(iVar1 + 4); + } while (iVar2 != param_4); + if (iVar1 != 0) { + *(undefined4 *)(iVar1 + 4) = *(undefined4 *)(iVar2 + 4); + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + return; + } + } + *param_3 = *(int *)(iVar2 + 4); + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + return; +} + + + +// --- FUN_00428be0 at 0x00428BE0 (size: 169) --- + +void __fastcall FUN_00428be0(int param_1) + +{ + int iVar1; + undefined4 *puVar2; + void *pvVar3; + void *pvVar4; + int *piVar5; + void *pvVar6; + + iVar1 = *(int *)(param_1 + 0x6c); + do { + if (iVar1 == 0) { + return; + } + piVar5 = *(int **)(param_1 + 100); + while (piVar5 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar5 = *(int **)(param_1 + 100); + pvVar6 = (void *)*piVar5; + goto LAB_00428c1e; + } + piVar5 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar5; + } + piVar5 = (int *)0x0; + pvVar6 = (void *)0x0; +LAB_00428c1e: + pvVar4 = (void *)*piVar5; + if (pvVar4 == pvVar6) { +LAB_00428c31: + *piVar5 = *(int *)((int)pvVar4 + 4); + } + else { + do { + pvVar3 = pvVar4; + pvVar4 = *(void **)((int)pvVar3 + 4); + } while (pvVar4 != pvVar6); + if (pvVar3 == (void *)0x0) goto LAB_00428c31; + *(undefined4 *)((int)pvVar3 + 4) = *(undefined4 *)((int)pvVar4 + 4); + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + if (pvVar6 != (void *)0x0) { + puVar2 = *(undefined4 **)((int)pvVar6 + 8); + if (puVar2 != (undefined4 *)0x0) { + piVar5 = puVar2 + 1; + *piVar5 = *piVar5 + -1; + if (*piVar5 == 0) { + (**(code **)*puVar2)(1); + } + *(undefined4 *)((int)pvVar6 + 8) = 0; + } + puVar2 = *(undefined4 **)((int)pvVar6 + 0xc); + if (puVar2 != (undefined4 *)0x0) { + piVar5 = puVar2 + 1; + *piVar5 = *piVar5 + -1; + if (*piVar5 == 0) { + (**(code **)*puVar2)(1); + } + *(undefined4 *)((int)pvVar6 + 0xc) = 0; + } + operator_delete(pvVar6); + } + iVar1 = *(int *)(param_1 + 0x6c); + } while( true ); +} + + + +// --- FUN_00428d40 at 0x00428D40 (size: 116) --- + +void __fastcall FUN_00428d40(int param_1) + +{ + int *piVar1; + int iVar2; + undefined4 *puVar3; + int *piVar4; + int iVar5; + undefined1 auStack_c [12]; + + (**(code **)(*(int *)(param_1 + 0x30) + 0x3c))(); + piVar4 = (int *)FUN_0052dcf0(auStack_c); + iVar5 = piVar4[2]; + iVar2 = *piVar4; + piVar4 = (int *)piVar4[1]; + while (iVar5 != 0) { + do { + puVar3 = *(undefined4 **)(iVar5 + 8); + if (puVar3 != (undefined4 *)0x0) { + piVar1 = puVar3 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar3)(1); + } + } + iVar5 = *(int *)(iVar5 + 4); + } while (iVar5 != 0); + do { + piVar4 = piVar4 + 1; + if (piVar4 == (int *)(*(int *)(iVar2 + 0x60) + *(int *)(iVar2 + 0x68) * 4)) goto LAB_00428da5; + iVar5 = *piVar4; + } while (iVar5 == 0); + } +LAB_00428da5: + FUN_005870f0(); + return; +} + + + +// --- FUN_00428dc0 at 0x00428DC0 (size: 82) --- + +undefined4 * __thiscall FUN_00428dc0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007986a0; + FUN_005870f0(); + param_1[1] = &PTR_FUN_007980c8; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00428e30 at 0x00428E30 (size: 94) --- + +void __fastcall FUN_00428e30(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_007986a8; + FUN_00428d40(); + param_1[0x54] = &PTR_FUN_007986a0; + FUN_005870f0(); + param_1[0x55] = &PTR_FUN_007980c8; + if ((undefined4 *)param_1[0x6d] != param_1 + 0x56) { + operator_delete__((undefined4 *)param_1[0x6d]); + } + param_1[0x6d] = 0; + param_1[0x6e] = 0; + param_1[0x6f] = 0; + param_1[0x70] = 0; + FUN_0041bf80(); + FUN_004154b0(); + return; +} + + + +// --- FUN_00428ee0 at 0x00428EE0 (size: 82) --- + +undefined4 * __thiscall FUN_00428ee0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00798700; + FUN_00428be0(); + param_1[1] = &PTR_FUN_007980cc; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00428fa0 at 0x00428FA0 (size: 58) --- + +void __fastcall FUN_00428fa0(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_00798700; + FUN_00428be0(); + param_1[1] = &PTR_FUN_007980cc; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + return; +} + + + +// --- FUN_00428fe0 at 0x00428FE0 (size: 30) --- + +void * __thiscall FUN_00428fe0(void *param_1,byte param_2) + +{ + FUN_00428e30(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00429000 at 0x00429000 (size: 44) --- + +undefined4 * __fastcall FUN_00429000(undefined4 *param_1) + +{ + param_1[1] = 1; + *param_1 = &PTR_FUN_00798708; + param_1[2] = &PTR_FUN_00798700; + FUN_00428580(0); + param_1[2] = &PTR_FUN_00798700; + return param_1; +} + + + +// --- FUN_00429050 at 0x00429050 (size: 58) --- + +undefined4 FUN_00429050(undefined4 param_1) + +{ + undefined1 local_c [8]; + int local_4; + + FUN_00429090(local_c,param_1); + if (local_4 != 0) { + FUN_00429ab0(local_4 + 8); + return 1; + } + return 0; +} + + + +// --- FUN_00429090 at 0x00429090 (size: 57) --- + +void __thiscall FUN_00429090(int param_1,int *param_2,uint *param_3) + +{ + undefined4 *puVar1; + uint *puVar2; + + puVar1 = (undefined4 *)(*(int *)(param_1 + 0x60) + (*param_3 % *(uint *)(param_1 + 0x68)) * 4); + for (puVar2 = (uint *)*puVar1; (puVar2 != (uint *)0x0 && (*puVar2 != *param_3)); + puVar2 = (uint *)puVar2[1]) { + } + param_2[1] = (int)puVar1; + *param_2 = param_1; + param_2[2] = (int)puVar2; + return; +} + + + +// --- FUN_00429120 at 0x00429120 (size: 154) --- + +undefined4 FUN_00429120(undefined4 *param_1,undefined4 param_2) + +{ + undefined4 *puVar1; + undefined1 local_c [8]; + int local_4; + + FUN_00429090(local_c,param_1); + if (local_4 != 0) { + FUN_00429ab0(param_2); + return 1; + } + puVar1 = (undefined4 *)FUN_005df0f5(0x10); + if (puVar1 == (undefined4 *)0x0) { + puVar1 = (undefined4 *)0x0; + } + else { + *puVar1 = *param_1; + puVar1[1] = 0; + puVar1[2] = 0; + puVar1[3] = 0; + FUN_00429ab0(param_2); + } + FUN_00429090(local_c,puVar1); + if (local_4 == 0) { + FUN_00428610(puVar1); + } + return 1; +} + + + +// --- FUN_004291d0 at 0x004291D0 (size: 91) --- + +undefined4 FUN_004291d0(undefined4 param_1) + +{ + int *piVar1; + undefined4 *puVar2; + void *pvVar3; + + pvVar3 = (void *)FUN_004171e0(param_1); + if (pvVar3 != (void *)0x0) { + puVar2 = *(undefined4 **)((int)pvVar3 + 8); + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + *(undefined4 *)((int)pvVar3 + 8) = 0; + } + puVar2 = *(undefined4 **)((int)pvVar3 + 0xc); + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + *(undefined4 *)((int)pvVar3 + 0xc) = 0; + } + operator_delete(pvVar3); + return 1; + } + return 0; +} + + + +// --- FUN_00429230 at 0x00429230 (size: 45) --- + +undefined4 * __thiscall FUN_00429230(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00798708; + FUN_00428fa0(); + *param_1 = &PTR_LAB_00796c4c; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00429260 at 0x00429260 (size: 40) --- + +undefined4 FUN_00429260(int *param_1) + +{ + int iVar1; + + iVar1 = (**(code **)(*param_1 + 0x128))(); + if (iVar1 != 0) { + FUN_00429290(iVar1); + return 1; + } + return 0; +} + + + +// --- FUN_00429290 at 0x00429290 (size: 226) --- + +int __thiscall FUN_00429290(int param_1,int param_2) + +{ + undefined4 *puVar1; + undefined4 *puVar2; + undefined4 uVar3; + int iVar4; + undefined4 *puVar5; + undefined4 *local_10; + undefined1 local_c [12]; + + if (param_1 != param_2) { + FUN_00428be0(); + uVar3 = FUN_006b3a50(*(undefined4 *)(param_2 + 0x6c)); + FUN_00428650(uVar3); + uVar3 = FUN_006b3f60(local_c); + FUN_006b3f40(uVar3); + iVar4 = FUN_0052dcf0(local_c); + puVar1 = *(undefined4 **)(iVar4 + 8); + puVar2 = (undefined4 *)0x0; + while (puVar1 != local_10) { + puVar5 = (undefined4 *)FUN_005df0f5(0x10); + if (puVar5 == (undefined4 *)0x0) { + puVar5 = (undefined4 *)0x0; + } + else { + *puVar5 = *puVar1; + puVar5[1] = 0; + puVar5[2] = 0; + puVar5[3] = 0; + FUN_00429ab0(puVar1 + 2); + } + FUN_00599310(puVar5,puVar2); + FUN_00429380(); + puVar2 = puVar5; + } + } + return param_1; +} + + + +// --- FUN_00429380 at 0x00429380 (size: 55) --- + +void __fastcall FUN_00429380(int *param_1) + +{ + int iVar1; + int iVar2; + int *piVar3; + + iVar1 = *(int *)(param_1[2] + 4); + param_1[2] = iVar1; + if (iVar1 == 0) { + iVar1 = *(int *)(*param_1 + 0x68); + iVar2 = *(int *)(*param_1 + 0x60); + do { + piVar3 = (int *)(param_1[1] + 4); + param_1[1] = (int)piVar3; + if (piVar3 == (int *)(iVar2 + iVar1 * 4)) { + return; + } + } while (*piVar3 == 0); + param_1[2] = *piVar3; + } + return; +} + + + +// --- FUN_004293c0 at 0x004293C0 (size: 660) --- + +undefined4 * FUN_004293c0(undefined4 param_1) + +{ + int iVar1; + undefined4 *puVar2; + + switch(param_1) { + case 1: + puVar2 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar2 != (undefined4 *)0x0) { + *puVar2 = &PTR_LAB_00796ed0; + *(undefined1 *)(puVar2 + 2) = 0; + puVar2[1] = 1; + return puVar2; + } + break; + case 2: + puVar2 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar2 != (undefined4 *)0x0) { + *puVar2 = &PTR_LAB_00797690; + puVar2[2] = 0; + puVar2[1] = 1; + return puVar2; + } + break; + case 3: + puVar2 = (undefined4 *)FUN_005df0f5(0x10); + if (puVar2 != (undefined4 *)0x0) { + *puVar2 = &PTR_LAB_007977d0; + puVar2[2] = 0; + puVar2[3] = 0; + puVar2[1] = 1; + return puVar2; + } + break; + case 4: + puVar2 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar2 != (undefined4 *)0x0) { + *puVar2 = &PTR_LAB_00797410; + puVar2[2] = 0; + puVar2[1] = 1; + return puVar2; + } + break; + case 5: + iVar1 = FUN_005df0f5(0x14); + if (iVar1 != 0) { + puVar2 = (undefined4 *)FUN_004254f0(); + return puVar2; + } + break; + case 6: + iVar1 = FUN_005df0f5(0x18); + if (iVar1 != 0) { + puVar2 = (undefined4 *)FUN_00423db0(); + return puVar2; + } + break; + case 7: + iVar1 = FUN_005df0f5(0xc); + if (iVar1 != 0) { + puVar2 = (undefined4 *)FUN_004262b0(); + return puVar2; + } + break; + case 8: + iVar1 = FUN_005df0f5(0x98); + if (iVar1 != 0) { + puVar2 = (undefined4 *)FUN_00424fc0(); + return puVar2; + } + break; + case 9: + case 0x14: + puVar2 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar2 != (undefined4 *)0x0) { + *puVar2 = &PTR_LAB_007972d0; + puVar2[2] = 0; + puVar2[1] = 1; + return puVar2; + } + break; + case 10: + puVar2 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar2 != (undefined4 *)0x0) { + puVar2[1] = 1; + *puVar2 = &PTR_LAB_00797190; + puVar2[2] = DAT_00837d78; + return puVar2; + } + break; + case 0xb: + iVar1 = FUN_005df0f5(0x34); + if (iVar1 != 0) { + puVar2 = (undefined4 *)FUN_004256e0(); + return puVar2; + } + break; + case 0xc: + puVar2 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar2 != (undefined4 *)0x0) { + *puVar2 = &PTR_LAB_00797550; + puVar2[2] = 0; + puVar2[1] = 1; + return puVar2; + } + break; + case 0xd: + iVar1 = FUN_005df0f5(0x50); + if (iVar1 != 0) { + puVar2 = (undefined4 *)FUN_00424d50(); + return puVar2; + } + break; + case 0xe: + iVar1 = FUN_005df0f5(0x10); + if (iVar1 != 0) { + puVar2 = (undefined4 *)FUN_00425270(); + return puVar2; + } + break; + case 0xf: + puVar2 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar2 != (undefined4 *)0x0) { + *puVar2 = &PTR_LAB_00796c50; + puVar2[2] = 0; + puVar2[1] = 1; + return puVar2; + } + break; + case 0x10: + puVar2 = (undefined4 *)FUN_005df0f5(0x10); + if (puVar2 != (undefined4 *)0x0) { + *puVar2 = &PTR_LAB_00796d90; + puVar2[2] = 0; + puVar2[3] = 0; + puVar2[1] = 1; + return puVar2; + } + break; + case 0x11: + iVar1 = FUN_005df0f5(0x14); + if (iVar1 != 0) { + puVar2 = (undefined4 *)FUN_00426970(); + return puVar2; + } + break; + case 0x12: + iVar1 = FUN_005df0f5(0x7c); + if (iVar1 != 0) { + puVar2 = (undefined4 *)FUN_00429000(); + return puVar2; + } + break; + case 0x13: + iVar1 = FUN_005df0f5(0x10); + if (iVar1 != 0) { + puVar2 = (undefined4 *)FUN_00426660(); + return puVar2; + } + break; + case 0x15: + puVar2 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar2 != (undefined4 *)0x0) { + *puVar2 = &PTR_LAB_00797ba8; + puVar2[2] = 0xff; + puVar2[1] = 1; + return puVar2; + } + } + return (undefined4 *)0x0; +} + + + +// --- FUN_004296e0 at 0x004296E0 (size: 65) --- + +undefined4 * __thiscall FUN_004296e0(undefined4 *param_1,int param_2) + +{ + param_1[1] = 1; + *param_1 = &PTR_FUN_00798708; + param_1[2] = &PTR_FUN_00798700; + FUN_00428580(*(undefined4 *)(param_2 + 0x6c)); + FUN_00429290(param_2); + param_1[2] = &PTR_FUN_00798700; + return param_1; +} + + + +// --- FUN_00429760 at 0x00429760 (size: 407) --- + +void FUN_00429760(undefined4 param_1,int param_2,uint param_3) + +{ + uint uVar1; + char cVar2; + int iVar3; + byte *pbVar4; + undefined4 uVar5; + int *piVar6; + undefined4 uVar7; + uint uVar8; + int *piVar9; + int iVar10; + int iVar11; + undefined1 local_c [12]; + + uVar1 = param_3; + if ((~*(byte *)(param_3 + 4) & 1) != 0) { + FUN_005c2c80(); + } + if (((byte)*(undefined4 *)(uVar1 + 4) & 5) == 1) { + iVar3 = FUN_006b3a20(*(undefined4 *)(param_2 + 0x68)); + uVar8 = iVar3 - (int)PTR_DAT_00818554 >> 2; + } + else { + uVar8 = param_3 & 0xff; + } + FUN_0040ad10(1); + pbVar4 = (byte *)FUN_0040acf0(1); + if (pbVar4 != (byte *)0x0) { + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + uVar8 = (uint)*pbVar4; + } + else { + *pbVar4 = (byte)uVar8; + } + } + if ((*(byte *)(uVar1 + 4) & 5) == 0) { + if ((uVar8 & 0xff) < DAT_007956cc) { + uVar5 = FUN_006b3a50(*(undefined4 *)(PTR_DAT_00818554 + (uVar8 & 0xff) * 4)); + FUN_00428650(uVar5); + } + else { + FUN_0040aa50(); + } + } + if (((byte)*(undefined4 *)(uVar1 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x6c); + } + FUN_00401a80(¶m_3,¶m_3,uVar1); + if (((byte)*(undefined4 *)(uVar1 + 4) & 5) == 1) { + piVar6 = (int *)FUN_0052dcf0(local_c); + iVar3 = *piVar6; + piVar9 = (int *)piVar6[1]; + iVar10 = piVar6[2]; +LAB_00429843: + iVar11 = iVar10; + if (iVar10 != 0) { + do { + FUN_004449f0(iVar11,uVar1); + FUN_0042a330(uVar1); + iVar11 = *(int *)(iVar11 + 4); + } while (iVar11 != 0); + do { + piVar9 = piVar9 + 1; + iVar10 = iVar11; + if (piVar9 == (int *)(*(int *)(iVar3 + 0x60) + *(int *)(iVar3 + 0x68) * 4)) break; + iVar10 = *piVar9; + } while (iVar10 == 0); + goto LAB_00429843; + } + } + if ((*(byte *)(uVar1 + 4) & 5) == 0) { + uVar8 = FUN_0040a8f0(); + if (uVar8 < param_3) { +LAB_004298e8: + FUN_0040aa50(); + } + else { + uVar8 = 0; + uVar5 = 0; + if (param_3 != 0) { + while( true ) { + uVar7 = FUN_00429900(uVar5); + FUN_004449f0(uVar7,uVar1); + FUN_0042a330(uVar1); + if ((*(uint *)(uVar1 + 4) >> 2 & 1) != 0) break; + cVar2 = FUN_00599310(uVar7,uVar5); + if (cVar2 == '\0') goto LAB_004298e8; + uVar8 = uVar8 + 1; + uVar5 = uVar7; + if (param_3 <= uVar8) { + return; + } + } + } + } + } + return; +} + + + +// --- FUN_00429900 at 0x00429900 (size: 29) --- + +int FUN_00429900(void) + +{ + int iVar1; + + iVar1 = FUN_005df0f5(0x10); + if (iVar1 != 0) { + *(undefined4 *)(iVar1 + 4) = 0; + *(undefined4 *)(iVar1 + 8) = 0; + *(undefined4 *)(iVar1 + 0xc) = 0; + return iVar1; + } + return 0; +} + + + +// --- FUN_00429920 at 0x00429920 (size: 25) --- + +uint __thiscall FUN_00429920(int param_1,undefined4 *param_2) + +{ + undefined4 uVar1; + uint in_EAX; + + if (*(int *)(param_1 + 0xc) != 10) { + return in_EAX & 0xffffff00; + } + uVar1 = *(undefined4 *)(param_1 + 0x1c); + *param_2 = uVar1; + return CONCAT31((int3)((uint)uVar1 >> 8),1); +} + + + +// --- FUN_00429940 at 0x00429940 (size: 20) --- + +uint __fastcall FUN_00429940(int param_1) + +{ + uint in_EAX; + uint uVar1; + + if (*(int **)(param_1 + 4) != (int *)0x0) { + /* WARNING: Could not recover jumptable at 0x00429949. Too many branches */ + /* WARNING: Treating indirect jump as call */ + uVar1 = (**(code **)(**(int **)(param_1 + 4) + 0xa8))(); + return uVar1; + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00429960 at 0x00429960 (size: 25) --- + +undefined4 __fastcall FUN_00429960(int *param_1) + +{ + int iVar1; + + iVar1 = *param_1; + if (iVar1 != 0) { + return CONCAT31((int3)((uint)iVar1 >> 8),*(int *)(iVar1 + 0xa4) == 0); + } + return 0; +} + + + +// --- FUN_00429980 at 0x00429980 (size: 26) --- + +undefined4 __fastcall FUN_00429980(int *param_1) + +{ + int iVar1; + + iVar1 = *param_1; + if (iVar1 != 0) { + return CONCAT31((int3)((uint)iVar1 >> 8),*(int *)(iVar1 + 0xa4) == 1); + } + return 0; +} + + + +// --- FUN_004299a0 at 0x004299A0 (size: 16) --- + +undefined4 __fastcall FUN_004299a0(int *param_1) + +{ + int iVar1; + + iVar1 = *param_1; + if (iVar1 != 0) { + return CONCAT31((int3)((uint)iVar1 >> 8),*(undefined1 *)(iVar1 + 0xb9)); + } + return 0; +} + + + +// --- FUN_004299b0 at 0x004299B0 (size: 66) --- + +uint __thiscall FUN_004299b0(int *param_1,int *param_2) + +{ + char cVar1; + uint in_EAX; + + if ((*param_1 != 0) && ((int *)param_1[1] != (int *)0x0)) { + in_EAX = 0; + if (*param_2 != 0) { + if (*(int *)(*param_1 + 8) == *(int *)(*param_2 + 8)) { + cVar1 = (**(code **)(*(int *)param_1[1] + 8))(param_2[1]); + if (cVar1 != '\0') { + return 1; + } + } + return 0; + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00429a00 at 0x00429A00 (size: 11) --- + +undefined4 __fastcall FUN_00429a00(int *param_1) + +{ + if (*param_1 == 0) { + return 0; + } + return *(undefined4 *)(*param_1 + 8); +} + + + +// --- FUN_00429a10 at 0x00429A10 (size: 13) --- + +undefined4 __fastcall FUN_00429a10(int *param_1) + +{ + if (*param_1 != 0) { + return *(undefined4 *)(*param_1 + 0x10); + } + return 0; +} + + + +// --- FUN_00429a20 at 0x00429A20 (size: 43) --- + +void __thiscall FUN_00429a20(int *param_1,undefined4 param_2) + +{ + if (*param_1 == 0) { + FUN_004268d0(0,param_2); + return; + } + FUN_004268d0(*(undefined4 *)(*param_1 + 8),param_2); + return; +} + + + +// --- FUN_00429a50 at 0x00429A50 (size: 31) --- + +void __fastcall FUN_00429a50(undefined4 *param_1) + +{ + char *_Str; + int *piVar1; + + _Str = (char *)*param_1; + piVar1 = _errno(); + *piVar1 = 0; + strtol(_Str,(char **)0x0,0); + return; +} + + + +// --- FUN_00429a70 at 0x00429A70 (size: 44) --- + +undefined4 __thiscall FUN_00429a70(int param_1,undefined4 *param_2) + +{ + switch(*(undefined4 *)(param_1 + 0xc)) { + case 9: + case 0xf: + case 0x10: + case 0x14: + *param_2 = *(undefined4 *)(param_1 + 0x18); + return 1; + default: + return 0; + } +} + + + +// --- FUN_00429ab0 at 0x00429AB0 (size: 91) --- + +int * __thiscall FUN_00429ab0(int *param_1,int *param_2) + +{ + int *piVar1; + undefined4 *puVar2; + int iVar3; + + if (param_1 != param_2) { + puVar2 = (undefined4 *)*param_1; + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + *param_1 = 0; + } + iVar3 = *param_2; + if (iVar3 != 0) { + *param_1 = iVar3; + *(int *)(iVar3 + 4) = *(int *)(iVar3 + 4) + 1; + } + puVar2 = (undefined4 *)param_1[1]; + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + param_1[1] = 0; + } + iVar3 = param_2[1]; + if (iVar3 != 0) { + param_1[1] = iVar3; + *(int *)(iVar3 + 4) = *(int *)(iVar3 + 4) + 1; + } + } + return param_1; +} + + + +// --- FUN_00429b10 at 0x00429B10 (size: 43) --- + +void __fastcall FUN_00429b10(int param_1) + +{ + undefined4 *puVar1; + int iVar2; + undefined4 uVar3; + + puVar1 = *(undefined4 **)(param_1 + 4); + if ((puVar1 != (undefined4 *)0x0) && (puVar1[1] != 1)) { + iVar2 = puVar1[1] + -1; + puVar1[1] = iVar2; + if (iVar2 == 0) { + (**(code **)*puVar1)(1); + } + uVar3 = (**(code **)(**(int **)(param_1 + 4) + 4))(); + *(undefined4 *)(param_1 + 4) = uVar3; + } + return; +} + + + +// --- FUN_00429b40 at 0x00429B40 (size: 64) --- + +undefined4 * __thiscall FUN_00429b40(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00798888; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00429b80 at 0x00429B80 (size: 59) --- + +uint __fastcall FUN_00429b80(int param_1) + +{ + undefined4 *puVar1; + uint in_EAX; + int iVar2; + undefined4 uVar3; + uint uVar4; + + puVar1 = *(undefined4 **)(param_1 + 4); + if (puVar1 != (undefined4 *)0x0) { + if (puVar1[1] != 1) { + iVar2 = puVar1[1] + -1; + puVar1[1] = iVar2; + if (iVar2 == 0) { + (**(code **)*puVar1)(1); + } + uVar3 = (**(code **)(**(int **)(param_1 + 4) + 4))(); + *(undefined4 *)(param_1 + 4) = uVar3; + } + /* WARNING: Could not recover jumptable at 0x00429baf. Too many branches */ + /* WARNING: Treating indirect jump as call */ + uVar4 = (**(code **)(**(int **)(param_1 + 4) + 0x8c))(); + return uVar4; + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00429bc0 at 0x00429BC0 (size: 59) --- + +uint __fastcall FUN_00429bc0(int param_1) + +{ + undefined4 *puVar1; + uint in_EAX; + int iVar2; + undefined4 uVar3; + uint uVar4; + + puVar1 = *(undefined4 **)(param_1 + 4); + if (puVar1 != (undefined4 *)0x0) { + if (puVar1[1] != 1) { + iVar2 = puVar1[1] + -1; + puVar1[1] = iVar2; + if (iVar2 == 0) { + (**(code **)*puVar1)(1); + } + uVar3 = (**(code **)(**(int **)(param_1 + 4) + 4))(); + *(undefined4 *)(param_1 + 4) = uVar3; + } + /* WARNING: Could not recover jumptable at 0x00429bef. Too many branches */ + /* WARNING: Treating indirect jump as call */ + uVar4 = (**(code **)(**(int **)(param_1 + 4) + 0xac))(); + return uVar4; + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00429c00 at 0x00429C00 (size: 59) --- + +uint __fastcall FUN_00429c00(int param_1) + +{ + undefined4 *puVar1; + uint in_EAX; + int iVar2; + undefined4 uVar3; + uint uVar4; + + puVar1 = *(undefined4 **)(param_1 + 4); + if (puVar1 != (undefined4 *)0x0) { + if (puVar1[1] != 1) { + iVar2 = puVar1[1] + -1; + puVar1[1] = iVar2; + if (iVar2 == 0) { + (**(code **)*puVar1)(1); + } + uVar3 = (**(code **)(**(int **)(param_1 + 4) + 4))(); + *(undefined4 *)(param_1 + 4) = uVar3; + } + /* WARNING: Could not recover jumptable at 0x00429c2f. Too many branches */ + /* WARNING: Treating indirect jump as call */ + uVar4 = (**(code **)(**(int **)(param_1 + 4) + 0xc4))(); + return uVar4; + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00429c40 at 0x00429C40 (size: 33) --- + +undefined4 * __fastcall FUN_00429c40(undefined4 *param_1) + +{ + LONG *lpAddend; + + *param_1 = &PTR_FUN_00798140; + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[1] = PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + return param_1; +} + + + +// --- FUN_00429c70 at 0x00429C70 (size: 44) --- + +undefined4 * FUN_00429c70(undefined4 *param_1) + +{ + undefined4 *puVar1; + undefined1 local_c [12]; + + puVar1 = (undefined4 *)FUN_0052dcf0(local_c); + *param_1 = *puVar1; + param_1[1] = puVar1[1]; + param_1[2] = puVar1[2]; + return param_1; +} + + + +// --- FUN_00429ca0 at 0x00429CA0 (size: 55) --- + +void __fastcall FUN_00429ca0(int *param_1) + +{ + int iVar1; + int iVar2; + int *piVar3; + + iVar1 = *(int *)(param_1[2] + 4); + param_1[2] = iVar1; + if (iVar1 == 0) { + iVar1 = *(int *)(*param_1 + 0x68); + iVar2 = *(int *)(*param_1 + 0x60); + do { + piVar3 = (int *)(param_1[1] + 4); + param_1[1] = (int)piVar3; + if (piVar3 == (int *)(iVar2 + iVar1 * 4)) { + return; + } + } while (*piVar3 == 0); + param_1[2] = *piVar3; + } + return; +} + + + +// --- FUN_00429ce0 at 0x00429CE0 (size: 416) --- + +void __thiscall FUN_00429ce0(int *param_1,undefined4 param_2) + +{ + int *piVar1; + char cVar2; + undefined4 uVar3; + int *piVar4; + int iVar5; + int iVar6; + undefined4 uVar7; + int *local_a0; + undefined4 local_9c [2]; + int iStack_94; + undefined1 local_90 [144]; + + FUN_00425ba0(); + piVar1 = local_a0; + if (local_a0 != (int *)0x0) { + uVar7 = 0; + uVar3 = FUN_004220b0(local_a0[10],0); + FUN_0041a4e0(uVar3,uVar7); + } + if (*param_1 == 0) { + uVar3 = 0; + } + else { + uVar3 = *(undefined4 *)(*param_1 + 0xc); + } + switch(uVar3) { + case 8: + FUN_0042dc80(); + if (((int *)param_1[1] != (int *)0x0) && + (cVar2 = (**(code **)(*(int *)param_1[1] + 0xc0))(local_90), cVar2 != '\0')) { + FUN_0042ced0(param_2); + } + FUN_0042e590(); + break; + case 10: + if (((int *)param_1[1] != (int *)0x0) && + (cVar2 = (**(code **)(*(int *)param_1[1] + 0xb0))(local_9c), cVar2 != '\0')) { + local_a0 = (int *)0x0; + if (*param_1 != 0) { + FUN_00429920(&local_a0); + } + FUN_0041aaa0(local_9c[0],local_a0); + } + break; + case 0x11: + if ((int *)param_1[1] == (int *)0x0) { +LAB_00429e68: + if (piVar1 == (int *)0x0) { + return; + } + (**(code **)(*piVar1 + 0x14))(); + return; + } + piVar4 = (int *)(**(code **)(*(int *)param_1[1] + 0x108))(); + if (piVar4 == (int *)0x0) { +LAB_00429e53: + FUN_0049b890(); + return; + } + iVar6 = *piVar4; + iVar5 = iVar6 + piVar4[2] * 8; + for (; iVar6 != iVar5; iVar6 = iVar6 + 8) { + FUN_00429ce0(param_2); + } + break; + case 0x12: + if ((int *)param_1[1] == (int *)0x0) goto LAB_00429e68; + iVar5 = (**(code **)(*(int *)param_1[1] + 0x128))(); + if (iVar5 == 0) goto LAB_00429e53; + FUN_00429c70(local_9c); + while (iStack_94 != 0) { + FUN_00429ce0(param_2); + FUN_00429ca0(); + } + } + if (piVar1 != (int *)0x0) { + (**(code **)(*piVar1 + 0x14))(); + } + return; +} + + + +// --- FUN_00429ea0 at 0x00429EA0 (size: 157) --- + +undefined4 __thiscall FUN_00429ea0(int *param_1,undefined *param_2) + +{ + char cVar1; + undefined4 uVar2; + int iVar3; + undefined *puVar4; + + if (((param_2 != (undefined *)0x0) && (*param_1 != 0)) && (param_1[1] != 0)) { + param_2 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + uVar2 = 0; + if (*param_1 != 0) { + uVar2 = *(undefined4 *)(*param_1 + 8); + } + cVar1 = FUN_004268d0(uVar2,¶m_2); + if (cVar1 != '\0') { + puVar4 = param_2; + InterlockedIncrement((LONG *)(param_2 + -0x10)); + iVar3 = FUN_00426f90(puVar4); + if ((iVar3 != 0) && + (cVar1 = (**(code **)(*(int *)param_1[1] + 100))(*param_1,iVar3), cVar1 != '\0')) { + FUN_004011b0(); + return 1; + } + } + FUN_004011b0(); + } + return 0; +} + + + +// --- FUN_00429f40 at 0x00429F40 (size: 87) --- + +undefined4 __thiscall FUN_00429f40(int *param_1,undefined4 param_2) + +{ + char cVar1; + undefined4 extraout_ECX; + undefined4 uVar2; + + if ((*param_1 != 0) && (param_1[1] != 0)) { + if (*(int *)(*param_1 + 8) != 0) { + FUN_00429b10(); + } + cVar1 = (**(code **)(*(int *)param_1[1] + 0x60))(*param_1,param_2); + if (cVar1 != '\0') { + return 1; + } + uVar2 = extraout_ECX; + FUN_00401340("unable to read property value"); + FUN_0065d620(param_2,uVar2); + } + return 0; +} + + + +// --- FUN_00429fa0 at 0x00429FA0 (size: 143) --- + +undefined4 * __thiscall FUN_00429fa0(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00798888; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_0042a030 at 0x0042A030 (size: 143) --- + +void __fastcall FUN_0042a030(int param_1) + +{ + int iVar1; + undefined4 *puVar2; + void *pvVar3; + void *pvVar4; + int *piVar5; + void *pvVar6; + + iVar1 = *(int *)(param_1 + 0x6c); + do { + if (iVar1 == 0) { + return; + } + piVar5 = *(int **)(param_1 + 100); + while (piVar5 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar5 = *(int **)(param_1 + 100); + pvVar6 = (void *)*piVar5; + goto LAB_0042a06f; + } + piVar5 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar5; + } + piVar5 = (int *)0x0; + pvVar6 = (void *)0x0; +LAB_0042a06f: + pvVar4 = (void *)*piVar5; + if (pvVar4 == pvVar6) { +LAB_0042a082: + *piVar5 = *(int *)((int)pvVar4 + 4); + } + else { + do { + pvVar3 = pvVar4; + pvVar4 = *(void **)((int)pvVar3 + 4); + } while (pvVar4 != pvVar6); + if (pvVar3 == (void *)0x0) goto LAB_0042a082; + *(undefined4 *)((int)pvVar3 + 4) = *(undefined4 *)((int)pvVar4 + 4); + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + if (pvVar6 != (void *)0x0) { + puVar2 = *(undefined4 **)((int)pvVar6 + 8); + if (puVar2 != (undefined4 *)0x0) { + piVar5 = puVar2 + 1; + *piVar5 = *piVar5 + -1; + if (*piVar5 == 0) { + (**(code **)*puVar2)(1); + } + } + operator_delete(pvVar6); + } + iVar1 = *(int *)(param_1 + 0x6c); + } while( true ); +} + + + +// --- FUN_0042a0c0 at 0x0042A0C0 (size: 113) --- + +undefined4 FUN_0042a0c0(undefined4 *param_1,int *param_2) + +{ + int *piVar1; + int iVar2; + undefined4 *puVar3; + char cVar4; + undefined4 *puVar5; + + puVar5 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar5 == (undefined4 *)0x0) { + puVar5 = (undefined4 *)0x0; + } + else { + *puVar5 = *param_1; + puVar5[1] = 0; + iVar2 = *param_2; + puVar5[2] = iVar2; + if (iVar2 != 0) { + *(int *)(iVar2 + 4) = *(int *)(iVar2 + 4) + 1; + } + } + cVar4 = FUN_0042bd40(puVar5); + if (cVar4 != '\0') { + return 1; + } + if (puVar5 != (undefined4 *)0x0) { + puVar3 = (undefined4 *)puVar5[2]; + if (puVar3 != (undefined4 *)0x0) { + piVar1 = puVar3 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar3)(1); + } + } + operator_delete(puVar5); + } + return 0; +} + + + +// --- FUN_0042a140 at 0x0042A140 (size: 123) --- + +undefined4 * FUN_0042a140(uint param_1) + +{ + int *piVar1; + uint *puVar2; + undefined4 *puVar3; + undefined4 *local_4; + + puVar2 = *(uint **)(DAT_00818944 + (param_1 % DAT_0081894c) * 4); + do { + if (puVar2 == (uint *)0x0) { +LAB_0042a16b: + puVar3 = (undefined4 *)FUN_004293c0(param_1); + if (puVar3 != (undefined4 *)0x0) { + puVar3[1] = puVar3[1] + 1; + local_4 = puVar3; + FUN_0042a0c0(¶m_1,&local_4); + piVar1 = puVar3 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar3)(1); + } + } + return puVar3; + } + if (*puVar2 == param_1) { + if ((puVar2 != (uint *)0x0) && (puVar2 + 2 != (uint *)0x0)) { + puVar3 = (undefined4 *)puVar2[2]; + piVar1 = puVar3 + 1; + *piVar1 = *piVar1 + 1; + return puVar3; + } + goto LAB_0042a16b; + } + puVar2 = (uint *)puVar2[1]; + } while( true ); +} + + + +// --- FUN_0042a1c0 at 0x0042A1C0 (size: 96) --- + +uint __fastcall FUN_0042a1c0(int *param_1) + +{ + int *piVar1; + undefined4 *puVar2; + int iVar3; + int iVar4; + uint uVar5; + undefined4 uVar6; + + if (*param_1 != 0) { + puVar2 = (undefined4 *)param_1[1]; + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + param_1[1] = 0; + } + iVar3 = *param_1; + iVar4 = *(int *)(iVar3 + 0x20); + if (iVar4 != 0) { + param_1[1] = iVar4; + *(int *)(iVar4 + 4) = *(int *)(iVar4 + 4) + 1; + return CONCAT31((int3)((uint)iVar4 >> 8),1); + } + if (iVar3 == 0) { + uVar6 = 0; + } + else { + uVar6 = *(undefined4 *)(iVar3 + 0xc); + } + uVar5 = FUN_0042a140(uVar6); + param_1[1] = uVar5; + if (uVar5 != 0) { + return uVar5 & 0xffffff00; + } + } + return 0; +} + + + +// --- FUN_0042a220 at 0x0042A220 (size: 82) --- + +undefined4 * __thiscall FUN_0042a220(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007988b4; + FUN_0042a030(); + param_1[1] = &PTR_FUN_00798888; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0042a280 at 0x0042A280 (size: 77) --- + +undefined4 __thiscall FUN_0042a280(int *param_1,int param_2) + +{ + int *piVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)*param_1; + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + *param_1 = 0; + } + puVar2 = (undefined4 *)param_1[1]; + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + param_1[1] = 0; + } + if (param_2 != 0) { + *param_1 = param_2; + *(int *)(param_2 + 4) = *(int *)(param_2 + 4) + 1; + FUN_0042a1c0(); + } + return 1; +} + + + +// --- FUN_0042a2d0 at 0x0042A2D0 (size: 83) --- + +uint FUN_0042a2d0(int *param_1) + +{ + uint uVar1; + int iVar2; + + iVar2 = 0; + if (param_1 == (int *)0x0) { +LAB_0042a306: + uVar1 = FUN_0042a280(iVar2); + return uVar1; + } + uVar1 = FUN_00425ba0(); + if (param_1 != (int *)0x0) { + iVar2 = FUN_004284b0(param_1); + if (iVar2 != 0) { + (**(code **)(*param_1 + 0x14))(); + goto LAB_0042a306; + } + uVar1 = (**(code **)(*param_1 + 0x14))(); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_0042a330 at 0x0042A330 (size: 231) --- + +void __thiscall FUN_0042a330(int *param_1,int param_2) + +{ + char cVar1; + undefined4 *puVar2; + int *piVar3; + int iVar4; + undefined4 uVar5; + + if ((*(byte *)(param_2 + 4) & 1) != 0) { + if (*param_1 == 0) { + uVar5 = 0; + } + else { + uVar5 = *(undefined4 *)(*param_1 + 8); + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if ((puVar2 != (undefined4 *)0x0) && ((*(byte *)(param_2 + 4) & 1) != 0)) { + *puVar2 = uVar5; + } + } + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + FUN_0040ad10(4); + piVar3 = (int *)FUN_0040acf0(4); + iVar4 = param_2; + if (piVar3 != (int *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + iVar4 = *piVar3; + } + else { + *piVar3 = param_2; + } + } + cVar1 = FUN_0042a2d0(iVar4); + if (cVar1 == '\0') { + FUN_0040aa50(); + } + if (*param_1 == 0) { + return; + } + if (((*(int *)(*param_1 + 8) != 0) && + (puVar2 = (undefined4 *)param_1[1], puVar2 != (undefined4 *)0x0)) && (puVar2[1] != 1)) { + iVar4 = puVar2[1] + -1; + puVar2[1] = iVar4; + if (iVar4 == 0) { + (**(code **)*puVar2)(1); + } + iVar4 = (**(code **)(*(int *)param_1[1] + 4))(); + param_1[1] = iVar4; + } + } + if ((*param_1 != 0) && (iVar4 = *(int *)(*param_1 + 8), iVar4 != 0)) { + if ((int *)param_1[1] == (int *)0x0) { + FUN_0040aa50(); + return; + } + (**(code **)(*(int *)param_1[1] + 0x5c))(param_2,iVar4); + } + return; +} + + + +// --- FUN_0042a420 at 0x0042A420 (size: 220) --- + +undefined4 FUN_0042a420(undefined *param_1) + +{ + int iVar1; + char cVar2; + LONG LVar3; + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined4 *puVar4; + undefined4 uVar5; + undefined *puVar6; + undefined4 local_4; + + iVar1 = (int)param_1; + if (param_1 != (undefined *)0x0) { + param_1 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00426020(¶m_1); + cVar2 = FUN_004271f0(¶m_1,&local_4); + if (cVar2 == '\0') { + uVar5 = extraout_ECX; + puVar6 = param_1; + FUN_00401340("invalid property name \'%s\'"); + FUN_0065d620(iVar1,uVar5,puVar6); + } + else { + cVar2 = FUN_0042a2d0(local_4); + if (cVar2 != '\0') { + cVar2 = FUN_00429f40(iVar1); + if (cVar2 == '\0') { + FUN_004011b0(); + return 0; + } + FUN_004011b0(); + return 1; + } + uVar5 = extraout_ECX_00; + FUN_00401340("unable to initialize property"); + FUN_0065d620(iVar1,uVar5); + } + puVar4 = (undefined4 *)(param_1 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(param_1 + -0x10)); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + } + return 0; +} + + + +// --- FUN_0042a500 at 0x0042A500 (size: 64) --- + +uint __thiscall FUN_0042a500(int param_1,undefined4 param_2,undefined4 param_3) + +{ + uint uVar1; + + uVar1 = *(uint *)(param_1 + 0xc); + if (uVar1 == 9) { + uVar1 = FUN_0041b220(*(undefined4 *)(param_1 + 0x18),param_2,param_3); + return uVar1; + } + if (uVar1 == 0x14) { + uVar1 = FUN_004268d0(param_2,param_3); + return uVar1; + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_0042a540 at 0x0042A540 (size: 64) --- + +undefined4 * __thiscall FUN_0042a540(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00798908; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0042a580 at 0x0042A580 (size: 48) --- + +void __fastcall FUN_0042a580(int param_1) + +{ + switch(*(int *)(param_1 + 0xc)) { + case 9: + case 0xf: + case 0x10: + case 0x14: + /* WARNING: Could not recover jumptable at 0x0042a5a3. Too many branches */ + /* WARNING: Treating indirect jump as call */ + (**(code **)(&DAT_0042a5e0 + (uint)(&BYTE_0042a5df)[*(int *)(param_1 + 0xc)] * 4))(); + return; + default: + return; + } +} + + + +// --- FUN_0042a600 at 0x0042A600 (size: 1048) --- + +void __thiscall FUN_0042a600(int param_1,uint param_2) + +{ + uint uVar1; + undefined4 *puVar2; + int *piVar3; + byte *pbVar4; + int iVar5; + byte bVar6; + undefined4 uVar7; + + uVar1 = param_2; + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 8) = *puVar2; + } + else { + *puVar2 = *(undefined4 *)(param_1 + 8); + } + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0xc) = *puVar2; + } + else { + *puVar2 = *(undefined4 *)(param_1 + 0xc); + } + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x10) = *puVar2; + } + else { + *puVar2 = *(undefined4 *)(param_1 + 0x10); + } + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x14) = *puVar2; + } + else { + *puVar2 = *(undefined4 *)(param_1 + 0x14); + } + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x18) = *puVar2; + } + else { + *puVar2 = *(undefined4 *)(param_1 + 0x18); + } + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x1c) = *puVar2; + } + else { + *puVar2 = *(undefined4 *)(param_1 + 0x1c); + } + } + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + if ((~*(byte *)(uVar1 + 4) & 1) != 0) { + puVar2 = *(undefined4 **)(param_1 + 0x20); + if (puVar2 != (undefined4 *)0x0) { + piVar3 = puVar2 + 1; + *piVar3 = *piVar3 + -1; + if (*piVar3 == 0) { + (**(code **)*puVar2)(1); + } + *(undefined4 *)(param_1 + 0x20) = 0; + } + param_2 = param_2 & 0xffffff00; + FUN_00422250(¶m_2,uVar1); + if ((char)param_2 != '\0') { + piVar3 = (int *)FUN_004293c0(*(undefined4 *)(param_1 + 0xc)); + *(int **)(param_1 + 0x20) = piVar3; + if (piVar3 != (int *)0x0) { + uVar7 = *(undefined4 *)(param_1 + 8); + iVar5 = *piVar3; + goto LAB_0042a77e; + } + } + } + } + else { + param_2 = CONCAT31(param_2._1_3_,*(int *)(param_1 + 0x20) != 0); + FUN_00422250(¶m_2,uVar1); + if (*(int **)(param_1 + 0x20) != (int *)0x0) { + uVar7 = *(undefined4 *)(param_1 + 8); + iVar5 = **(int **)(param_1 + 0x20); +LAB_0042a77e: + (**(code **)(iVar5 + 0x5c))(uVar1,uVar7); + } + } + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + if ((~*(byte *)(uVar1 + 4) & 1) != 0) { + puVar2 = *(undefined4 **)(param_1 + 0x24); + if (puVar2 != (undefined4 *)0x0) { + piVar3 = puVar2 + 1; + *piVar3 = *piVar3 + -1; + if (*piVar3 == 0) { + (**(code **)*puVar2)(1); + } + *(undefined4 *)(param_1 + 0x24) = 0; + } + param_2 = param_2 & 0xffffff00; + FUN_00422250(¶m_2,uVar1); + if ((char)param_2 != '\0') { + piVar3 = (int *)FUN_004293c0(*(undefined4 *)(param_1 + 0xc)); + *(int **)(param_1 + 0x24) = piVar3; + if (piVar3 != (int *)0x0) { + uVar7 = *(undefined4 *)(param_1 + 8); + iVar5 = *piVar3; + goto LAB_0042a807; + } + } + } + } + else { + param_2 = CONCAT31(param_2._1_3_,*(int *)(param_1 + 0x24) != 0); + FUN_00422250(¶m_2,uVar1); + if (*(int **)(param_1 + 0x24) != (int *)0x0) { + uVar7 = *(undefined4 *)(param_1 + 8); + iVar5 = **(int **)(param_1 + 0x24); +LAB_0042a807: + (**(code **)(iVar5 + 0x5c))(uVar1,uVar7); + } + } + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + if ((~*(byte *)(uVar1 + 4) & 1) == 0) goto LAB_0042a894; + puVar2 = *(undefined4 **)(param_1 + 0x28); + if (puVar2 != (undefined4 *)0x0) { + piVar3 = puVar2 + 1; + *piVar3 = *piVar3 + -1; + if (*piVar3 == 0) { + (**(code **)*puVar2)(1); + } + *(undefined4 *)(param_1 + 0x28) = 0; + } + param_2 = param_2 & 0xffffff00; + FUN_00422250(¶m_2,uVar1); + if ((char)param_2 == '\0') goto LAB_0042a894; + piVar3 = (int *)FUN_004293c0(*(undefined4 *)(param_1 + 0xc)); + *(int **)(param_1 + 0x28) = piVar3; + if (piVar3 == (int *)0x0) goto LAB_0042a894; + uVar7 = *(undefined4 *)(param_1 + 8); + iVar5 = *piVar3; + } + else { + param_2 = CONCAT31(param_2._1_3_,*(int *)(param_1 + 0x28) != 0); + FUN_00422250(¶m_2,uVar1); + if (*(int **)(param_1 + 0x28) == (int *)0x0) goto LAB_0042a894; + uVar7 = *(undefined4 *)(param_1 + 8); + iVar5 = **(int **)(param_1 + 0x28); + } + (**(code **)(iVar5 + 0x5c))(uVar1,uVar7); +LAB_0042a894: + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 200) = *puVar2; + } + else { + *puVar2 = *(undefined4 *)(param_1 + 200); + } + } + bVar6 = *(byte *)(param_1 + 0xa0); + FUN_0040ad10(1); + pbVar4 = (byte *)FUN_0040acf0(1); + if (pbVar4 != (byte *)0x0) { + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + bVar6 = *pbVar4; + } + else { + *pbVar4 = bVar6; + } + } + if ((*(byte *)(uVar1 + 4) & 5) == 0) { + *(uint *)(param_1 + 0xa0) = (uint)bVar6; + } + bVar6 = *(byte *)(param_1 + 0xa4); + FUN_0040ad10(1); + pbVar4 = (byte *)FUN_0040acf0(1); + if (pbVar4 != (byte *)0x0) { + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + bVar6 = *pbVar4; + } + else { + *pbVar4 = bVar6; + } + } + if ((*(byte *)(uVar1 + 4) & 5) == 0) { + *(uint *)(param_1 + 0xa4) = (uint)bVar6; + } + bVar6 = *(byte *)(param_1 + 0xa8); + FUN_0040ad10(1); + pbVar4 = (byte *)FUN_0040acf0(1); + if (pbVar4 != (byte *)0x0) { + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + bVar6 = *pbVar4; + } + else { + *pbVar4 = bVar6; + } + } + if ((*(byte *)(uVar1 + 4) & 5) == 0) { + *(uint *)(param_1 + 0xa8) = (uint)bVar6; + } + bVar6 = *(byte *)(param_1 + 0xac); + FUN_0040ad10(1); + pbVar4 = (byte *)FUN_0040acf0(1); + if (pbVar4 != (byte *)0x0) { + if ((*(byte *)(uVar1 + 4) & 1) == 0) { + bVar6 = *pbVar4; + } + else { + *pbVar4 = bVar6; + } + } + if ((*(byte *)(uVar1 + 4) & 5) == 0) { + *(uint *)(param_1 + 0xac) = (uint)bVar6; + } + FUN_00422250(param_1 + 0xb0,uVar1); + FUN_00422250(param_1 + 0xb1,uVar1); + FUN_00422250(param_1 + 0xb3,uVar1); + FUN_00422250(param_1 + 0xb8,uVar1); + FUN_00422250(param_1 + 0xb7,uVar1); + FUN_00422250(param_1 + 0xb4,uVar1); + FUN_00422250(param_1 + 0xb5,uVar1); + FUN_00422250(param_1 + 0xb2,uVar1); + FUN_0042c070(uVar1); + return; +} + + + +// --- FUN_0042aa20 at 0x0042AA20 (size: 120) --- + +void FUN_0042aa20(void) + +{ + int iVar1; + int *piVar2; + int *piVar3; + undefined4 *puVar4; + int *local_10; + undefined1 local_c [12]; + + FUN_00425ba0(); + if (local_10 != (int *)0x0) { + piVar2 = (int *)FUN_0052dcf0(local_c); + piVar3 = (int *)piVar2[2]; + iVar1 = *piVar2; + puVar4 = (undefined4 *)piVar2[1]; + while (piVar3 != (int *)0x0) { + do { + if (*piVar3 != 0) { + FUN_0042be30(*piVar3); + } + piVar3 = (int *)piVar3[1]; + } while (piVar3 != (int *)0x0); + do { + puVar4 = puVar4 + 1; + if (puVar4 == (undefined4 *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) + goto LAB_0042aa88; + piVar3 = (int *)*puVar4; + } while (piVar3 == (int *)0x0); + } +LAB_0042aa88: + (**(code **)(*local_10 + 0x14))(); + } + return; +} + + + +// --- FUN_0042aaa0 at 0x0042AAA0 (size: 34) --- + +undefined ** __fastcall FUN_0042aaa0(int param_1) + +{ + if (*(char *)(param_1 + 0xb6) != '\0') { + if (DAT_008189d8 == 0) { + FUN_0042aa20(); + } + return &PTR_PTR_00818968; + } + return (undefined **)(param_1 + 0x2c); +} + + + +// --- FUN_0042aad0 at 0x0042AAD0 (size: 143) --- + +undefined4 * __thiscall FUN_0042aad0(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00798908; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_0042ab60 at 0x0042AB60 (size: 67) --- + +void FUN_0042ab60(undefined4 param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + + puVar1 = PTR_DAT_00818558; + puVar2 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_1,param_1,0); + if (puVar2 == (undefined4 *)puVar1) { + puVar2 = puVar2 + -1; + } + FUN_0046c280(*puVar2); + return; +} + + + +// --- FUN_0042abb0 at 0x0042ABB0 (size: 82) --- + +undefined4 * __thiscall FUN_0042abb0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079890c; + FUN_005870f0(); + param_1[1] = &PTR_FUN_00798908; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0042ac10 at 0x0042AC10 (size: 207) --- + +undefined4 * __fastcall FUN_0042ac10(undefined4 *param_1) + +{ + LONG *lpAddend; + + param_1[1] = 1; + *param_1 = &PTR_FUN_00798910; + param_1[2] = 0; + param_1[3] = 0; + param_1[4] = 0; + param_1[5] = 1; + param_1[6] = 0; + param_1[7] = 0; + param_1[8] = 0; + param_1[9] = 0; + param_1[10] = 0; + param_1[0xb] = &PTR_FUN_0079890c; + FUN_0042aad0(0x17); + param_1[0x28] = 2; + param_1[0x29] = 2; + param_1[0x2a] = 4; + param_1[0x2b] = 0; + *(undefined1 *)(param_1 + 0x2c) = 0; + *(undefined1 *)((int)param_1 + 0xb1) = 0; + *(undefined1 *)((int)param_1 + 0xb2) = 0; + *(undefined1 *)((int)param_1 + 0xb3) = 0; + *(undefined1 *)(param_1 + 0x2d) = 0; + *(undefined1 *)((int)param_1 + 0xb5) = 0; + *(undefined1 *)((int)param_1 + 0xb6) = 0; + *(undefined1 *)((int)param_1 + 0xb7) = 0; + *(undefined1 *)(param_1 + 0x2e) = 0; + param_1[0x2f] = 0; + param_1[0x30] = 0xffff; + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x31] = PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + param_1[0x32] = DAT_007988f4; + return param_1; +} + + + +// --- FUN_0042ace0 at 0x0042ACE0 (size: 175) --- + +void __fastcall FUN_0042ace0(undefined4 *param_1) + +{ + int *piVar1; + LONG LVar2; + undefined4 *puVar3; + + puVar3 = (undefined4 *)param_1[8]; + *param_1 = &PTR_FUN_00798910; + if (puVar3 != (undefined4 *)0x0) { + piVar1 = puVar3 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar3)(1); + } + param_1[8] = 0; + } + puVar3 = (undefined4 *)param_1[9]; + if (puVar3 != (undefined4 *)0x0) { + piVar1 = puVar3 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar3)(1); + } + param_1[9] = 0; + } + puVar3 = (undefined4 *)param_1[10]; + if (puVar3 != (undefined4 *)0x0) { + piVar1 = puVar3 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar3)(1); + } + param_1[10] = 0; + } + puVar3 = (undefined4 *)(param_1[0x31] + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_1[0x31] + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + param_1[0xb] = &PTR_FUN_0079890c; + FUN_005870f0(); + param_1[0xc] = &PTR_FUN_00798908; + if ((undefined4 *)param_1[0x24] != param_1 + 0xd) { + operator_delete__((undefined4 *)param_1[0x24]); + } + param_1[0x24] = 0; + param_1[0x25] = 0; + param_1[0x26] = 0; + param_1[0x27] = 0; + *param_1 = &PTR_LAB_00796c4c; + return; +} + + + +// --- FUN_0042ad90 at 0x0042AD90 (size: 30) --- + +void * __thiscall FUN_0042ad90(void *param_1,byte param_2) + +{ + FUN_0042ace0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0042af10 at 0x0042AF10 (size: 181) --- + +undefined4 * __thiscall FUN_0042af10(int *param_1,undefined4 *param_2,int *param_3) + +{ + int *piVar1; + int iVar2; + undefined *puVar3; + LONG LVar4; + int *piVar5; + + puVar3 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + if (param_1[2] != 0) { + piVar5 = (int *)*param_1; + piVar1 = piVar5 + param_1[2] + -1; + for (; piVar5 != piVar1; piVar5 = piVar5 + 1) { + iVar2 = *(int *)(*piVar5 + -4); + if (iVar2 != 1) { + FUN_00404ef0(*piVar5,iVar2 + -1); + } + iVar2 = *(int *)(*param_3 + -4); + if (iVar2 != 1) { + FUN_00404ef0(*param_3,iVar2 + -1); + } + } + iVar2 = *(int *)(*piVar5 + -4); + if (iVar2 != 1) { + FUN_00404ef0(*piVar5,iVar2 + -1); + } + } + *param_2 = puVar3; + InterlockedIncrement((LONG *)(puVar3 + -0x10)); + LVar4 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(puVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar3 + -0x14))(1); + } + return param_2; +} + + + +// --- FUN_0042b1b0 at 0x0042B1B0 (size: 97) --- + +/* WARNING: Removing unreachable block (ram,0x0042b23e) */ + +undefined1 __thiscall FUN_0042b1b0(int param_1,int param_2,int param_3) + +{ + char cVar1; + undefined1 uVar2; + int extraout_ECX; + int *unaff_EBX; + + if (param_3 != 0) { + switch(*(undefined4 *)(param_2 + 0xc)) { + case 9: + case 0xf: + case 0x10: + case 0x14: + cVar1 = FUN_00677f00(*(undefined4 *)(param_2 + 0x18)); + param_2 = extraout_ECX; + if (cVar1 != '\0') { + uVar2 = func_0x00678490(*(undefined4 *)(param_1 + 8),*(undefined4 *)(param_1 + 0xc),param_3) + ; + if (unaff_EBX != (int *)0x0) { + (**(code **)(*unaff_EBX + 0x14))(); + } + return uVar2; + } + } + FUN_00401340("There was a problem with the emp"); + FUN_0065d620(param_3,param_2); + } + return 0; +} + + + +// --- FUN_0042b3a0 at 0x0042B3A0 (size: 162) --- + +undefined4 __thiscall FUN_0042b3a0(int param_1,int param_2,int param_3) + +{ + undefined4 *puVar1; + int iVar2; + LONG LVar3; + + iVar2 = param_3; + if (*(int *)(param_1 + 8) == 0) { + FUN_00402710(param_3,""); + } + else { + FUN_00402710(param_3,"0x%08X",*(int *)(param_1 + 8)); + if (*(int *)(param_2 + 0xc) != 10) { + return 0; + } + FUN_00679220(¶m_3,*(undefined4 *)(param_1 + 8),*(undefined4 *)(param_2 + 0x18)); + if (*(int *)(param_3 + -4) != 1) { + FUN_00402710(iVar2,&DAT_007955ac,param_3); + } + puVar1 = (undefined4 *)(param_3 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar3 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + return 1; + } + } + return 1; +} + + + +// --- FUN_0042b450 at 0x0042B450 (size: 143) --- + +bool FUN_0042b450(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + undefined *puVar1; + char cVar2; + LONG LVar3; + undefined4 extraout_ECX; + undefined *puVar4; + undefined4 uVar5; + undefined *local_4; + + local_4 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00426020(&local_4); + puVar1 = local_4; + puVar4 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + cVar2 = FUN_0041bac0(param_2,puVar4,param_3); + if (cVar2 == '\0') { + uVar5 = extraout_ECX; + puVar4 = puVar1; + FUN_00401340("invalid emp value \'%s\'"); + FUN_0065d620(param_1,uVar5,puVar4); + } + LVar3 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + return cVar2 != '\0'; +} + + + +// --- FUN_0042b4e0 at 0x0042B4E0 (size: 52) --- + +uint FUN_0042b4e0(undefined4 param_1) + +{ + int iVar1; + uint uVar2; + undefined4 extraout_ECX; + undefined4 uVar3; + + iVar1 = FUN_0065ca90(); + if (iVar1 != 0) { + uVar2 = FUN_0042b450(); + return uVar2; + } + uVar3 = extraout_ECX; + FUN_00401340("Expecting a leaf node"); + uVar2 = FUN_0065d620(param_1,uVar3); + return uVar2 & 0xffffff00; +} + + + +// --- FUN_0042b520 at 0x0042B520 (size: 154) --- + +undefined1 FUN_0042b520(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + LONG *lpAddend; + undefined *puVar1; + char cVar2; + LONG LVar3; + undefined1 uVar4; + undefined4 *puVar5; + undefined *puVar6; + undefined *local_4; + + local_4 = PTR_DAT_00818344; + uVar4 = 0; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + cVar2 = FUN_0041b220(param_2,param_3,&local_4); + puVar1 = local_4; + if (cVar2 != '\0') { + lpAddend = (LONG *)(local_4 + -0x10); + InterlockedIncrement(lpAddend); + puVar6 = puVar1; + InterlockedIncrement(lpAddend); + FUN_00427050(puVar6); + LVar3 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + uVar4 = 1; + } + puVar5 = (undefined4 *)(local_4 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar3 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + return uVar4; +} + + + +// --- FUN_0042b5c0 at 0x0042B5C0 (size: 60) --- + +int FUN_0042b5c0(int *param_1,undefined4 param_2,undefined4 param_3) + +{ + char cVar1; + int iVar2; + + iVar2 = (**(code **)(*param_1 + 4))(); + if (iVar2 != 0) { + cVar1 = FUN_0042b520(iVar2,param_2,param_3); + if (cVar1 == '\0') { + FUN_0065d360(iVar2); + return 0; + } + } + return iVar2; +} + + + +// --- FUN_0042b940 at 0x0042B940 (size: 135) --- + +void FUN_0042b940(undefined4 param_1,undefined4 param_2) + +{ + int iVar1; + undefined4 *local_8; + undefined4 *local_4; + + local_8 = (undefined4 *)0x0; + local_4 = (undefined4 *)0x0; + FUN_00429ab0(param_1); + FUN_00429ab0(param_2); + FUN_00429ab0(&local_8); + if (local_8 != (undefined4 *)0x0) { + iVar1 = local_8[1]; + local_8[1] = iVar1 + -1; + if (iVar1 + -1 == 0) { + (**(code **)*local_8)(1); + } + local_8 = (undefined4 *)0x0; + } + if ((local_4 != (undefined4 *)0x0) && + (iVar1 = local_4[1], local_4[1] = iVar1 + -1, iVar1 + -1 == 0)) { + (**(code **)*local_4)(1); + } + return; +} + + + +// --- FUN_0042baa0 at 0x0042BAA0 (size: 584) --- + +uint FUN_0042baa0(int param_1,int *param_2) + +{ + bool bVar1; + char cVar2; + uint in_EAX; + uint uVar3; + undefined4 uVar4; + LONG LVar5; + undefined4 extraout_ECX; + undefined4 *puVar6; + int iVar7; + int iVar8; + int iVar9; + undefined1 local_26; + int iStack_24; + int iStack_20; + uint local_1c; + int local_18; + uint local_14; + undefined4 *local_10; + undefined4 *local_c; + + if (param_2 == (int *)0x0) { + return in_EAX & 0xffffff00; + } + local_14 = FUN_0065ca40(); + if ((DAT_00837720 == -0x7ffffffe) || (bVar1 = false, DAT_00837720 == -0x7fffffff)) { + bVar1 = true; + } + uVar3 = 0; + local_26 = 1; + local_1c = 0; + if (local_14 != 0) { + do { + local_10 = (undefined4 *)0x0; + local_c = (undefined4 *)0x0; + uVar4 = (**(code **)(*param_2 + 0xc))(local_1c); + cVar2 = FUN_0042a420(uVar4); + if (cVar2 == '\0') { + uVar4 = extraout_ECX; + FUN_00401340("failed to read property"); + FUN_0065d620(param_2,uVar4); + local_26 = 0; + } + else if ((!bVar1) || (cVar2 = FUN_004299a0(), cVar2 == '\0')) { + uVar4 = FUN_00429a00(); + if ((*(char *)(param_1 + 0xb6) == '\0') && + ((cVar2 = FUN_0042bd10(uVar4), cVar2 == '\0' && (*(char *)(param_1 + 0xb6) == '\0')))) { + FUN_00401340(""); + FUN_00401340(""); + FUN_004268d0(*(undefined4 *)(param_1 + 8),&iStack_24); + uVar4 = FUN_00429a00(&iStack_20); + FUN_004268d0(uVar4); + iVar7 = iStack_20; + iVar8 = iStack_20; + iVar9 = iStack_24; + FUN_00401340("[%s] is not an available property for [%s]"); + FUN_0065d620(param_2,iVar7,iVar8,iVar9); + puVar6 = (undefined4 *)(iStack_24 + -0x14); + local_26 = 0; + LVar5 = InterlockedDecrement((LONG *)(iStack_24 + -0x10)); + if ((LVar5 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + puVar6 = (undefined4 *)(iStack_20 + -0x14); + LVar5 = InterlockedDecrement((LONG *)(iStack_20 + -0x10)); + if ((LVar5 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + } + else { + iVar7 = local_18; + uVar3 = *(uint *)(local_18 + 0xc) & 0x7fffffff; + if (uVar3 <= *(uint *)(local_18 + 0x10)) { + uVar4 = FUN_00453850(uVar3 + 1); + cVar2 = FUN_004273a0(uVar4); + if (cVar2 == '\0') goto LAB_0042bc75; + } + FUN_00429ab0(&local_10); + *(int *)(iVar7 + 0x10) = *(int *)(iVar7 + 0x10) + 1; + } + } +LAB_0042bc75: + if (local_10 != (undefined4 *)0x0) { + iVar7 = local_10[1]; + local_10[1] = iVar7 + -1; + if (iVar7 + -1 == 0) { + (**(code **)*local_10)(1); + } + local_10 = (undefined4 *)0x0; + } + if ((local_c != (undefined4 *)0x0) && + (iVar7 = local_c[1], local_c[1] = iVar7 + -1, iVar7 + -1 == 0)) { + (**(code **)*local_c)(1); + } + uVar3 = local_1c + 1; + local_1c = uVar3; + } while (uVar3 < local_14); + } + return CONCAT31((int3)(uVar3 >> 8),local_26); +} + + + +// --- FUN_0042bcf0 at 0x0042BCF0 (size: 20) --- + +void __thiscall FUN_0042bcf0(int param_1,int *param_2) + +{ + *param_2 = param_1 + 4; + param_2[1] = 0; + param_2[2] = 0; + return; +} + + + +// --- FUN_0042bd10 at 0x0042BD10 (size: 44) --- + +undefined4 __thiscall FUN_0042bd10(int param_1,uint param_2) + +{ + uint *puVar1; + bool bVar2; + + puVar1 = *(uint **)(*(int *)(param_1 + 100) + (param_2 % *(uint *)(param_1 + 0x6c)) * 4); + bVar2 = puVar1 == (uint *)0x0; + if (!bVar2) { + do { + if (*puVar1 == param_2) break; + puVar1 = (uint *)puVar1[1]; + } while (puVar1 != (uint *)0x0); + bVar2 = puVar1 == (uint *)0x0; + } + return CONCAT31((int3)((uint)puVar1 >> 8),!bVar2); +} + + + +// --- FUN_0042bd40 at 0x0042BD40 (size: 80) --- + +uint __thiscall FUN_0042bd40(int param_1,uint *param_2) + +{ + uint *puVar1; + uint *puVar2; + int iVar3; + + puVar1 = (uint *)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + puVar2 = (uint *)*puVar1; + do { + if (puVar2 == (uint *)0x0) { +LAB_0042bd6b: + param_2[1] = *puVar1; + *puVar1 = (uint)param_2; + if (puVar1 < *(uint **)(param_1 + 100)) { + *(uint **)(param_1 + 100) = puVar1; + } + iVar3 = *(int *)(param_1 + 0x6c) + 1; + *(int *)(param_1 + 0x6c) = iVar3; + return CONCAT31((int3)((uint)iVar3 >> 8),1); + } + if (*puVar2 == *param_2) { + if (puVar2 != (uint *)0x0) { + return (uint)puVar2 & 0xffffff00; + } + goto LAB_0042bd6b; + } + puVar2 = (uint *)puVar2[1]; + } while( true ); +} + + + +// --- FUN_0042bda0 at 0x0042BDA0 (size: 142) --- + +undefined4 __thiscall FUN_0042bda0(int param_1,uint *param_2,undefined4 param_3) + +{ + uint *puVar1; + + puVar1 = *(uint **)(*(int *)(param_1 + 100) + (*param_2 % *(uint *)(param_1 + 0x6c)) * 4); + do { + if (puVar1 == (uint *)0x0) { +LAB_0042bdcb: + puVar1 = (uint *)FUN_005df0f5(0xc); + if (puVar1 != (uint *)0x0) { + *puVar1 = *param_2; + puVar1[1] = 0; + FUN_0042c690(param_3); + FUN_0042bd40(puVar1); + return 1; + } + FUN_0042bd40(0); + return 1; + } + if (*puVar1 == *param_2) { + if (puVar1 != (uint *)0x0) { + FUN_0042c690(param_3); + return 1; + } + goto LAB_0042bdcb; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_0042be30 at 0x0042BE30 (size: 43) --- + +void FUN_0042be30(undefined4 param_1) + +{ + undefined4 local_4; + + FUN_00535a80(); + local_4 = param_1; + FUN_0042bda0(¶m_1,&local_4); + return; +} + + + +// --- FUN_0042be60 at 0x0042BE60 (size: 526) --- + +void FUN_0042be60(undefined4 param_1,int param_2,uint param_3) + +{ + int iVar1; + undefined *puVar2; + undefined *puVar3; + uint uVar4; + char cVar5; + undefined *puVar6; + byte *pbVar7; + int *piVar8; + undefined4 *puVar9; + undefined4 *puVar10; + uint uVar11; + undefined4 *puVar12; + undefined1 local_c [12]; + + uVar4 = param_3; + if ((~*(byte *)(param_3 + 4) & 1) != 0) { + FUN_005c2c80(); + } + puVar3 = PTR_DAT_00818558; + puVar2 = PTR_DAT_00818554; + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x68); + puVar6 = (undefined *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_3,param_3,0); + if (puVar6 == puVar3) { + puVar6 = puVar6 + -4; + } + uVar11 = (int)puVar6 - (int)puVar2 >> 2; + } + else { + uVar11 = param_3 & 0xff; + } + FUN_0040ad10(1); + pbVar7 = (byte *)FUN_0040acf0(1); + if (pbVar7 != (byte *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + uVar11 = (uint)*pbVar7; + } + else { + *pbVar7 = (byte)uVar11; + } + } + if ((*(byte *)(uVar4 + 4) & 5) == 0) { + if ((uVar11 & 0xff) < DAT_007956cc) { + FUN_0042ab60(*(undefined4 *)(PTR_DAT_00818554 + (uVar11 & 0xff) * 4)); + } + else { + FUN_0040aa50(); + } + } + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x6c); + } + FUN_00401a80(¶m_3,¶m_3,uVar4); + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + piVar8 = (int *)FUN_0052dcf0(local_c); + iVar1 = *piVar8; + puVar12 = (undefined4 *)piVar8[1]; + puVar9 = (undefined4 *)piVar8[2]; +LAB_0042bf62: + puVar10 = puVar9; + if (puVar9 != (undefined4 *)0x0) { + do { + FUN_0040ad10(4); + puVar9 = (undefined4 *)FUN_0040acf0(4); + if (puVar9 != (undefined4 *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + *puVar10 = *puVar9; + } + else { + *puVar9 = *puVar10; + } + } + FUN_0068b220(uVar4); + puVar10 = (undefined4 *)puVar10[1]; + } while (puVar10 != (undefined4 *)0x0); + do { + puVar12 = puVar12 + 1; + puVar9 = puVar10; + if (puVar12 == (undefined4 *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) break; + puVar9 = (undefined4 *)*puVar12; + } while (puVar9 == (undefined4 *)0x0); + goto LAB_0042bf62; + } + } + if ((*(byte *)(uVar4 + 4) & 5) == 0) { + uVar11 = FUN_0040a8f0(); + if (uVar11 < param_3) { +LAB_0042c05f: + FUN_0040aa50(); + } + else { + uVar11 = 0; + puVar12 = (undefined4 *)0x0; + if (param_3 != 0) { + while( true ) { + puVar9 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar9 == (undefined4 *)0x0) { + puVar9 = (undefined4 *)0x0; + } + else { + puVar9[1] = 0; + FUN_00535a80(); + } + FUN_0040ad10(4); + puVar10 = (undefined4 *)FUN_0040acf0(4); + if (puVar10 != (undefined4 *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + *puVar9 = *puVar10; + } + else { + *puVar10 = *puVar9; + } + } + FUN_0068b220(uVar4); + if ((*(uint *)(uVar4 + 4) >> 2 & 1) != 0) break; + cVar5 = FUN_00599310(puVar9,puVar12); + if (cVar5 == '\0') goto LAB_0042c05f; + uVar11 = uVar11 + 1; + puVar12 = puVar9; + if (param_3 <= uVar11) { + return; + } + } + } + } + } + return; +} + + + +// --- FUN_0042c070 at 0x0042C070 (size: 48) --- + +void __thiscall FUN_0042c070(int param_1,int param_2) + +{ + int iVar1; + + iVar1 = param_2; + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + FUN_005870f0(); + } + FUN_0042be60(¶m_2,param_1 + 4,iVar1); + return; +} + + + +// --- FUN_0042c0a0 at 0x0042C0A0 (size: 117) --- + +undefined4 FUN_0042c0a0(undefined4 param_1,int param_2) + +{ + int iVar1; + char cVar2; + int *piVar3; + int iVar4; + undefined1 local_c [12]; + + if (param_2 == 0) { + return 0; + } + piVar3 = (int *)FUN_0052dcf0(local_c); + iVar4 = piVar3[2]; + iVar1 = *piVar3; + piVar3 = (int *)piVar3[1]; + do { + if (iVar4 == 0) { + return 1; + } + do { + cVar2 = FUN_00429ea0(param_2); + if (cVar2 == '\0') { + return 0; + } + iVar4 = *(int *)(iVar4 + 4); + } while (iVar4 != 0); + do { + piVar3 = piVar3 + 1; + if (piVar3 == (int *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) { + return 1; + } + iVar4 = *piVar3; + } while (iVar4 == 0); + } while( true ); +} + + + +// --- FUN_0042c210 at 0x0042C210 (size: 120) --- + +uint __thiscall FUN_0042c210(int param_1,uint *param_2) + +{ + uint *puVar1; + int iVar2; + uint uVar3; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + do { + if (puVar1 == (uint *)0x0) { +LAB_0042c23b: + if ((int)(*(uint *)(param_1 + 0x68) * 2) < *(int *)(param_1 + 0x6c) + 1) { + FUN_00428210(); + } + uVar3 = *param_2 % *(uint *)(param_1 + 0x68); + iVar2 = *(int *)(param_1 + 0x60); + param_2[1] = *(uint *)(iVar2 + uVar3 * 4); + *(uint **)(iVar2 + uVar3 * 4) = param_2; + uVar3 = iVar2 + uVar3 * 4; + if (uVar3 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar3; + } + iVar2 = *(int *)(param_1 + 0x6c) + 1; + *(int *)(param_1 + 0x6c) = iVar2; + return CONCAT31((int3)((uint)iVar2 >> 8),1); + } + if (*puVar1 == *param_2) { + if (puVar1 != (uint *)0x0) { + return (uint)puVar1 & 0xffffff00; + } + goto LAB_0042c23b; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_0042c290 at 0x0042C290 (size: 140) --- + +undefined4 FUN_0042c290(undefined4 *param_1,undefined4 param_2) + +{ + int *piVar1; + undefined4 *puVar2; + char cVar3; + undefined4 *puVar4; + + puVar4 = (undefined4 *)FUN_005df0f5(0x10); + if (puVar4 == (undefined4 *)0x0) { + puVar4 = (undefined4 *)0x0; + } + else { + *puVar4 = *param_1; + puVar4[1] = 0; + puVar4[2] = 0; + puVar4[3] = 0; + FUN_00429ab0(param_2); + } + cVar3 = FUN_0042c210(puVar4); + if (cVar3 == '\0') { + if (puVar4 != (undefined4 *)0x0) { + puVar2 = (undefined4 *)puVar4[2]; + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + puVar4[2] = 0; + } + puVar2 = (undefined4 *)puVar4[3]; + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + puVar4[3] = 0; + } + operator_delete(puVar4); + } + return 0; + } + return 1; +} + + + +// --- FUN_0042c690 at 0x0042C690 (size: 17) --- + +void __thiscall FUN_0042c690(undefined4 *param_1,undefined4 *param_2) + +{ + if (param_1 != param_2) { + *param_1 = *param_2; + } + return; +} + + + +// --- FUN_0042c6b0 at 0x0042C6B0 (size: 112) --- + +void FUN_0042c6b0(int param_1) + +{ + int *piVar1; + + if (param_1 == 0) { + param_1 = 1; + } + piVar1 = &DAT_00837f3c; + DAT_008189ec = param_1; + do { + param_1 = param_1 * 0x9c4e + (param_1 / 0xd1a4) * -0x7fffffab; + if (param_1 < 0) { + param_1 = param_1 + 0x7fffffab; + } + if ((int)piVar1 < 0x837f20) { + *piVar1 = param_1; + } + piVar1 = piVar1 + -1; + } while (0x837e9f < (int)piVar1); + DAT_00837f20 = DAT_00837ea0; + DAT_008189e8 = param_1; + return; +} + + + +// --- FUN_0042c720 at 0x0042C720 (size: 217) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +float10 FUN_0042c720(void) + +{ + int iVar1; + float10 fVar2; + + DAT_008189e8 = DAT_008189e8 * 0x9c4e + (DAT_008189e8 / 0xd1a4) * -0x7fffffab; + if (DAT_008189e8 < 0) { + DAT_008189e8 = DAT_008189e8 + 0x7fffffab; + } + DAT_008189ec = DAT_008189ec * 0x9ef4 + (DAT_008189ec / 0xce26) * -0x7fffff07; + if (DAT_008189ec < 0) { + DAT_008189ec = DAT_008189ec + 0x7fffff07; + } + iVar1 = DAT_00837f20 / 0x3fffffe; + DAT_00837f20 = (&DAT_00837ea0)[iVar1] - DAT_008189ec; + (&DAT_00837ea0)[iVar1] = DAT_008189e8; + if (DAT_00837f20 < 1) { + DAT_00837f20 = DAT_00837f20 + 0x7fffffaa; + } + fVar2 = (float10)DAT_00837f20 * (float10)_DAT_00798d50; + if ((float10)_DAT_00798d48 < fVar2) { + fVar2 = (float10)_DAT_00798d48; + } + return fVar2; +} + + + +// --- FUN_0042c800 at 0x0042C800 (size: 23) --- + +void FUN_0042c800(void) + +{ + time_t tVar1; + + tVar1 = time((time_t *)0x0); + DAT_008189e8 = (undefined4)tVar1; + FUN_0042c6b0(DAT_008189e8); + return; +} + + + +// --- FUN_0042c820 at 0x0042C820 (size: 62) --- + +int FUN_0042c820(int param_1,int param_2) + +{ + int iVar1; + + if (param_2 != param_1) { + if (param_2 < param_1) { + param_1 = param_2; + } + FUN_0042c720(); + iVar1 = FUN_005df4c4(); + param_1 = iVar1 + param_1; + } + return param_1; +} + + + +// --- FUN_0042c860 at 0x0042C860 (size: 94) --- + +float10 FUN_0042c860(float param_1,float param_2) + +{ + float10 fVar1; + undefined4 local_8; + undefined4 local_4; + + if (param_1 == param_2) { + return (float10)param_1; + } + local_4 = param_2; + local_8 = param_1; + if (param_2 < param_1) { + local_4 = param_1; + local_8 = param_2; + } + fVar1 = (float10)FUN_0042c720(); + return ((float10)local_4 - (float10)local_8) * fVar1 + (float10)local_8; +} + + + +// --- FUN_0042c8c0 at 0x0042C8C0 (size: 63) --- + +uint __thiscall FUN_0042c8c0(undefined4 *param_1,undefined4 *param_2) + +{ + wchar_t *_Str2; + wchar_t *_Str1; + uint uVar1; + int iVar2; + + _Str2 = (wchar_t *)*param_2; + _Str1 = (wchar_t *)*param_1; + uVar1 = *(uint *)(_Str1 + -2); + if (uVar1 == *(uint *)(_Str2 + -2)) { + uVar1 = *(uint *)(_Str1 + -4); + if (((uVar1 == *(uint *)(_Str2 + -4)) || (uVar1 == 0xffffffff)) || + (*(uint *)(_Str2 + -4) == 0xffffffff)) { + iVar2 = wcscmp(_Str1,_Str2); + return (uint)(iVar2 == 0); + } + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_0042c900 at 0x0042C900 (size: 64) --- + +undefined4 * __thiscall FUN_0042c900(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00798d68; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0042c940 at 0x0042C940 (size: 64) --- + +undefined4 * __thiscall FUN_0042c940(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00798d6c; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0042c980 at 0x0042C980 (size: 59) --- + +void __thiscall FUN_0042c980(int param_1,undefined4 param_2) + +{ + undefined4 uVar1; + undefined4 *puVar2; + int iVar3; + + puVar2 = (undefined4 *)FUN_00415640(¶m_2,param_2,4); + uVar1 = *puVar2; + iVar3 = FUN_0041c280(uVar1); + if (iVar3 != 0x25) { + *(undefined4 *)(param_1 + 8) = DAT_00837f28; + return; + } + *(undefined4 *)(param_1 + 8) = uVar1; + return; +} + + + +// --- FUN_0042c9c0 at 0x0042C9C0 (size: 65) --- + +void __thiscall FUN_0042c9c0(int param_1,undefined4 param_2,undefined4 param_3) + +{ + undefined4 uVar1; + undefined4 *puVar2; + int iVar3; + + *(undefined4 *)(param_1 + 4) = param_2; + puVar2 = (undefined4 *)FUN_00415640(¶m_2,param_3,4); + uVar1 = *puVar2; + iVar3 = FUN_0041c280(uVar1); + if (iVar3 != 0x25) { + *(undefined4 *)(param_1 + 8) = DAT_00837f28; + return; + } + *(undefined4 *)(param_1 + 8) = uVar1; + return; +} + + + +// --- FUN_0042ca10 at 0x0042CA10 (size: 51) --- + +void __thiscall FUN_0042ca10(int param_1,undefined4 param_2,undefined4 param_3) + +{ + int iVar1; + + *(undefined4 *)(param_1 + 4) = param_2; + iVar1 = FUN_0041c280(param_3); + if (iVar1 != 0x25) { + *(undefined4 *)(param_1 + 8) = DAT_00837f28; + return; + } + *(undefined4 *)(param_1 + 8) = param_3; + return; +} + + + +// --- FUN_0042ca50 at 0x0042CA50 (size: 152) --- + +uint __thiscall FUN_0042ca50(int param_1,int *param_2) + +{ + int iVar1; + int *piVar2; + LONG LVar3; + undefined4 *puVar4; + int local_4; + + if (*(uint *)(param_1 + 8) == DAT_00837f28) { + return *(uint *)(param_1 + 8) & 0xffffff00; + } + local_4 = param_1; + piVar2 = (int *)FUN_00679220(&local_4,*(undefined4 *)(param_1 + 8),0x25); + iVar1 = *param_2; + if (iVar1 != *piVar2) { + LVar3 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *piVar2; + *param_2 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + puVar4 = (undefined4 *)(local_4 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + return CONCAT31((int3)((uint)*param_2 >> 8),*(int *)(*param_2 + -4) != 1); +} + + + +// --- FUN_0042caf0 at 0x0042CAF0 (size: 48) --- + +undefined4 * __thiscall FUN_0042caf0(undefined4 *param_1,undefined4 param_2) + +{ + undefined4 uVar1; + + *param_1 = 0; + uVar1 = FUN_004220b0(param_2,0x25); + uVar1 = FUN_00415430(uVar1); + *param_1 = uVar1; + return param_1; +} + + + +// --- FUN_0042cb20 at 0x0042CB20 (size: 73) --- + +void __thiscall FUN_0042cb20(int *param_1,int *param_2) + +{ + int iVar1; + int iVar2; + int iVar3; + int iVar4; + int iVar5; + int *piVar6; + + iVar1 = param_1[1]; + iVar2 = param_1[2]; + iVar3 = *(int *)(iVar2 + 4); + iVar4 = *param_1; + param_1[2] = iVar3; + if (iVar3 == 0) { + iVar3 = *(int *)(iVar4 + 0x68); + iVar5 = *(int *)(iVar4 + 0x60); + do { + piVar6 = (int *)(param_1[1] + 4); + param_1[1] = (int)piVar6; + if (piVar6 == (int *)(iVar5 + iVar3 * 4)) goto LAB_0042cb57; + } while (*piVar6 == 0); + param_1[2] = *piVar6; + } +LAB_0042cb57: + *param_2 = iVar4; + param_2[2] = iVar2; + param_2[1] = iVar1; + return; +} + + + +// --- FUN_0042cb70 at 0x0042CB70 (size: 107) --- + +void FUN_0042cb70(undefined4 param_1,int *param_2,uint param_3) + +{ + ushort *puVar1; + int iVar2; + uint uVar3; + + uVar3 = param_3; + if ((*(byte *)(param_3 + 4) & 1) != 0) { + uVar3 = (uint)*(ushort *)(*param_2 + 4); + } + FUN_0040ad10(2); + puVar1 = (ushort *)FUN_0040acf0(2); + if (puVar1 != (ushort *)0x0) { + if ((*(byte *)(param_3 + 4) & 1) == 0) { + uVar3 = (uint)*puVar1; + } + else { + *puVar1 = (ushort)uVar3; + } + } + if ((~*(byte *)(param_3 + 4) & 1) != 0) { + iVar2 = FUN_0042ed90(uVar3); + *param_2 = iVar2; + } + if ((int *)*param_2 != (int *)0x0) { + (**(code **)(*(int *)*param_2 + 0x10))(param_3); + } + return; +} + + + +// --- FUN_0042cbe0 at 0x0042CBE0 (size: 205) --- + +void __thiscall FUN_0042cbe0(int param_1,int *param_2,int param_3) + +{ + int iVar1; + int *piVar2; + LONG LVar3; + undefined4 *puVar4; + + *(undefined1 *)(param_1 + 0x84) = 1; + if ((char)param_3 == '\0') { + iVar1 = *(int *)(param_1 + 0x80); + if (iVar1 != *param_2) { + LVar3 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *param_2; + *(int *)(param_1 + 0x80) = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + } + else { + piVar2 = (int *)FUN_0067cbc0(¶m_3,param_2); + iVar1 = *(int *)(param_1 + 0x80); + if (iVar1 != *piVar2) { + LVar3 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *piVar2; + *(int *)(param_1 + 0x80) = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + puVar4 = (undefined4 *)(param_3 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + return; + } + } + return; +} + + + +// --- FUN_0042ccb0 at 0x0042CCB0 (size: 288) --- + +int * __thiscall FUN_0042ccb0(int param_1,int *param_2,int param_3) + +{ + int *piVar1; + LONG LVar2; + undefined4 *puVar3; + int local_4; + + local_4 = *(int *)(param_1 + 0x80); + InterlockedIncrement((LONG *)(local_4 + -0x10)); + if ((char)param_3 == '\0') { + piVar1 = (int *)FUN_0067caf0(¶m_3,&local_4); + if (local_4 != *piVar1) { + puVar3 = (undefined4 *)(local_4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + local_4 = *piVar1; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + } + puVar3 = (undefined4 *)(param_3 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + } + piVar1 = (int *)FUN_0067cdc0(¶m_3,&local_4); + if (local_4 != *piVar1) { + puVar3 = (undefined4 *)(local_4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + local_4 = *piVar1; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + } + puVar3 = (undefined4 *)(param_3 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + *param_2 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + puVar3 = (undefined4 *)(local_4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + return param_2; +} + + + +// --- FUN_0042cdd0 at 0x0042CDD0 (size: 47) --- + +void __thiscall FUN_0042cdd0(undefined4 *param_1,undefined4 *param_2) + +{ + undefined4 uVar1; + undefined4 uVar2; + undefined4 uVar3; + undefined1 local_c [12]; + + uVar1 = param_1[2]; + uVar2 = *param_1; + uVar3 = param_1[1]; + FUN_0042cb20(local_c,0); + param_2[1] = uVar3; + *param_2 = uVar2; + param_2[2] = uVar1; + return; +} + + + +// --- FUN_0042ce00 at 0x0042CE00 (size: 203) --- + +undefined4 __thiscall FUN_0042ce00(int param_1,undefined4 param_2) + +{ + char cVar1; + int iVar2; + int *local_1c; + undefined1 local_18 [8]; + int local_10; + undefined1 auStack_c [12]; + + if (*(char *)(param_1 + 0x84) != '\x01') { + if ((*(int *)(param_1 + 4) == 0) || (*(int *)(param_1 + 8) == DAT_00837f28)) { + return 0; + } + if (*(char *)(param_1 + 0x84) != '\x02') { + FUN_0042caf0(*(int *)(param_1 + 8)); + if (local_1c != (int *)0x0) { + iVar2 = FUN_004301a0(*(undefined4 *)(param_1 + 4)); + if (iVar2 != 0) { + if ((char)param_2 != '\0') { + FUN_00429c70(local_18); + while (local_10 != 0) { + if ((*(int **)(local_10 + 8) != (int *)0x0) && + (cVar1 = (**(code **)(**(int **)(local_10 + 8) + 0xc))(param_2), cVar1 == '\0')) + goto LAB_0042ce5d; + FUN_0042cdd0(auStack_c,0); + } + } + (**(code **)(*local_1c + 0x14))(); + return 1; + } +LAB_0042ce5d: + FUN_0049b890(); + } + return 0; + } + } + return 1; +} + + + +// --- FUN_0042ced0 at 0x0042CED0 (size: 130) --- + +void __thiscall FUN_0042ced0(int param_1,undefined4 param_2) + +{ + int iVar1; + undefined4 uVar2; + int *piVar3; + int iVar4; + undefined4 uVar5; + undefined1 local_c [12]; + + if (*(char *)(param_1 + 0x84) != '\x01') { + uVar5 = 0; + uVar2 = FUN_004220b0(*(undefined4 *)(param_1 + 8),0); + FUN_0041a4e0(uVar2,uVar5); + piVar3 = (int *)FUN_0052dcf0(local_c); + iVar4 = piVar3[2]; + iVar1 = *piVar3; + piVar3 = (int *)piVar3[1]; + while (iVar4 != 0) { + do { + if (*(int **)(iVar4 + 8) != (int *)0x0) { + (**(code **)(**(int **)(iVar4 + 8) + 4))(param_2); + } + iVar4 = *(int *)(iVar4 + 4); + } while (iVar4 != 0); + do { + piVar3 = piVar3 + 1; + if (piVar3 == (int *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) { + return; + } + iVar4 = *piVar3; + } while (iVar4 == 0); + } + } + return; +} + + + +// --- FUN_0042d020 at 0x0042D020 (size: 899) --- + +undefined1 __thiscall FUN_0042d020(int *param_1,int param_2) + +{ + bool bVar1; + char cVar2; + int iVar3; + int iVar4; + undefined4 uVar5; + int *piVar6; + LONG LVar7; + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined4 extraout_ECX_01; + undefined4 extraout_ECX_02; + undefined4 extraout_ECX_03; + undefined4 extraout_ECX_04; + undefined4 extraout_ECX_05; + undefined4 extraout_ECX_06; + undefined4 extraout_ECX_07; + undefined4 extraout_ECX_08; + undefined4 extraout_ECX_09; + undefined4 *puVar8; + undefined *puVar9; + int iVar10; + char *pcVar11; + int iVar12; + undefined1 local_1a; + undefined *local_18; + undefined1 local_14 [4]; + undefined1 local_10 [16]; + + iVar3 = param_2; + if (param_2 == 0) { + return 0; + } + local_18 = PTR_DAT_00818344; + local_1a = 1; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + bVar1 = false; + FUN_0065cf90(iVar3); + iVar3 = FUN_0065c810(); + puVar9 = local_18; + while (local_18 = puVar9, iVar3 != 0) { + cVar2 = FUN_0065cc50(&DAT_00837f30); + if (cVar2 == '\0') { + cVar2 = FUN_0065cc50(&DAT_00837f34); + if (cVar2 == '\0') { + cVar2 = FUN_0065cc50(&DAT_00837f38); + if (cVar2 == '\0') { + cVar2 = FUN_0065cc50(&DAT_00837f3c); + if (cVar2 == '\0') { + cVar2 = FUN_0065cc50(&DAT_00837f40); + if (cVar2 == '\0') { + uVar5 = extraout_ECX_07; + FUN_00401340("unknown keyword"); + FUN_0065d670(iVar3,uVar5); + } + else { + FUN_00401a40(); + iVar4 = FUN_0065ca90(); + uVar5 = extraout_ECX_08; + if ((iVar4 == 0) || + (cVar2 = FUN_00426020(local_14), uVar5 = extraout_ECX_09, cVar2 == '\0')) { + FUN_00401340("corrupt literal data"); + FUN_0065d620(iVar3,uVar5); + local_1a = 0; + } + uVar5 = FUN_00403350(local_10,0); + FUN_00402070(uVar5); + FUN_004011b0(); + *(undefined1 *)(param_1 + 0x21) = 1; + FUN_004011b0(); + } + } + else { + iVar4 = FUN_0065ca90(); + uVar5 = extraout_ECX_05; + if ((iVar4 == 0) || + (cVar2 = FUN_00426020(param_1 + 0x23), uVar5 = extraout_ECX_06, cVar2 == '\0')) { + FUN_00401340("corrupt string comment data"); + FUN_0065d620(iVar3,uVar5); + local_1a = 0; + } + *(undefined1 *)(param_1 + 0x21) = 2; + } + } + else { + iVar4 = FUN_0065ca90(); + uVar5 = extraout_ECX_03; + if ((iVar4 == 0) || + (cVar2 = FUN_00426020(param_1 + 0x22), uVar5 = extraout_ECX_04, cVar2 == '\0')) { + FUN_00401340("corrupt string english data"); + FUN_0065d620(iVar3,uVar5); + local_1a = 0; + *(undefined1 *)(param_1 + 0x21) = 2; + } + else { + bVar1 = true; + *(undefined1 *)(param_1 + 0x21) = 2; + } + } + } + else { + iVar4 = FUN_0065ca90(); + uVar5 = extraout_ECX_01; + if ((iVar4 == 0) || (cVar2 = FUN_00426020(param_1), uVar5 = extraout_ECX_02, cVar2 == '\0')) + { + pcVar11 = "corrupt string token data"; + goto LAB_0042d0db; + } + } + } + else { + iVar4 = FUN_0065ca90(); + uVar5 = extraout_ECX; + if ((iVar4 == 0) || (cVar2 = FUN_00426020(&local_18), uVar5 = extraout_ECX_00, cVar2 == '\0')) + { + pcVar11 = "corrupt string table data"; +LAB_0042d0db: + FUN_00401340(pcVar11); + FUN_0065d620(iVar3,uVar5); + local_1a = 0; + } + } + iVar3 = FUN_0065cb10(); + puVar9 = local_18; + } + if (((char)param_1[0x21] == '\0') || ((char)param_1[0x21] == '\x02')) { + if (*(int *)(puVar9 + -4) == 1) { + iVar3 = param_1[0x23]; + iVar4 = param_1[0x22]; + iVar10 = *param_1; + iVar12 = iVar3; + FUN_00401340( + "failed parsing the stringtable name! ( token: \'%s\', english: \'%s\', comment: \'%s\'" + ); + FUN_0065d620(param_2,iVar3,iVar10,iVar4,iVar12); + } + else { + if ((bVar1) && (cVar2 = FUN_00413a70(), cVar2 == '\0')) { + iVar3 = param_1[0x23]; + InterlockedIncrement((LONG *)(iVar3 + -0x10)); + iVar4 = param_1[0x22]; + InterlockedIncrement((LONG *)(iVar4 + -0x10)); + iVar10 = *param_1; + InterlockedIncrement((LONG *)(iVar10 + -0x10)); + InterlockedIncrement((LONG *)(puVar9 + -0x10)); + piVar6 = (int *)FUN_0065d560(puVar9,iVar10,iVar4,iVar3); + iVar3 = *piVar6; + InterlockedIncrement((LONG *)(iVar3 + -0x10)); + FUN_00430bc0(iVar3); + } + iVar3 = *param_1; + iVar4 = *(int *)(iVar3 + -8); + if (iVar4 == -1) { + iVar4 = FUN_004016b0(iVar3); + *(int *)(iVar3 + -8) = iVar4; + } + param_1[1] = iVar4; + FUN_00403350(¶m_2,0); + puVar8 = (undefined4 *)(param_2 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar7 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + if (param_1[2] != DAT_00837f28) goto LAB_0042d363; + } + local_1a = 0; + } +LAB_0042d363: + FUN_0065cae0(); + puVar8 = (undefined4 *)(local_18 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(local_18 + -0x10)); + if ((LVar7 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + return local_1a; +} + + + +// --- FUN_0042d3b0 at 0x0042D3B0 (size: 319) --- + +int * __thiscall FUN_0042d3b0(int *param_1,undefined4 *param_2) + +{ + LONG *lpAddend; + int *piVar1; + int iVar2; + undefined *puVar3; + undefined *puVar4; + char cVar5; + LONG LVar6; + uint uVar7; + int *piVar8; + int *piVar9; + + if ((param_1[1] & 0x7fffffffU) < (param_2[1] & 0x7fffffff)) { + param_1[2] = 0; + cVar5 = FUN_00407f10(param_2[1] & 0x7fffffff); + if (cVar5 == '\0') { + return param_1; + } + } + piVar8 = (int *)*param_1; + piVar9 = (int *)*param_2; + piVar1 = piVar9 + param_2[2]; + for (; piVar9 < piVar1; piVar9 = piVar9 + 1) { + iVar2 = *piVar8; + if (iVar2 != *piVar9) { + LVar6 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar2 = *piVar9; + *piVar8 = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + } + piVar8 = piVar8 + 1; + } + uVar7 = param_2[2]; + if (uVar7 < (uint)param_1[2]) { + do { + puVar4 = PTR_DAT_00818340; + lpAddend = (LONG *)(PTR_DAT_00818340 + -0x10); + InterlockedIncrement(lpAddend); + piVar1 = (int *)(*param_1 + uVar7 * 4); + puVar3 = (undefined *)*piVar1; + if (puVar3 != puVar4) { + LVar6 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar3 + -0x14))(1); + } + *piVar1 = (int)puVar4; + InterlockedIncrement(lpAddend); + } + LVar6 = InterlockedDecrement((LONG *)(puVar4 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar4 + -0x14))(1); + } + uVar7 = uVar7 + 1; + } while (uVar7 < (uint)param_1[2]); + } + param_1[2] = param_2[2]; + return param_1; +} + + + +// --- FUN_0042d4f0 at 0x0042D4F0 (size: 71) --- + +int FUN_0042d4f0(int param_1,undefined4 param_2,undefined4 param_3) + +{ + LONG LVar1; + int iVar2; + + iVar2 = param_1; + FUN_00402730(param_2); + FUN_004086c0(iVar2,param_3); + LVar1 = InterlockedDecrement((LONG *)(param_1 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(param_1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_1 + -0x14))(1); + } + return param_1; +} + + + +// --- FUN_0042d540 at 0x0042D540 (size: 285) --- + +undefined4 __thiscall FUN_0042d540(int param_1,int param_2) + +{ + uint *puVar1; + char cVar2; + undefined4 uVar3; + undefined1 local_c [8]; + uint *local_4; + + if (param_1 == param_2) { + return 1; + } + if (*(char *)(param_1 + 0x84) == '\x01') { + if (*(char *)(param_2 + 0x84) == '\x01') { + uVar3 = FUN_0042c8c0(param_2 + 0x80); + return uVar3; + } + } + else if ((((*(int *)(param_1 + 4) == *(int *)(param_2 + 4)) && + (*(int *)(param_1 + 8) == *(int *)(param_2 + 8))) && + (*(char *)(param_1 + 0x84) == *(char *)(param_2 + 0x84))) && + (((cVar2 = FUN_00426520(param_2), cVar2 == '\0' && + (cVar2 = FUN_00426520(param_2 + 0x88), cVar2 == '\0')) && + ((cVar2 = FUN_00426520(param_2 + 0x8c), cVar2 == '\0' && + (*(int *)(param_1 + 0x7c) == *(int *)(param_2 + 0x7c))))))) { + FUN_00429c70(local_c); + while( true ) { + if (local_4 == (uint *)0x0) { + return 1; + } + puVar1 = *(uint **)(*(int *)(param_2 + 0x70) + (*local_4 % *(uint *)(param_2 + 0x78)) * 4); + while( true ) { + if (puVar1 == (uint *)0x0) { + return 0; + } + if (*puVar1 == *local_4) break; + puVar1 = (uint *)puVar1[1]; + } + if (puVar1 == (uint *)0x0) break; + cVar2 = FUN_0042f050(puVar1[2],local_4[2]); + if (cVar2 == '\0') { + return 0; + } + FUN_0046bfb0(); + } + return 0; + } + return 0; +} + + + +// --- FUN_0042d660 at 0x0042D660 (size: 143) --- + +undefined4 * __thiscall FUN_0042d660(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00798d68; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_0042d6f0 at 0x0042D6F0 (size: 143) --- + +undefined4 * __thiscall FUN_0042d6f0(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00798d6c; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_0042d780 at 0x0042D780 (size: 534) --- + +void FUN_0042d780(undefined4 param_1,int param_2,uint param_3) + +{ + int iVar1; + undefined *puVar2; + undefined *puVar3; + uint uVar4; + char cVar5; + undefined *puVar6; + byte *pbVar7; + int *piVar8; + undefined4 *puVar9; + undefined4 *puVar10; + uint uVar11; + undefined4 *puVar12; + undefined1 local_c [12]; + + uVar4 = param_3; + if ((~*(byte *)(param_3 + 4) & 1) != 0) { + FUN_005c2c80(); + } + puVar3 = PTR_DAT_00818558; + puVar2 = PTR_DAT_00818554; + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x68); + puVar6 = (undefined *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_3,param_3,0); + if (puVar6 == puVar3) { + puVar6 = puVar6 + -4; + } + uVar11 = (int)puVar6 - (int)puVar2 >> 2; + } + else { + uVar11 = param_3 & 0xff; + } + FUN_0040ad10(1); + pbVar7 = (byte *)FUN_0040acf0(1); + if (pbVar7 != (byte *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + uVar11 = (uint)*pbVar7; + } + else { + *pbVar7 = (byte)uVar11; + } + } + if ((*(byte *)(uVar4 + 4) & 5) == 0) { + if ((uVar11 & 0xff) < DAT_007956cc) { + FUN_0042ab60(*(undefined4 *)(PTR_DAT_00818554 + (uVar11 & 0xff) * 4)); + } + else { + FUN_0040aa50(); + } + } + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x6c); + } + FUN_00401a80(¶m_3,¶m_3,uVar4); + if (((byte)*(undefined4 *)(uVar4 + 4) & 5) == 1) { + piVar8 = (int *)FUN_0052dcf0(local_c); + iVar1 = *piVar8; + puVar12 = (undefined4 *)piVar8[1]; + puVar9 = (undefined4 *)piVar8[2]; +LAB_0042d882: + puVar10 = puVar9; + if (puVar9 != (undefined4 *)0x0) { + do { + FUN_0040ad10(4); + puVar9 = (undefined4 *)FUN_0040acf0(4); + if (puVar9 != (undefined4 *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + *puVar10 = *puVar9; + } + else { + *puVar9 = *puVar10; + } + } + FUN_0042cb70(param_1,puVar10 + 2,uVar4); + puVar10 = (undefined4 *)puVar10[1]; + } while (puVar10 != (undefined4 *)0x0); + do { + puVar12 = puVar12 + 1; + puVar9 = puVar10; + if (puVar12 == (undefined4 *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) break; + puVar9 = (undefined4 *)*puVar12; + } while (puVar9 == (undefined4 *)0x0); + goto LAB_0042d882; + } + } + if ((*(byte *)(uVar4 + 4) & 5) == 0) { + uVar11 = FUN_0040a8f0(); + if (uVar11 < param_3) { +LAB_0042d98a: + FUN_0040aa50(); + } + else { + puVar12 = (undefined4 *)0x0; + uVar11 = 0; + if (param_3 != 0) { + while( true ) { + puVar10 = (undefined4 *)FUN_005df0f5(0xc); + puVar9 = (undefined4 *)0x0; + if (puVar10 != (undefined4 *)0x0) { + puVar10[1] = 0; + puVar9 = puVar10; + } + FUN_0040ad10(4); + puVar10 = (undefined4 *)FUN_0040acf0(4); + if (puVar10 != (undefined4 *)0x0) { + if ((*(byte *)(uVar4 + 4) & 1) == 0) { + *puVar9 = *puVar10; + } + else { + *puVar10 = *puVar9; + } + } + FUN_0042cb70(param_1,puVar9 + 2,uVar4); + if ((*(uint *)(uVar4 + 4) >> 2 & 1) != 0) break; + cVar5 = FUN_00599310(puVar9,puVar12); + if (cVar5 == '\0') goto LAB_0042d98a; + uVar11 = uVar11 + 1; + puVar12 = puVar9; + if (param_3 <= uVar11) { + return; + } + } + } + } + } + return; +} + + + +// --- FUN_0042d9a0 at 0x0042D9A0 (size: 129) --- + +undefined4 __thiscall FUN_0042d9a0(int param_1,uint *param_2,uint *param_3) + +{ + uint *puVar1; + + puVar1 = *(uint **)(*(int *)(param_1 + 100) + (*param_2 % *(uint *)(param_1 + 0x6c)) * 4); + do { + if (puVar1 == (uint *)0x0) { +LAB_0042d9cb: + puVar1 = (uint *)FUN_005df0f5(0xc); + if (puVar1 != (uint *)0x0) { + *puVar1 = *param_2; + puVar1[1] = 0; + puVar1[2] = *param_3; + FUN_0042bd40(puVar1); + return 1; + } + FUN_0042bd40(0); + return 1; + } + if (*puVar1 == *param_2) { + if (puVar1 != (uint *)0x0) { + puVar1[2] = *param_3; + return 1; + } + goto LAB_0042d9cb; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_0042da30 at 0x0042DA30 (size: 190) --- + +undefined4 __thiscall FUN_0042da30(int param_1,uint *param_2,uint *param_3) + +{ + uint uVar1; + uint *puVar2; + LONG LVar3; + + puVar2 = *(uint **)(*(int *)(param_1 + 100) + (*param_2 % *(uint *)(param_1 + 0x6c)) * 4); + do { + if (puVar2 == (uint *)0x0) { +LAB_0042da5b: + puVar2 = (uint *)FUN_005df0f5(0xc); + if (puVar2 == (uint *)0x0) { + FUN_0042bd40(0); + return 1; + } + *puVar2 = *param_2; + puVar2[1] = 0; + uVar1 = *param_3; + puVar2[2] = uVar1; + InterlockedIncrement((LONG *)(uVar1 - 0x10)); + FUN_0042bd40(puVar2); + return 1; + } + if (*puVar2 == *param_2) { + if (puVar2 != (uint *)0x0) { + uVar1 = puVar2[2]; + if (uVar1 == *param_3) { + return 1; + } + LVar3 = InterlockedDecrement((LONG *)(uVar1 - 0x10)); + if ((LVar3 == 0) && ((undefined4 *)(uVar1 - 0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(uVar1 - 0x14))(1); + } + uVar1 = *param_3; + puVar2[2] = uVar1; + InterlockedIncrement((LONG *)(uVar1 - 0x10)); + return 1; + } + goto LAB_0042da5b; + } + puVar2 = (uint *)puVar2[1]; + } while( true ); +} + + + +// --- FUN_0042daf0 at 0x0042DAF0 (size: 104) --- + +void FUN_0042daf0(void) + +{ + int iVar1; + int *piVar2; + int iVar3; + undefined1 local_c [12]; + + piVar2 = (int *)FUN_0052dcf0(local_c); + iVar3 = piVar2[2]; + iVar1 = *piVar2; + piVar2 = (int *)piVar2[1]; + while (iVar3 != 0) { + do { + if (*(undefined4 **)(iVar3 + 8) != (undefined4 *)0x0) { + (**(code **)**(undefined4 **)(iVar3 + 8))(1); + } + *(undefined4 *)(iVar3 + 8) = 0; + iVar3 = *(int *)(iVar3 + 4); + } while (iVar3 != 0); + do { + piVar2 = piVar2 + 1; + if (piVar2 == (int *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) goto LAB_0042db49; + iVar3 = *piVar2; + } while (iVar3 == 0); + } +LAB_0042db49: + FUN_005870f0(); + return; +} + + + +// --- FUN_0042db60 at 0x0042DB60 (size: 85) --- + +void FUN_0042db60(int param_1) + +{ + undefined4 *puVar1; + void *pvVar2; + undefined4 local_4; + + if (param_1 != 0) { + local_4 = *(undefined4 *)(param_1 + 8); + pvVar2 = (void *)FUN_004171e0(&local_4); + if (pvVar2 != (void *)0x0) { + puVar1 = *(undefined4 **)((int)pvVar2 + 8); + operator_delete(pvVar2); + if (puVar1 != (undefined4 *)0x0) { + (**(code **)*puVar1)(1); + } + } + FUN_0042d9a0(&local_4,¶m_1); + } + return; +} + + + +// --- FUN_0042dbc0 at 0x0042DBC0 (size: 82) --- + +undefined4 * __thiscall FUN_0042dbc0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00798e5c; + FUN_005870f0(); + param_1[1] = &PTR_FUN_00798d68; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0042dc20 at 0x0042DC20 (size: 82) --- + +undefined4 * __thiscall FUN_0042dc20(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00798e60; + FUN_00415e50(); + param_1[1] = &PTR_FUN_00798d6c; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0042dc80 at 0x0042DC80 (size: 129) --- + +undefined4 * __fastcall FUN_0042dc80(undefined4 *param_1) + +{ + LONG *pLVar1; + + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + param_1[1] = 0; + param_1[2] = DAT_00837f28; + param_1[3] = &PTR_FUN_00798e5c; + FUN_0042d660(0x17); + pLVar1 = (LONG *)(PTR_DAT_00818340 + -0x10); + param_1[0x20] = PTR_DAT_00818340; + InterlockedIncrement(pLVar1); + *(undefined1 *)(param_1 + 0x21) = 0; + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x22] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x23] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + return param_1; +} + + + +// --- FUN_0042dd10 at 0x0042DD10 (size: 277) --- + +void __fastcall FUN_0042dd10(int *param_1) + +{ + undefined *puVar1; + LONG LVar2; + LONG *pLVar3; + + param_1[1] = 0; + param_1[2] = DAT_00837f28; + puVar1 = (undefined *)*param_1; + *(undefined1 *)(param_1 + 0x21) = 0; + if (puVar1 != PTR_DAT_00818344) { + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + pLVar3 = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = (int)PTR_DAT_00818344; + InterlockedIncrement(pLVar3); + } + puVar1 = (undefined *)param_1[0x20]; + if (puVar1 != PTR_DAT_00818340) { + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + pLVar3 = (LONG *)(PTR_DAT_00818340 + -0x10); + param_1[0x20] = (int)PTR_DAT_00818340; + InterlockedIncrement(pLVar3); + } + puVar1 = (undefined *)param_1[0x22]; + if (puVar1 != PTR_DAT_00818344) { + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + pLVar3 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x22] = (int)PTR_DAT_00818344; + InterlockedIncrement(pLVar3); + } + puVar1 = (undefined *)param_1[0x23]; + if (puVar1 != PTR_DAT_00818344) { + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + pLVar3 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x23] = (int)PTR_DAT_00818344; + InterlockedIncrement(pLVar3); + } + FUN_0042daf0(); + return; +} + + + +// --- FUN_0042de30 at 0x0042DE30 (size: 449) --- + +int * __thiscall FUN_0042de30(int *param_1,int *param_2) + +{ + int iVar1; + undefined4 uVar2; + char cVar3; + LONG LVar4; + int *piVar5; + int iVar6; + undefined4 *puVar7; + undefined4 *puVar8; + undefined4 *puVar9; + undefined1 auStack_c [12]; + + if (param_2 != param_1) { + iVar1 = *param_1; + if (iVar1 != *param_2) { + LVar4 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *param_2; + *param_1 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + param_1[1] = param_2[1]; + param_1[2] = param_2[2]; + *(char *)(param_1 + 0x21) = (char)param_2[0x21]; + iVar1 = param_1[0x20]; + if (iVar1 != param_2[0x20]) { + LVar4 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = param_2[0x20]; + param_1[0x20] = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + iVar1 = param_1[0x22]; + if (iVar1 != param_2[0x22]) { + LVar4 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = param_2[0x22]; + param_1[0x22] = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + iVar1 = param_1[0x23]; + if (iVar1 != param_2[0x23]) { + LVar4 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = param_2[0x23]; + param_1[0x23] = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + FUN_0042daf0(); + piVar5 = (int *)FUN_0052dcf0(auStack_c); + puVar9 = (undefined4 *)piVar5[2]; + iVar1 = *piVar5; + puVar8 = (undefined4 *)piVar5[1]; + while (puVar9 != (undefined4 *)0x0) { + do { + iVar6 = FUN_0042f3a0(puVar9[2]); + if (iVar6 != 0) { + puVar7 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar7 == (undefined4 *)0x0) { + puVar7 = (undefined4 *)0x0; + } + else { + uVar2 = *puVar9; + puVar7[2] = iVar6; + *puVar7 = uVar2; + puVar7[1] = 0; + } + cVar3 = FUN_0042bd40(puVar7); + if ((cVar3 == '\0') && (puVar7 != (undefined4 *)0x0)) { + operator_delete(puVar7); + } + } + puVar9 = (undefined4 *)puVar9[1]; + } while (puVar9 != (undefined4 *)0x0); + do { + puVar8 = puVar8 + 1; + if (puVar8 == (undefined4 *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) { + return param_1; + } + puVar9 = (undefined4 *)*puVar8; + } while (puVar9 == (undefined4 *)0x0); + } + } + return param_1; +} + + + +// --- FUN_0042e000 at 0x0042E000 (size: 59) --- + +void FUN_0042e000(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + int iVar1; + + iVar1 = FUN_005df0f5(0x18); + if (iVar1 != 0) { + iVar1 = FUN_0042eb70(param_1); + if (iVar1 != 0) { + *(undefined4 *)(iVar1 + 0x14) = param_3; + *(undefined4 *)(iVar1 + 0x10) = param_2; + FUN_0042db60(iVar1); + } + } + return; +} + + + +// --- FUN_0042e040 at 0x0042E040 (size: 59) --- + +void FUN_0042e040(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + int iVar1; + + iVar1 = FUN_005df0f5(0x18); + if (iVar1 != 0) { + iVar1 = FUN_0042ebd0(param_1); + if (iVar1 != 0) { + *(undefined4 *)(iVar1 + 0x14) = param_3; + *(undefined4 *)(iVar1 + 0x10) = param_2; + FUN_0042db60(iVar1); + } + } + return; +} + + + +// --- FUN_0042e080 at 0x0042E080 (size: 68) --- + +void FUN_0042e080(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined2 param_4) + +{ + int iVar1; + + iVar1 = FUN_005df0f5(0x20); + if (iVar1 != 0) { + iVar1 = FUN_0042eb00(param_1); + if (iVar1 != 0) { + *(undefined4 *)(iVar1 + 0x10) = param_2; + *(undefined4 *)(iVar1 + 0x14) = param_3; + *(undefined2 *)(iVar1 + 0x18) = param_4; + FUN_0042db60(iVar1); + } + } + return; +} + + + +// --- FUN_0042e0d0 at 0x0042E0D0 (size: 353) --- + +void __thiscall FUN_0042e0d0(int param_1,int param_2) + +{ + int iVar1; + char *pcVar2; + undefined4 *puVar3; + char cVar4; + char local_1; + + iVar1 = param_2; + if ((DAT_00837720 == -0x7fffffff) || (local_1 = '\x01', DAT_00837720 == -0x7ffffffe)) { + local_1 = '\0'; + } + cVar4 = *(char *)(param_1 + 0x84); + if ((local_1 == '\0') && (cVar4 == '\x02')) { + cVar4 = '\0'; + } + FUN_0040ad10(1); + pcVar2 = (char *)FUN_0040acf0(1); + if (pcVar2 != (char *)0x0) { + if ((*(byte *)(iVar1 + 4) & 1) == 0) { + cVar4 = *pcVar2; + } + else { + *pcVar2 = cVar4; + } + } + if ((~*(byte *)(iVar1 + 4) & 1) != 0) { + *(char *)(param_1 + 0x84) = cVar4; + } + if (*(char *)(param_1 + 0x84) == '\x01') { + FUN_004227d0(iVar1); + } + else { + FUN_0040ad10(4); + puVar3 = (undefined4 *)FUN_0040acf0(4); + if (puVar3 != (undefined4 *)0x0) { + if ((*(byte *)(iVar1 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 4) = *puVar3; + } + else { + *puVar3 = *(undefined4 *)(param_1 + 4); + } + } + FUN_0040ad10(4); + puVar3 = (undefined4 *)FUN_0040acf0(4); + if (puVar3 != (undefined4 *)0x0) { + if ((*(byte *)(iVar1 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 8) = *puVar3; + } + else { + *puVar3 = *(undefined4 *)(param_1 + 8); + } + } + } + FUN_0040ad10(1); + pcVar2 = (char *)FUN_0040acf0(1); + if (pcVar2 != (char *)0x0) { + if ((*(byte *)(iVar1 + 4) & 1) == 0) { + local_1 = *pcVar2; + } + else { + *pcVar2 = local_1; + } + } + if ((*(byte *)(iVar1 + 4) & 5) == 0) { + if (local_1 == '\0') goto LAB_0042e206; + if (local_1 != '\x01') { + FUN_0040aa50(); + } + } + if (local_1 != '\0') { + FUN_00402400(iVar1); + FUN_00402400(iVar1); + FUN_00402400(iVar1); + } +LAB_0042e206: + if ((~*(byte *)(iVar1 + 4) & 1) != 0) { + FUN_005870f0(); + } + FUN_0042d780(¶m_2,param_1 + 0x10,iVar1); + return; +} + + + +// --- FUN_0042e240 at 0x0042E240 (size: 714) --- + +undefined4 __thiscall FUN_0042e240(int param_1,int *param_2,char param_3) + +{ + char cVar1; + LONG LVar2; + undefined4 uVar3; + int iVar4; + undefined4 uVar5; + code *pcVar6; + int *piVar7; + int *piVar8; + undefined4 *puVar9; + int *local_88; + int local_84; + int local_80; + int *local_7c; + int local_78; + undefined **local_74; + undefined **local_70; + undefined1 auStack_6c [92]; + undefined1 *puStack_10; + undefined4 uStack_c; + undefined4 uStack_8; + undefined4 uStack_4; + + pcVar6 = InterlockedDecrement_exref; + if (*(char *)(param_1 + 0x84) == '\x01') { + iVar4 = *param_2; + if (iVar4 != *(int *)(param_1 + 0x80)) { + LVar2 = InterlockedDecrement((LONG *)(iVar4 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar4 + -0x14))(1); + } + iVar4 = *(int *)(param_1 + 0x80); + *param_2 = iVar4; + InterlockedIncrement((LONG *)(iVar4 + -0x10)); + } + } + else { + if (*(char *)(param_1 + 0x84) != '\x02') { + FUN_004027b0(param_2,L"", + *(undefined4 *)(param_1 + 4),*(undefined4 *)(param_1 + 8)); + if ((*(int *)(param_1 + 4) == 0) || (*(int *)(param_1 + 8) == DAT_00837f28)) { + cVar1 = FUN_00413a90(); + if (cVar1 != '\0') { + FUN_00413a70(); + } + return 1; + } + FUN_0042caf0(*(int *)(param_1 + 8)); + piVar8 = local_88; + if (local_88 == (int *)0x0) { + return 3; + } + local_74 = &PTR_FUN_00798e60; + FUN_0042d6f0(0x17); + FUN_00429c70(&local_80); + piVar7 = local_7c; + iVar4 = local_78; + while (iVar4 != 0) { + do { + if (*(int **)(iVar4 + 8) != (int *)0x0) { + uVar3 = (**(code **)(**(int **)(iVar4 + 8) + 0x14))(&local_84); + FUN_0042da30(iVar4,uVar3); + puVar9 = (undefined4 *)(local_84 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_84 + -0x10)); + if ((LVar2 == 0) && (puVar9 != (undefined4 *)0x0)) { + (**(code **)*puVar9)(1); + } + } + iVar4 = *(int *)(iVar4 + 4); + } while (iVar4 != 0); + do { + piVar7 = piVar7 + 1; + piVar8 = local_88; + if (piVar7 == (int *)(*(int *)(local_80 + 0x60) + *(int *)(local_80 + 0x68) * 4)) + goto LAB_0042e43b; + iVar4 = *piVar7; + } while (iVar4 == 0); + } +LAB_0042e43b: + uVar3 = FUN_00430270(param_2,*(undefined4 *)(param_1 + 4),&local_74,1); + if (param_3 == '\0') { + uVar5 = FUN_0067caf0(&local_84,param_2); + FUN_00402070(uVar5); + LVar2 = InterlockedDecrement((LONG *)(local_84 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(local_84 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_84 + -0x14))(1); + } + } + local_74 = &PTR_FUN_00798e60; + FUN_00415e50(); + local_70 = &PTR_FUN_00798d6c; + if (puStack_10 != auStack_6c) { + operator_delete__(puStack_10); + } + puStack_10 = (undefined1 *)0x0; + uStack_c = 0; + uStack_8 = 0; + uStack_4 = 0; + (**(code **)(*piVar8 + 0x14))(); + return uVar3; + } + uVar3 = FUN_00403350(&local_88,0); + FUN_00402070(uVar3); + pcVar6 = InterlockedDecrement_exref; + piVar8 = local_88 + -5; + LVar2 = InterlockedDecrement(local_88 + -4); + if ((LVar2 == 0) && (piVar8 != (int *)0x0)) { + (**(code **)*piVar8)(1); + } + } + if (param_3 == '\0') { + uVar3 = FUN_0067caf0(&local_88,param_2); + FUN_00402070(uVar3); + iVar4 = (*pcVar6)(local_88 + -4); + if ((iVar4 == 0) && (local_88 + -5 != (int *)0x0)) { + (**(code **)local_88[-5])(1); + } + } + return 0; +} + + + +// --- FUN_0042e510 at 0x0042E510 (size: 120) --- + +undefined4 * __thiscall FUN_0042e510(undefined4 *param_1,undefined4 param_2) + +{ + LONG *pLVar1; + + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + param_1[3] = &PTR_FUN_00798e5c; + FUN_0042d660(0x17); + pLVar1 = (LONG *)(PTR_DAT_00818340 + -0x10); + param_1[0x20] = PTR_DAT_00818340; + InterlockedIncrement(pLVar1); + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x22] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[0x23] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + FUN_0042de30(param_2); + return param_1; +} + + + +// --- FUN_0042e590 at 0x0042E590 (size: 198) --- + +void __fastcall FUN_0042e590(int *param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + FUN_0042dd10(); + puVar2 = (undefined4 *)(param_1[0x23] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x23] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x22] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x22] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0x20] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0x20] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + param_1[3] = (int)&PTR_FUN_00798e5c; + FUN_005870f0(); + param_1[4] = (int)&PTR_FUN_00798d68; + if ((int *)param_1[0x1c] != param_1 + 5) { + operator_delete__((int *)param_1[0x1c]); + } + param_1[0x1c] = 0; + param_1[0x1d] = 0; + param_1[0x1e] = 0; + param_1[0x1f] = 0; + puVar2 = (undefined4 *)(*param_1 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*param_1 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return; +} + + + +// --- FUN_0042e660 at 0x0042E660 (size: 65) --- + +void FUN_0042e660(undefined4 param_1,undefined4 param_2) + +{ + int iVar1; + + iVar1 = FUN_005df0f5(0x9c); + if ((iVar1 != 0) && (iVar1 = FUN_0042ea40(param_1), iVar1 != 0)) { + FUN_0042de30(param_2); + FUN_0042db60(iVar1); + } + return; +} + + + +// --- FUN_0042e6b0 at 0x0042E6B0 (size: 136) --- + +undefined4 FUN_0042e6b0(int *param_1,int param_2) + +{ + int iVar1; + int *piVar2; + LONG LVar3; + undefined4 *puVar4; + + iVar1 = FUN_0042e240(param_1,param_2); + if (iVar1 == 0) { + piVar2 = (int *)FUN_0067cdc0(¶m_2,param_1); + iVar1 = *param_1; + if (iVar1 != *piVar2) { + LVar3 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *piVar2; + *param_1 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + puVar4 = (undefined4 *)(param_2 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar3 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + return 1; + } + return 0; +} + + + +// --- FUN_0042e740 at 0x0042E740 (size: 405) --- + +undefined4 * __thiscall FUN_0042e740(int param_1,undefined4 *param_2,wchar_t *param_3) + +{ + int iVar1; + size_t sVar2; + LONG LVar3; + int *piVar4; + undefined4 *puVar5; + undefined *local_10; + int local_c; + int local_8; + int local_4; + + local_10 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + iVar1 = FUN_0042e240(&local_10,param_3); + if (iVar1 == 0) { + FUN_00402730(&DAT_00798f60); + sVar2 = wcslen(L"("); + FUN_004022d0(sVar2); + wcscpy(param_3,L"("); + FUN_004086c0(&local_c,&local_10); + LVar3 = InterlockedDecrement((LONG *)(param_3 + -8)); + if ((LVar3 == 0) && (param_3 + -10 != (wchar_t *)0x0)) { + (*(code *)**(undefined4 **)(param_3 + -10))(1); + } + piVar4 = (int *)FUN_004086c0(&local_4,&local_8); + if (local_10 != (undefined *)*piVar4) { + puVar5 = (undefined4 *)(local_10 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(local_10 + -0x10)); + if ((LVar3 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + local_10 = (undefined *)*piVar4; + InterlockedIncrement((LONG *)(local_10 + -0x10)); + } + LVar3 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + LVar3 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(local_c + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_c + -0x14))(1); + } + LVar3 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(local_8 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_8 + -0x14))(1); + } + } + else { + FUN_004027b0(&local_10,L"", + *(undefined4 *)(param_1 + 8),*(undefined4 *)(param_1 + 4),iVar1); + } + *param_2 = local_10; + InterlockedIncrement((LONG *)(local_10 + -0x10)); + puVar5 = (undefined4 *)(local_10 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(local_10 + -0x10)); + if ((LVar3 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + return param_2; +} + + + +// --- FUN_0042e8e0 at 0x0042E8E0 (size: 153) --- + +void FUN_0042e8e0(undefined4 param_1,int param_2) + +{ + int iVar1; + LONG LVar2; + undefined4 *puVar3; + undefined1 local_90 [144]; + + FUN_0042dc80(); + FUN_0042cbe0(¶m_2,1); + iVar1 = FUN_005df0f5(0x9c); + if (iVar1 != 0) { + iVar1 = FUN_0042ea40(param_1); + if (iVar1 != 0) { + FUN_0042de30(local_90); + FUN_0042db60(iVar1); + } + } + FUN_0042e590(); + puVar3 = (undefined4 *)(param_2 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + return; +} + + + +// --- FUN_0042e980 at 0x0042E980 (size: 102) --- + +undefined4 * FUN_0042e980(undefined4 *param_1,undefined4 param_2) + +{ + LONG LVar1; + undefined4 *puVar2; + undefined *local_4; + + local_4 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + FUN_0042e6b0(&local_4,param_2); + *param_1 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return param_1; +} + + + +// --- FUN_0042e9f0 at 0x0042E9F0 (size: 67) --- + +void FUN_0042e9f0(undefined4 param_1,int param_2) + +{ + LONG LVar1; + + FUN_00403350(&stack0xfffffff8,0); + FUN_0042e8e0(param_1); + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(param_2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_2 + -0x14))(); + } + return; +} + + + +// --- FUN_0042ea40 at 0x0042EA40 (size: 36) --- + +undefined4 * __thiscall FUN_0042ea40(undefined4 *param_1,undefined4 param_2) + +{ + *(undefined2 *)(param_1 + 1) = 1; + param_1[2] = param_2; + *param_1 = &PTR_FUN_00798fc0; + FUN_0042dc80(); + return param_1; +} + + + +// --- FUN_0042ea70 at 0x0042EA70 (size: 45) --- + +undefined4 * __thiscall FUN_0042ea70(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00798fc0; + FUN_0042e590(); + *param_1 = &PTR_LAB_00798fa4; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0042eaa0 at 0x0042EAA0 (size: 51) --- + +undefined4 __thiscall FUN_0042eaa0(int param_1,int param_2) + +{ + char cVar1; + + if ((*(short *)(param_1 + 4) == *(short *)(param_2 + 4)) && + (*(int *)(param_1 + 8) == *(int *)(param_2 + 8))) { + cVar1 = FUN_0042d540(param_2 + 0xc); + if (cVar1 != '\0') { + return 1; + } + } + return 0; +} + + + +// --- FUN_0042eb00 at 0x0042EB00 (size: 36) --- + +void __thiscall FUN_0042eb00(undefined4 *param_1,undefined4 param_2) + +{ + param_1[2] = param_2; + *(undefined2 *)(param_1 + 1) = 2; + *param_1 = &PTR_LAB_00798fd8; + param_1[4] = 0; + param_1[5] = 0; + *(undefined2 *)(param_1 + 6) = 0; + return; +} + + + +// --- FUN_0042eb30 at 0x0042EB30 (size: 58) --- + +undefined4 __thiscall FUN_0042eb30(int param_1,int param_2) + +{ + if ((((*(short *)(param_1 + 4) == *(short *)(param_2 + 4)) && + (*(int *)(param_1 + 8) == *(int *)(param_2 + 8))) && + (*(double *)(param_1 + 0x10) == *(double *)(param_2 + 0x10))) && + (*(short *)(param_1 + 0x18) == *(short *)(param_2 + 0x18))) { + return 1; + } + return 0; +} + + + +// --- FUN_0042eb70 at 0x0042EB70 (size: 32) --- + +void __thiscall FUN_0042eb70(undefined4 *param_1,undefined4 param_2) + +{ + param_1[2] = param_2; + *(undefined2 *)(param_1 + 1) = 4; + *param_1 = &PTR_LAB_00798ff0; + param_1[4] = 0; + param_1[5] = 0; + return; +} + + + +// --- FUN_0042eb90 at 0x0042EB90 (size: 51) --- + +undefined4 __thiscall FUN_0042eb90(int param_1,int param_2) + +{ + if ((((*(short *)(param_1 + 4) == *(short *)(param_2 + 4)) && + (*(int *)(param_1 + 8) == *(int *)(param_2 + 8))) && + (*(int *)(param_1 + 0x10) == *(int *)(param_2 + 0x10))) && + (*(int *)(param_1 + 0x14) == *(int *)(param_2 + 0x14))) { + return 1; + } + return 0; +} + + + +// --- FUN_0042ebd0 at 0x0042EBD0 (size: 32) --- + +void __thiscall FUN_0042ebd0(undefined4 *param_1,undefined4 param_2) + +{ + param_1[2] = param_2; + *(undefined2 *)(param_1 + 1) = 6; + *param_1 = &PTR_LAB_00799008; + param_1[4] = 0; + param_1[5] = 0; + return; +} + + + +// --- FUN_0042ec10 at 0x0042EC10 (size: 60) --- + +void __thiscall FUN_0042ec10(undefined4 *param_1,undefined4 param_2) + +{ + param_1[2] = param_2; + param_1[4] = 0; + param_1[5] = 0; + *(undefined2 *)(param_1 + 6) = 0; + param_1[8] = &PTR_FUN_00798fbc; + *(undefined1 *)(param_1 + 9) = 1; + *(undefined2 *)((int)param_1 + 0x26) = 0xffff; + *param_1 = &PTR_LAB_00799024; + param_1[8] = &PTR_LAB_00799020; + *(undefined2 *)(param_1 + 1) = 3; + return; +} + + + +// --- FUN_0042ec80 at 0x0042EC80 (size: 76) --- + +undefined4 __thiscall FUN_0042ec80(int param_1,int param_2) + +{ + if ((((*(short *)(param_1 + 4) == *(short *)(param_2 + 4)) && + (*(int *)(param_1 + 8) == *(int *)(param_2 + 8))) && + (*(double *)(param_1 + 0x10) == *(double *)(param_2 + 0x10))) && + (((*(short *)(param_1 + 0x18) == *(short *)(param_2 + 0x18) && + (*(char *)(param_1 + 0x24) == *(char *)(param_2 + 0x24))) && + (*(short *)(param_1 + 0x26) == *(short *)(param_2 + 0x26))))) { + return 1; + } + return 0; +} + + + +// --- FUN_0042ecd0 at 0x0042ECD0 (size: 56) --- + +void __thiscall FUN_0042ecd0(undefined4 *param_1,undefined4 param_2) + +{ + param_1[2] = param_2; + param_1[4] = 0; + param_1[5] = 0; + param_1[6] = &PTR_FUN_00798fbc; + *(undefined1 *)(param_1 + 7) = 1; + *(undefined2 *)((int)param_1 + 0x1e) = 0xffff; + *param_1 = &PTR_LAB_00799040; + param_1[6] = &PTR_LAB_0079903c; + *(undefined2 *)(param_1 + 1) = 5; + return; +} + + + +// --- FUN_0042ed40 at 0x0042ED40 (size: 69) --- + +undefined4 __thiscall FUN_0042ed40(int param_1,int param_2) + +{ + if ((((*(short *)(param_1 + 4) == *(short *)(param_2 + 4)) && + (*(int *)(param_1 + 8) == *(int *)(param_2 + 8))) && + (*(int *)(param_1 + 0x10) == *(int *)(param_2 + 0x10))) && + (((*(int *)(param_1 + 0x14) == *(int *)(param_2 + 0x14) && + (*(char *)(param_1 + 0x1c) == *(char *)(param_2 + 0x1c))) && + (*(short *)(param_1 + 0x1e) == *(short *)(param_2 + 0x1e))))) { + return 1; + } + return 0; +} + + + +// --- FUN_0042ed90 at 0x0042ED90 (size: 150) --- + +undefined4 FUN_0042ed90(undefined2 param_1) + +{ + int iVar1; + undefined4 uVar2; + + switch(param_1) { + case 1: + iVar1 = FUN_005df0f5(0x9c); + if (iVar1 != 0) { + uVar2 = FUN_0042ea40(0); + return uVar2; + } + break; + case 2: + iVar1 = FUN_005df0f5(0x20); + if (iVar1 != 0) { + uVar2 = FUN_0042eb00(0); + return uVar2; + } + break; + case 3: + iVar1 = FUN_005df0f5(0x28); + if (iVar1 != 0) { + uVar2 = FUN_0042ec10(0); + return uVar2; + } + break; + case 4: + case 6: + iVar1 = FUN_005df0f5(0x18); + if (iVar1 != 0) { + uVar2 = FUN_0042eb70(0); + return uVar2; + } + break; + case 5: + case 7: + iVar1 = FUN_005df0f5(0x20); + if (iVar1 != 0) { + uVar2 = FUN_0042ecd0(0); + return uVar2; + } + } + return 0; +} + + + +// --- FUN_0042ee50 at 0x0042EE50 (size: 51) --- + +undefined4 * __thiscall FUN_0042ee50(undefined4 *param_1,int param_2) + +{ + *param_1 = &PTR_LAB_00798fa4; + *(undefined2 *)(param_1 + 1) = *(undefined2 *)(param_2 + 4); + param_1[2] = *(undefined4 *)(param_2 + 8); + *param_1 = &PTR_FUN_00798fc0; + FUN_0042e510(param_2 + 0xc); + return param_1; +} + + + +// --- FUN_0042ee90 at 0x0042EE90 (size: 55) --- + +void __thiscall FUN_0042ee90(undefined4 *param_1,int param_2) + +{ + *param_1 = &PTR_LAB_00798fa4; + *(undefined2 *)(param_1 + 1) = *(undefined2 *)(param_2 + 4); + param_1[2] = *(undefined4 *)(param_2 + 8); + *param_1 = &PTR_LAB_00798fd8; + param_1[4] = *(undefined4 *)(param_2 + 0x10); + param_1[5] = *(undefined4 *)(param_2 + 0x14); + *(undefined2 *)(param_1 + 6) = *(undefined2 *)(param_2 + 0x18); + return; +} + + + +// --- FUN_0042eed0 at 0x0042EED0 (size: 89) --- + +void __thiscall FUN_0042eed0(undefined4 *param_1,int param_2) + +{ + undefined4 uVar1; + + *param_1 = &PTR_LAB_00798fa4; + *(undefined2 *)(param_1 + 1) = *(undefined2 *)(param_2 + 4); + uVar1 = *(undefined4 *)(param_2 + 8); + *param_1 = &PTR_LAB_00798fd8; + param_1[2] = uVar1; + param_1[4] = *(undefined4 *)(param_2 + 0x10); + param_1[5] = *(undefined4 *)(param_2 + 0x14); + *(undefined2 *)(param_1 + 6) = *(undefined2 *)(param_2 + 0x18); + param_1[8] = &PTR_FUN_00798fbc; + *(undefined1 *)(param_1 + 9) = *(undefined1 *)(param_2 + 0x24); + *(undefined2 *)((int)param_1 + 0x26) = *(undefined2 *)(param_2 + 0x26); + *param_1 = &PTR_LAB_00799024; + param_1[8] = &PTR_LAB_00799020; + return; +} + + + +// --- FUN_0042ef30 at 0x0042EF30 (size: 47) --- + +void __thiscall FUN_0042ef30(undefined4 *param_1,int param_2) + +{ + *param_1 = &PTR_LAB_00798fa4; + *(undefined2 *)(param_1 + 1) = *(undefined2 *)(param_2 + 4); + param_1[2] = *(undefined4 *)(param_2 + 8); + *param_1 = &PTR_LAB_00798ff0; + param_1[4] = *(undefined4 *)(param_2 + 0x10); + param_1[5] = *(undefined4 *)(param_2 + 0x14); + return; +} + + + +// --- FUN_0042ef60 at 0x0042EF60 (size: 81) --- + +void __thiscall FUN_0042ef60(undefined4 *param_1,int param_2) + +{ + undefined4 uVar1; + + *param_1 = &PTR_LAB_00798fa4; + *(undefined2 *)(param_1 + 1) = *(undefined2 *)(param_2 + 4); + uVar1 = *(undefined4 *)(param_2 + 8); + *param_1 = &PTR_LAB_00798ff0; + param_1[2] = uVar1; + param_1[4] = *(undefined4 *)(param_2 + 0x10); + param_1[5] = *(undefined4 *)(param_2 + 0x14); + param_1[6] = &PTR_FUN_00798fbc; + *(undefined1 *)(param_1 + 7) = *(undefined1 *)(param_2 + 0x1c); + *(undefined2 *)((int)param_1 + 0x1e) = *(undefined2 *)(param_2 + 0x1e); + *param_1 = &PTR_LAB_00799040; + param_1[6] = &PTR_LAB_0079903c; + return; +} + + + +// --- FUN_0042efc0 at 0x0042EFC0 (size: 47) --- + +void __thiscall FUN_0042efc0(undefined4 *param_1,int param_2) + +{ + *param_1 = &PTR_LAB_00798fa4; + *(undefined2 *)(param_1 + 1) = *(undefined2 *)(param_2 + 4); + param_1[2] = *(undefined4 *)(param_2 + 8); + *param_1 = &PTR_LAB_00799008; + param_1[4] = *(undefined4 *)(param_2 + 0x10); + param_1[5] = *(undefined4 *)(param_2 + 0x14); + return; +} + + + +// --- FUN_0042eff0 at 0x0042EFF0 (size: 81) --- + +void __thiscall FUN_0042eff0(undefined4 *param_1,int param_2) + +{ + undefined4 uVar1; + + *param_1 = &PTR_LAB_00798fa4; + *(undefined2 *)(param_1 + 1) = *(undefined2 *)(param_2 + 4); + uVar1 = *(undefined4 *)(param_2 + 8); + *param_1 = &PTR_LAB_00799008; + param_1[2] = uVar1; + param_1[4] = *(undefined4 *)(param_2 + 0x10); + param_1[5] = *(undefined4 *)(param_2 + 0x14); + param_1[6] = &PTR_FUN_00798fbc; + *(undefined1 *)(param_1 + 7) = *(undefined1 *)(param_2 + 0x1c); + *(undefined2 *)((int)param_1 + 0x1e) = *(undefined2 *)(param_2 + 0x1e); + *param_1 = &PTR_LAB_00799058; + param_1[6] = &PTR_LAB_0079903c; + return; +} + + + +// --- FUN_0042f050 at 0x0042F050 (size: 101) --- + +undefined1 FUN_0042f050(int param_1,int param_2) + +{ + undefined1 uVar1; + + uVar1 = 0; + if (((param_1 != 0) && (param_2 != 0)) && (*(short *)(param_1 + 4) == *(short *)(param_2 + 4))) { + switch(*(short *)(param_1 + 4)) { + case 1: + uVar1 = FUN_0042eaa0(param_1); + return uVar1; + case 2: + uVar1 = FUN_0042eb30(param_1); + return uVar1; + case 3: + uVar1 = FUN_0042ec80(param_1); + return uVar1; + case 4: + uVar1 = FUN_0042eb90(param_1); + return uVar1; + case 5: + uVar1 = FUN_0042ed40(param_1); + return uVar1; + case 6: + uVar1 = FUN_0042eb90(param_1); + return uVar1; + case 7: + uVar1 = FUN_0042ed40(param_1); + } + } + return uVar1; +} + + + +// --- FUN_0042f0e0 at 0x0042F0E0 (size: 100) --- + +void __thiscall FUN_0042f0e0(int param_1,int param_2) + +{ + undefined2 *puVar1; + undefined4 *puVar2; + + FUN_0040ad10(2); + puVar1 = (undefined2 *)FUN_0040acf0(2); + if (puVar1 != (undefined2 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined2 *)(param_1 + 4) = *puVar1; + } + else { + *puVar1 = *(undefined2 *)(param_1 + 4); + } + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *puVar2 = *(undefined4 *)(param_1 + 8); + return; + } + *(undefined4 *)(param_1 + 8) = *puVar2; + } + return; +} + + + +// --- FUN_0042f180 at 0x0042F180 (size: 118) --- + +void __thiscall FUN_0042f180(int param_1,int param_2) + +{ + undefined4 *puVar1; + undefined2 *puVar2; + + FUN_0042f0e0(param_2); + FUN_0040ad10(8); + puVar1 = (undefined4 *)FUN_0040acf0(8); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x10) = *puVar1; + *(undefined4 *)(param_1 + 0x14) = puVar1[1]; + } + else { + *puVar1 = *(undefined4 *)(param_1 + 0x10); + puVar1[1] = *(undefined4 *)(param_1 + 0x14); + } + } + FUN_0040ad10(2); + puVar2 = (undefined2 *)FUN_0040acf0(2); + if (puVar2 != (undefined2 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *puVar2 = *(undefined2 *)(param_1 + 0x18); + return; + } + *(undefined2 *)(param_1 + 0x18) = *puVar2; + } + return; +} + + + +// --- FUN_0042f250 at 0x0042F250 (size: 73) --- + +void __thiscall FUN_0042f250(int param_1,int param_2) + +{ + undefined2 *puVar1; + + FUN_00422250(param_1 + 4,param_2); + FUN_0040ad10(2); + puVar1 = (undefined2 *)FUN_0040acf0(2); + if (puVar1 != (undefined2 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *puVar1 = *(undefined2 *)(param_1 + 6); + return; + } + *(undefined2 *)(param_1 + 6) = *puVar1; + } + return; +} + + + +// --- FUN_0042f3a0 at 0x0042F3A0 (size: 219) --- + +undefined4 FUN_0042f3a0(int param_1) + +{ + int iVar1; + undefined4 uVar2; + + if (param_1 != 0) { + switch(*(undefined2 *)(param_1 + 4)) { + case 1: + iVar1 = FUN_005df0f5(0x9c); + if (iVar1 != 0) { + uVar2 = FUN_0042ee50(param_1); + return uVar2; + } + break; + case 2: + iVar1 = FUN_005df0f5(0x20); + if (iVar1 != 0) { + uVar2 = FUN_0042ee90(param_1); + return uVar2; + } + break; + case 3: + iVar1 = FUN_005df0f5(0x28); + if (iVar1 != 0) { + uVar2 = FUN_0042eed0(param_1); + return uVar2; + } + break; + case 4: + iVar1 = FUN_005df0f5(0x18); + if (iVar1 != 0) { + uVar2 = FUN_0042ef30(param_1); + return uVar2; + } + break; + case 5: + iVar1 = FUN_005df0f5(0x20); + if (iVar1 != 0) { + uVar2 = FUN_0042ef60(param_1); + return uVar2; + } + break; + case 6: + iVar1 = FUN_005df0f5(0x18); + if (iVar1 != 0) { + uVar2 = FUN_0042efc0(param_1); + return uVar2; + } + break; + case 7: + iVar1 = FUN_005df0f5(0x20); + if (iVar1 != 0) { + uVar2 = FUN_0042eff0(param_1); + return uVar2; + } + } + } + return 0; +} + + + +// --- FUN_0042f4a0 at 0x0042F4A0 (size: 1141) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 * +FUN_0042f4a0(undefined4 *param_1,double param_2,ushort param_3,char param_4,uint param_5) + +{ + undefined *puVar1; + int iVar2; + LONG LVar3; + uint uVar4; + int iVar5; + short sVar6; + int unaff_ESI; + undefined4 *puVar7; + short sVar8; + code *pcVar9; + float10 fVar10; + undefined8 uVar11; + ulonglong uVar12; + undefined2 auStackY_10080 [32700]; + wchar_t *pwVar13; + undefined1 *puVar14; + undefined *local_e4; + undefined4 uStack_e0; + uint local_dc; + undefined *local_d8; + uint local_d4; + undefined *local_d0; + undefined *local_cc; + int local_c8; + ushort local_c4 [2]; + wchar_t *local_c0; + ushort local_bc [2]; + double local_b8; + double local_b0; + uint local_a8; + undefined4 local_a4; + double local_a0; + int local_98; + uint uStack_94; + double local_90; + undefined4 local_88; + uint uStack_84; + undefined2 uStack_80; + undefined1 auStack_7e [124]; + undefined2 local_2; + + local_e4 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + local_b0 = ABS(param_2); + sVar8 = -param_3; + local_2 = 0; + sVar6 = 0x3e; + local_c8 = 0; + local_a0 = local_b0; + if (local_b0 < _DAT_007938c0) { + local_a0 = 1.0; + } + if (DAT_00837cc8 != 0) { + local_d4 = param_5; + if ((short)param_5 == -1) { + FUN_00422120(&local_d4); + } + if ((1 < (ushort)local_d4) && (param_3 < 0x15)) { + FUN_00422100((int)&uStack_e0 + 3); + FUN_004220e0(local_c4); + local_d8 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + FUN_00422510(&local_d8); + local_dc = local_d4 & 0xffff; + if (*(int *)(local_d8 + -4) - 1U < local_dc) { + *param_1 = local_e4; + InterlockedIncrement((LONG *)(local_e4 + -0x10)); + FUN_004011b0(); + FUN_004011b0(); + return param_1; + } + local_dc = (uint)sVar8; + fVar10 = (float10)_CIpow(); + local_b8 = (double)fVar10; + FUN_00422140(local_bc); + local_d0 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + FUN_00422560(&local_d0); + local_cc = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + FUN_004225b0(&local_cc); + local_a8 = local_d4 & 0xffff; + local_90 = (double)local_a8; + local_a4 = 0; + while( true ) { + local_dc = -(int)sVar8; + _CIpow(); + uVar11 = FUN_005df4c4(); + uVar12 = __aullrem(uVar11,local_a8,local_a4); + puVar1 = local_d0; + uVar4 = (uint)(uVar12 >> 0x20); + local_98 = (int)uVar12; + (&uStack_80)[sVar6] = *(undefined2 *)(local_d8 + local_98 * 2); + uStack_94 = uVar4 & 0x7fffffff; + uStack_84 = uVar4 & 0x80000000; + local_88 = 0; + sVar6 = sVar6 + -1; + local_c8 = local_c8 + 1; + sVar8 = sVar8 + 1; + local_b0 = local_b0 - + (-(double)(longlong)(((ulonglong)uVar4 & 0x80000000) << 0x20) + + (double)(uVar12 & 0x7fffffffffffffff)) * local_b8; + local_b8 = local_90 * local_b8; + if ((local_a0 < local_b8) && + ((uStack_e0._3_1_ == '\0' || ((int)(uint)local_c4[0] <= (int)(short)local_c8)))) break; + if (sVar6 == 0) { + *param_1 = local_e4; + InterlockedIncrement((LONG *)(local_e4 + -0x10)); + pcVar9 = InterlockedDecrement_exref; +LAB_0042f82c: + puVar7 = (undefined4 *)(local_cc + -0x14); + iVar2 = (*pcVar9)(local_cc + -0x10); + if ((iVar2 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + puVar7 = (undefined4 *)(local_d4 - 0x14); + iVar2 = (*pcVar9)(local_d4 - 0x10); + if ((iVar2 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + iVar2 = (*pcVar9)(uStack_e0 + -0x10); + if ((iVar2 == 0) && ((undefined4 *)(uStack_e0 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(uStack_e0 + -0x14))(1); + } + iVar2 = (*pcVar9)(unaff_ESI + -0x10); + if ((iVar2 == 0) && ((undefined4 *)(unaff_ESI + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(unaff_ESI + -0x14))(1); + } + return param_1; + } + if (((param_4 != '\0') && (0 < sVar8)) && ((int)sVar8 % (int)(uint)local_bc[0] == 0)) { + for (iVar2 = *(int *)(local_d0 + -4) + -2; -1 < iVar2; iVar2 = iVar2 + -1) { + iVar5 = (int)sVar6; + sVar6 = sVar6 + -1; + (&uStack_80)[iVar5] = *(undefined2 *)(puVar1 + iVar2 * 2); + } + } + if (sVar8 == 0) { + for (iVar2 = *(int *)(local_cc + -4) + -2; -1 < iVar2; iVar2 = iVar2 + -1) { + iVar5 = (int)sVar6; + sVar6 = sVar6 + -1; + (&uStack_80)[iVar5] = *(undefined2 *)(local_cc + iVar2 * 2); + } + } + } + local_c0 = (wchar_t *)PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + FUN_00422600(&local_c0); + if (_DAT_00795610 <= param_2) { + puVar14 = auStack_7e + sVar6 * 2; + if ((ushort)local_d4 == 0x10) { + pwVar13 = L"0x%s"; + } + else { + pwVar13 = L"%s"; + } + } + else { + puVar14 = auStack_7e + sVar6 * 2; + pwVar13 = local_c0; + } + FUN_004027b0(&local_e4,pwVar13,puVar14); + *param_1 = local_e4; + InterlockedIncrement((LONG *)(local_e4 + -0x10)); + pcVar9 = InterlockedDecrement_exref; + pwVar13 = local_c0 + -10; + LVar3 = InterlockedDecrement((LONG *)(local_c0 + -8)); + if ((LVar3 == 0) && (pwVar13 != (wchar_t *)0x0)) { + (*(code *)**(undefined4 **)pwVar13)(1); + } + goto LAB_0042f82c; + } + } + *param_1 = local_e4; + InterlockedIncrement((LONG *)(local_e4 + -0x10)); + puVar7 = (undefined4 *)(local_e4 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(local_e4 + -0x10)); + if ((LVar3 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + return param_1; +} + + + +// --- FUN_0042fb60 at 0x0042FB60 (size: 87) --- + +undefined4 __thiscall FUN_0042fb60(undefined4 *param_1,undefined4 *param_2) + +{ + byte bVar1; + byte *pbVar2; + int iVar3; + byte *pbVar4; + bool bVar5; + + pbVar4 = (byte *)*param_2; + pbVar2 = (byte *)*param_1; + while( true ) { + bVar1 = *pbVar2; + bVar5 = bVar1 < *pbVar4; + if (bVar1 != *pbVar4) break; + if (bVar1 == 0) { + return 0; + } + bVar1 = pbVar2[1]; + bVar5 = bVar1 < pbVar4[1]; + if (bVar1 != pbVar4[1]) break; + pbVar2 = pbVar2 + 2; + pbVar4 = pbVar4 + 2; + if (bVar1 == 0) { + return 0; + } + } + iVar3 = (1 - (uint)bVar5) - (uint)(bVar5 != 0); + return CONCAT31((int3)((uint)iVar3 >> 8),iVar3 < 0); +} + + + +// --- FUN_0042fbc0 at 0x0042FBC0 (size: 64) --- + +undefined4 * __thiscall FUN_0042fbc0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00799124; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0042fc00 at 0x0042FC00 (size: 172) --- + +void __thiscall FUN_0042fc00(int *param_1,int param_2) + +{ + undefined4 *puVar1; + uint *puVar2; + uint uVar3; + undefined4 *puVar4; + uint uVar5; + + uVar5 = param_1[2]; + FUN_0040ad10(4); + puVar2 = (uint *)FUN_0040acf0(4); + if (puVar2 != (uint *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + uVar5 = *puVar2; + } + else { + *puVar2 = uVar5; + } + } + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + uVar3 = FUN_0040a8f0(); + if (uVar3 < uVar5) { + FUN_0040aa50(); + return; + } + param_1[2] = 0; + FUN_0040ee80(uVar5,1); + } + if (param_1[2] != 0) { + uVar5 = 0; + do { + puVar1 = (undefined4 *)(*param_1 + uVar5 * 4); + FUN_0040ad10(4); + puVar4 = (undefined4 *)FUN_0040acf0(4); + if (puVar4 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *puVar1 = *puVar4; + } + else { + *puVar4 = *puVar1; + } + } + uVar5 = uVar5 + 1; + } while (uVar5 < (uint)param_1[2]); + } + return; +} + + + +// --- FUN_0042fd20 at 0x0042FD20 (size: 80) --- + +undefined4 * __fastcall FUN_0042fd20(undefined4 *param_1) + +{ + LONG *lpAddend; + + *param_1 = DAT_00837f54; + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[1] = PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + param_1[2] = 0; + param_1[3] = 0; + param_1[4] = 0; + param_1[5] = 0; + param_1[6] = 0; + param_1[7] = 0; + param_1[8] = 0; + param_1[9] = 0; + param_1[10] = 0; + param_1[0xb] = 0; + param_1[0xc] = 0; + param_1[0xd] = 0; + param_1[0xe] = 1; + return param_1; +} + + + +// --- FUN_0042fd70 at 0x0042FD70 (size: 155) --- + +void __fastcall FUN_0042fd70(int param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + if (((*(uint *)(param_1 + 0x30) & 0x80000000) == 0x80000000) && (*(int *)(param_1 + 0x2c) != 0)) { + FUN_00407920(3); + } + if ((*(uint *)(param_1 + 0x24) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)(param_1 + 0x20)); + } + if (((*(uint *)(param_1 + 0x18) & 0x80000000) == 0x80000000) && (*(int *)(param_1 + 0x14) != 0)) { + FUN_00407920(3); + } + if (((*(uint *)(param_1 + 0xc) & 0x80000000) == 0x80000000) && (*(int *)(param_1 + 8) != 0)) { + FUN_00407920(3); + } + puVar2 = (undefined4 *)(*(int *)(param_1 + 4) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)(param_1 + 4) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return; +} + + + +// --- FUN_0042fe10 at 0x0042FE10 (size: 642) --- + +bool __fastcall FUN_0042fe10(int param_1) + +{ + wchar_t *pwVar1; + bool bVar2; + size_t sVar3; + int iVar4; + LONG LVar5; + char cVar6; + int iVar7; + wchar_t *local_18; + wchar_t *pwStack_14; + wchar_t *local_10; + uint local_c; + int local_8; + wchar_t *pwStack_4; + + local_8 = 0; + local_c = 0; + if (*(int *)(param_1 + 0x34) != 0) { + do { + sVar3 = wcslen(L"PRE"); + FUN_004022d0(sVar3); + wcscpy(local_10,L"PRE"); + iVar7 = local_c * 4; + pwVar1 = *(wchar_t **)(*(int *)(param_1 + 0x2c) + iVar7); + if (*(int *)(pwVar1 + -2) == *(int *)(local_10 + -2)) { + if ((((*(int *)(pwVar1 + -4) != *(int *)(local_10 + -4)) && (*(int *)(pwVar1 + -4) != -1)) + && (*(int *)(local_10 + -4) != -1)) || (iVar4 = wcscmp(pwVar1,local_10), iVar4 != 0)) + goto LAB_0042fea8; +LAB_0043003f: + bVar2 = true; + } + else { +LAB_0042fea8: + sVar3 = wcslen(L"NAME"); + FUN_004022d0(sVar3); + wcscpy(local_18,L"NAME"); + pwVar1 = *(wchar_t **)(*(int *)(param_1 + 0x2c) + iVar7); + if (*(int *)(pwVar1 + -2) == *(int *)(local_18 + -2)) { + if (((*(int *)(pwVar1 + -4) == *(int *)(local_18 + -4)) || (*(int *)(pwVar1 + -4) == -1)) + || (*(int *)(local_18 + -4) == -1)) { + iVar4 = wcscmp(pwVar1,local_18); + cVar6 = '\x01' - (iVar4 != 0); + } + else { + cVar6 = '\0'; + } + } + else { + cVar6 = '\0'; + } + LVar5 = InterlockedDecrement((LONG *)(local_18 + -8)); + if ((LVar5 == 0) && (local_18 + -10 != (wchar_t *)0x0)) { + (*(code *)**(undefined4 **)(local_18 + -10))(1); + } + if (cVar6 != '\0') goto LAB_0043003f; + sVar3 = wcslen(L"MID"); + FUN_004022d0(sVar3); + wcscpy(pwStack_14,L"MID"); + pwVar1 = *(wchar_t **)(*(int *)(param_1 + 0x2c) + iVar7); + cVar6 = '\0'; + if (*(int *)(pwVar1 + -2) == *(int *)(pwStack_14 + -2)) { + if (((*(int *)(pwVar1 + -4) == *(int *)(pwStack_14 + -4)) || (*(int *)(pwVar1 + -4) == -1) + ) || (*(int *)(pwStack_14 + -4) == -1)) { + iVar4 = wcscmp(pwVar1,pwStack_14); + cVar6 = '\x01' - (iVar4 != 0); + } + else { + cVar6 = '\0'; + } + } + LVar5 = InterlockedDecrement((LONG *)(pwStack_14 + -8)); + if ((LVar5 == 0) && (pwStack_14 + -10 != (wchar_t *)0x0)) { + (*(code *)**(undefined4 **)(pwStack_14 + -10))(1); + } + if (cVar6 != '\0') goto LAB_0043003f; + FUN_00402730(L"POST"); + pwVar1 = *(wchar_t **)(*(int *)(param_1 + 0x2c) + iVar7); + cVar6 = '\0'; + if (*(int *)(pwVar1 + -2) == *(int *)(pwStack_4 + -2)) { + if (((*(int *)(pwVar1 + -4) == *(int *)(pwStack_4 + -4)) || (*(int *)(pwVar1 + -4) == -1)) + || (*(int *)(pwStack_4 + -4) == -1)) { + iVar7 = wcscmp(pwVar1,pwStack_4); + cVar6 = '\x01' - (iVar7 != 0); + } + else { + cVar6 = '\0'; + } + } + LVar5 = InterlockedDecrement((LONG *)(pwStack_4 + -8)); + if ((LVar5 == 0) && (pwStack_4 + -10 != (wchar_t *)0x0)) { + (*(code *)**(undefined4 **)(pwStack_4 + -10))(1); + } + bVar2 = false; + if (cVar6 != '\0') goto LAB_0043003f; + } + LVar5 = InterlockedDecrement((LONG *)(local_10 + -8)); + if ((LVar5 == 0) && (local_10 + -10 != (wchar_t *)0x0)) { + (*(code *)**(undefined4 **)(local_10 + -10))(1); + } + if (bVar2) { + local_8 = local_8 + 1; + } + local_c = local_c + 1; + } while (local_c < *(uint *)(param_1 + 0x34)); + } + return 1 < local_8; +} + + + diff --git a/docs/research/decompiled/chunk_00430000.c b/docs/research/decompiled/chunk_00430000.c new file mode 100644 index 0000000..1d37343 --- /dev/null +++ b/docs/research/decompiled/chunk_00430000.c @@ -0,0 +1,13263 @@ +// Decompiled from acclient.exe — chunk 0x00430000 +// Ghidra 12.0.4 + pyghidra headless + +// --- FUN_004300a0 at 0x004300A0 (size: 106) --- + +undefined4 FUN_004300a0(undefined4 param_1,undefined4 param_2) + +{ + undefined *puVar1; + undefined4 uVar2; + LONG LVar3; + + puVar1 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + uVar2 = FUN_00402520(param_2,&stack0x0000000c); + if (*(int *)(puVar1 + -4) != 1) { + FUN_00402490(puVar1,*(int *)(puVar1 + -4) + -1); + } + LVar3 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + return uVar2; +} + + + +// --- FUN_00430110 at 0x00430110 (size: 137) --- + +void __thiscall FUN_00430110(int param_1,int param_2) + +{ + uint *puVar1; + uint uVar2; + uint uVar3; + + uVar3 = *(uint *)(param_1 + 8); + FUN_0040ad10(4); + puVar1 = (uint *)FUN_0040acf0(4); + if (puVar1 != (uint *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + uVar3 = *puVar1; + } + else { + *puVar1 = uVar3; + } + } + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + uVar2 = FUN_0040a8f0(); + if (uVar2 < uVar3) { + FUN_0040aa50(); + return; + } + *(undefined4 *)(param_1 + 8) = 0; + FUN_00407fe0(uVar3,1); + } + uVar3 = 0; + if (*(int *)(param_1 + 8) != 0) { + do { + FUN_004227d0(param_2); + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 8)); + } + return; +} + + + +// --- FUN_004301a0 at 0x004301A0 (size: 63) --- + +uint __thiscall FUN_004301a0(int param_1,uint param_2) + +{ + uint *puVar1; + + puVar1 = *(uint **)(*(int *)(param_1 + 0xa0) + (param_2 % *(uint *)(param_1 + 0xa8)) * 4); + while( true ) { + if (puVar1 == (uint *)0x0) { + return 0; + } + if (*puVar1 == param_2) break; + puVar1 = (uint *)puVar1[1]; + } + if (puVar1 == (uint *)0x0) { + return 0; + } + return puVar1[2]; +} + + + +// --- FUN_004301e0 at 0x004301E0 (size: 143) --- + +undefined4 * __thiscall FUN_004301e0(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00799124; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00430270 at 0x00430270 (size: 940) --- + +byte __thiscall +FUN_00430270(int param_1,undefined *param_2,undefined *param_3,undefined4 param_4,char param_5) + +{ + int iVar1; + undefined *puVar2; + char cVar3; + undefined4 uVar4; + int iVar5; + int *piVar6; + LONG LVar7; + int *extraout_ECX; + uint uVar8; + undefined4 *puVar9; + int local_24; + uint uStack_20; + undefined4 uStack_1c; + int iStack_18; + uint uStack_14; + undefined4 uStack_10; + undefined1 auStack_c [8]; + undefined *local_4; + + puVar2 = param_3; + uVar8 = 0; + piVar6 = *(int **)(*(int *)(param_1 + 0xa0) + ((uint)param_3 % *(uint *)(param_1 + 0xa8)) * 4); + if (piVar6 != (int *)0x0) { + while ((undefined *)*piVar6 != param_3) { + piVar6 = (int *)piVar6[1]; + if (piVar6 == (int *)0x0) { + return 2; + } + } + if ((piVar6 != (int *)0x0) && (piVar6 = (int *)piVar6[2], piVar6 != (int *)0x0)) { + if (*piVar6 != DAT_00837f54) { + uVar4 = FUN_004220b0(*piVar6,0x25); + iVar5 = FUN_00415430(uVar4); + if (iVar5 == 0) { + return 5; + } + piVar6 = (int *)FUN_004301a0(puVar2); + if (piVar6 == (int *)0x0) { + (**(code **)(*extraout_ECX + 0x14))(); + return 4; + } + (**(code **)(*extraout_ECX + 0x14))(); + } + if (param_5 == '\0') { + FUN_0040b220(); + param_5 = '\0'; + cVar3 = '\0'; + if (piVar6[7] != 0) { + do { + iVar5 = *(int *)(piVar6[5] + uVar8 * 4); + iVar1 = *(int *)(iVar5 + -4); + if (iVar1 != 1) { + FUN_00402490(iVar5,iVar1 + -1); + } + if (uVar8 < (uint)piVar6[10]) { + param_2 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + cVar3 = FUN_0041ae30(piVar6[8] + uVar8 * 4,¶m_2); + puVar2 = param_2; + if (cVar3 == '\0') { + param_5 = '\x01'; + } + if (*(int *)(param_2 + -4) != 1) { + FUN_00402490(param_2,*(int *)(param_2 + -4) + -1); + } + puVar9 = (undefined4 *)(puVar2 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar7 == 0) && (puVar9 != (undefined4 *)0x0)) { + (**(code **)*puVar9)(1); + } + } + uVar8 = uVar8 + 1; + cVar3 = param_5; + } while (uVar8 < (uint)piVar6[7]); + } + return -(cVar3 != '\0') & 6; + } + local_4 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + local_24 = 0; + uStack_20 = 0; + uStack_1c = 0; + param_5 = '\0'; + if (piVar6[10] != 0) { + do { + param_3 = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + cVar3 = FUN_0041ae30(piVar6[8] + uVar8 * 4,¶m_3); + if (cVar3 == '\0') { + param_5 = '\x01'; + } + FUN_00408e40(¶m_3); + puVar9 = (undefined4 *)(param_3 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar7 == 0) && (puVar9 != (undefined4 *)0x0)) { + (**(code **)*puVar9)(1); + } + uVar8 = uVar8 + 1; + } while (uVar8 < (uint)piVar6[10]); + if (param_5 != '\0') { + if (((uStack_20 & 0x80000000) == 0x80000000) && (local_24 != 0)) { + FUN_00407920(3); + } + puVar9 = (undefined4 *)(local_4 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar7 == 0) && (puVar9 != (undefined4 *)0x0)) { + (**(code **)*puVar9)(1); + } + return 6; + } + } + iStack_18 = 0; + uStack_14 = 0; + uStack_10 = 0; + cVar3 = FUN_0067e150(piVar6 + 5,&local_24,piVar6 + 0xb,param_2,&iStack_18,1,auStack_c); + puVar2 = PTR_DAT_00818344; + if (cVar3 == '\0') { + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + puVar9 = (undefined4 *)(puVar2 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar7 == 0) && (puVar9 != (undefined4 *)0x0)) { + (**(code **)*puVar9)(1); + } + if (((uStack_14 & 0x80000000) == 0x80000000) && (iStack_18 != 0)) { + FUN_00407920(3); + } + if (((uStack_20 & 0x80000000) == 0x80000000) && (local_24 != 0)) { + FUN_00407920(3); + } + puVar9 = (undefined4 *)(local_4 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar7 == 0) && (puVar9 != (undefined4 *)0x0)) { + (**(code **)*puVar9)(1); + } + return 7; + } + if (((uStack_14 & 0x80000000) == 0x80000000) && (iStack_18 != 0)) { + FUN_00407920(3); + } + if (((uStack_20 & 0x80000000) == 0x80000000) && (local_24 != 0)) { + FUN_00407920(3); + } + puVar9 = (undefined4 *)(local_4 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar7 == 0) && (puVar9 != (undefined4 *)0x0)) { + (**(code **)*puVar9)(1); + } + return 0; + } + } + return 2; +} + + + +// --- FUN_00430620 at 0x00430620 (size: 149) --- + +void __thiscall FUN_00430620(undefined4 *param_1,int param_2) + +{ + char cVar1; + undefined4 *puVar2; + char *pcVar3; + + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *param_1 = *puVar2; + } + else { + *puVar2 = *param_1; + } + } + FUN_00430110(param_2); + FUN_0042fc00(param_2); + cVar1 = FUN_0042fe10(); + FUN_0040ad10(1); + pcVar3 = (char *)FUN_0040acf0(1); + if (pcVar3 != (char *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + cVar1 = *pcVar3; + } + else { + *pcVar3 = cVar1; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + if (cVar1 == '\0') { + return; + } + if (cVar1 != '\x01') { + FUN_0040aa50(); + } + } + if (cVar1 != '\0') { + FUN_00430110(param_2); + } + return; +} + + + +// --- FUN_004306c0 at 0x004306C0 (size: 198) --- + +void __fastcall FUN_004306c0(int param_1) + +{ + undefined *puVar1; + int iVar2; + void *pvVar3; + LONG LVar4; + int *piVar5; + LONG *lpAddend; + int iVar6; + undefined1 local_c [12]; + + *(undefined4 *)(param_1 + 0x30) = 0; + puVar1 = *(undefined **)(param_1 + 0x34); + if (puVar1 != PTR_DAT_00818340) { + LVar4 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818340 + -0x10); + *(undefined **)(param_1 + 0x34) = PTR_DAT_00818340; + InterlockedIncrement(lpAddend); + } + *(undefined4 *)(param_1 + 0x38) = 0; + piVar5 = (int *)FUN_0052dcf0(local_c); + iVar6 = piVar5[2]; + iVar2 = *piVar5; + piVar5 = (int *)piVar5[1]; + while (iVar6 != 0) { + do { + pvVar3 = *(void **)(iVar6 + 8); + if (pvVar3 != (void *)0x0) { + FUN_0042fd70(); + operator_delete(pvVar3); + } + *(undefined4 *)(iVar6 + 8) = 0; + iVar6 = *(int *)(iVar6 + 4); + } while (iVar6 != 0); + do { + piVar5 = piVar5 + 1; + if (piVar5 == (int *)(*(int *)(iVar2 + 0x60) + *(int *)(iVar2 + 0x68) * 4)) goto LAB_00430777; + iVar6 = *piVar5; + } while (iVar6 == 0); + } +LAB_00430777: + FUN_005870f0(); + return; +} + + + +// --- FUN_00430790 at 0x00430790 (size: 82) --- + +undefined4 * __thiscall FUN_00430790(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00799150; + FUN_005870f0(); + param_1[1] = &PTR_FUN_00799124; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00430850 at 0x00430850 (size: 114) --- + +void __fastcall FUN_00430850(undefined4 *param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + *param_1 = &PTR_LAB_00799158; + FUN_004306c0(); + param_1[0xf] = &PTR_FUN_00799150; + FUN_005870f0(); + param_1[0x10] = &PTR_FUN_00799124; + if ((undefined4 *)param_1[0x28] != param_1 + 0x11) { + operator_delete__((undefined4 *)param_1[0x28]); + } + param_1[0x28] = 0; + param_1[0x29] = 0; + param_1[0x2a] = 0; + param_1[0x2b] = 0; + puVar2 = (undefined4 *)(param_1[0xd] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0xd] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_004154b0(); + return; +} + + + +// --- FUN_004308d0 at 0x004308D0 (size: 121) --- + +void FUN_004308d0(undefined4 param_1,undefined4 *param_2,int param_3) + +{ + undefined4 *puVar1; + int iVar2; + undefined4 uVar3; + + FUN_0040ad10(4); + puVar1 = (undefined4 *)FUN_0040acf0(4); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_3 + 4) & 1) == 0) { + *param_2 = *puVar1; + } + else { + *puVar1 = *param_2; + } + } + if ((*(uint *)(param_3 + 4) >> 2 & 1) == 0) { + if ((~*(byte *)(param_3 + 4) & 1) != 0) { + iVar2 = FUN_005df0f5(0x3c); + if (iVar2 == 0) { + uVar3 = 0; + } + else { + uVar3 = FUN_0042fd20(); + } + param_2[2] = uVar3; + } + if (param_2[2] == 0) { + FUN_0040aa50(); + return; + } + FUN_00430620(param_3); + } + return; +} + + + +// --- FUN_00430980 at 0x00430980 (size: 30) --- + +void * __thiscall FUN_00430980(void *param_1,byte param_2) + +{ + FUN_00430850(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004309a0 at 0x004309A0 (size: 435) --- + +void FUN_004309a0(undefined4 param_1,int param_2,uint param_3) + +{ + undefined *puVar1; + undefined *puVar2; + uint uVar3; + char cVar4; + undefined *puVar5; + byte *pbVar6; + int *piVar7; + int iVar8; + uint uVar9; + int iVar10; + int *piVar11; + int iVar12; + undefined1 local_c [12]; + + uVar3 = param_3; + if ((~*(byte *)(param_3 + 4) & 1) != 0) { + FUN_005c2c80(); + } + puVar2 = PTR_DAT_00818558; + puVar1 = PTR_DAT_00818554; + if (((byte)*(undefined4 *)(uVar3 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x68); + puVar5 = (undefined *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_3,param_3,0); + if (puVar5 == puVar2) { + puVar5 = puVar5 + -4; + } + uVar9 = (int)puVar5 - (int)puVar1 >> 2; + } + else { + uVar9 = param_3 & 0xff; + } + FUN_0040ad10(1); + pbVar6 = (byte *)FUN_0040acf0(1); + if (pbVar6 != (byte *)0x0) { + if ((*(byte *)(uVar3 + 4) & 1) == 0) { + uVar9 = (uint)*pbVar6; + } + else { + *pbVar6 = (byte)uVar9; + } + } + if ((*(byte *)(uVar3 + 4) & 5) == 0) { + if ((uVar9 & 0xff) < DAT_007956cc) { + FUN_0042ab60(*(undefined4 *)(PTR_DAT_00818554 + (uVar9 & 0xff) * 4)); + } + else { + FUN_0040aa50(); + } + } + if (((byte)*(undefined4 *)(uVar3 + 4) & 5) == 1) { + param_3 = *(uint *)(param_2 + 0x6c); + } + FUN_00401a80(¶m_3,¶m_3,uVar3); + if (((byte)*(undefined4 *)(uVar3 + 4) & 5) == 1) { + piVar7 = (int *)FUN_0052dcf0(local_c); + iVar12 = *piVar7; + piVar11 = (int *)piVar7[1]; + iVar10 = piVar7[2]; +LAB_00430aa2: + iVar8 = iVar10; + if (iVar10 != 0) { + do { + FUN_004308d0(param_1,iVar8,uVar3); + iVar8 = *(int *)(iVar8 + 4); + } while (iVar8 != 0); + do { + piVar11 = piVar11 + 1; + iVar10 = iVar8; + if (piVar11 == (int *)(*(int *)(iVar12 + 0x60) + *(int *)(iVar12 + 0x68) * 4)) break; + iVar10 = *piVar11; + } while (iVar10 == 0); + goto LAB_00430aa2; + } + } + if ((*(byte *)(uVar3 + 4) & 5) == 0) { + uVar9 = FUN_0040a8f0(); + if (uVar9 < param_3) { +LAB_00430b44: + FUN_0040aa50(); + } + else { + uVar9 = 0; + iVar12 = 0; + if (param_3 != 0) { + while( true ) { + iVar8 = FUN_005df0f5(0xc); + iVar10 = 0; + if (iVar8 != 0) { + *(undefined4 *)(iVar8 + 4) = 0; + iVar10 = iVar8; + } + FUN_004308d0(param_1,iVar10,uVar3); + if ((*(uint *)(uVar3 + 4) >> 2 & 1) != 0) break; + cVar4 = FUN_00599310(iVar10,iVar12); + if (cVar4 == '\0') goto LAB_00430b44; + uVar9 = uVar9 + 1; + iVar12 = iVar10; + if (param_3 <= uVar9) { + return; + } + } + } + } + } + return; +} + + + +// --- FUN_00430b60 at 0x00430B60 (size: 94) --- + +void __thiscall FUN_00430b60(int param_1,int param_2) + +{ + int iVar1; + undefined4 *puVar2; + + iVar1 = param_2; + FUN_00415590(param_2); + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(iVar1 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x30) = *puVar2; + } + else { + *puVar2 = *(undefined4 *)(param_1 + 0x30); + } + } + if ((~*(byte *)(iVar1 + 4) & 1) != 0) { + FUN_005870f0(); + } + FUN_004309a0(¶m_2,param_1 + 0x40,iVar1); + return; +} + + + +// --- FUN_00430bc0 at 0x00430BC0 (size: 265) --- + +undefined1 FUN_00430bc0(int param_1,int param_2,int param_3,int param_4,int param_5) + +{ + LONG LVar1; + int iVar2; + int iVar3; + int iVar4; + int iVar5; + undefined1 local_1; + + local_1 = 0; + if (DAT_00837f58 != (int *)0x0) { + InterlockedIncrement((LONG *)(param_5 + -0x10)); + iVar5 = param_4; + InterlockedIncrement((LONG *)(param_4 + -0x10)); + iVar4 = param_3; + InterlockedIncrement((LONG *)(param_3 + -0x10)); + iVar3 = param_2; + InterlockedIncrement((LONG *)(param_2 + -0x10)); + iVar2 = param_1; + InterlockedIncrement((LONG *)(param_1 + -0x10)); + local_1 = (**(code **)(*DAT_00837f58 + 0xc))(iVar2,iVar3,iVar4,iVar5); + } + LVar1 = InterlockedDecrement((LONG *)(param_1 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(param_1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_1 + -0x14))(1); + } + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(param_2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_2 + -0x14))(1); + } + LVar1 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(param_3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_3 + -0x14))(1); + } + LVar1 = InterlockedDecrement((LONG *)(param_4 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(param_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_4 + -0x14))(1); + } + LVar1 = InterlockedDecrement((LONG *)(param_5 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(param_5 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_5 + -0x14))(1); + } + return local_1; +} + + + +// --- FUN_00430cd0 at 0x00430CD0 (size: 146) --- + +/* WARNING: Removing unreachable block (ram,0x00430d30) */ +/* WARNING: Removing unreachable block (ram,0x00430d0b) */ +/* WARNING: Removing unreachable block (ram,0x00430d50) */ +/* WARNING: Removing unreachable block (ram,0x00430ce5) */ +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __thiscall FUN_00430cd0(float *param_1,uint param_2) + +{ + param_1[3] = (float)(param_2 >> 0x18) * _DAT_00799208; + *param_1 = (float)(param_2 >> 0x10 & 0xff) * _DAT_00799208; + param_1[1] = (float)(param_2 >> 8 & 0xff) * _DAT_00799208; + param_1[2] = (float)(param_2 & 0xff) * _DAT_00799208; + return; +} + + + +// --- FUN_00430d70 at 0x00430D70 (size: 16) --- + +undefined1 FUN_00430d70(void) + +{ + thunk_FUN_00436cf0(&DAT_00837fec); + return 1; +} + + + +// --- FUN_00430d80 at 0x00430D80 (size: 89) --- + +undefined4 FUN_00430d80(void) + +{ + LONG LVar1; + int local_4; + + FUN_00401340("A flag to use IME"); + FUN_00411d90(&DAT_00837fec,&local_4,0,0,0,0); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + DAT_00837f61 = 1; + return 1; +} + + + +// --- FUN_00430e00 at 0x00430E00 (size: 77) --- + +bool __fastcall FUN_00430e00(int *param_1) + +{ + int iVar1; + + (**(code **)(*param_1 + 0x74))(DAT_00838197); + if ((int *)param_1[0x23] != (int *)0x0) { + (**(code **)(*(int *)param_1[0x23] + 0x14))(); + param_1[0x23] = 0; + } + iVar1 = FUN_00415730(1,8,0x27); + param_1[0x23] = iVar1; + return iVar1 != 0; +} + + + +// --- FUN_00430e50 at 0x00430E50 (size: 64) --- + +bool __thiscall FUN_00430e50(int param_1,undefined4 param_2) + +{ + int iVar1; + + if (*(int **)(param_1 + 0x8c) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x8c) + 0x14))(); + *(undefined4 *)(param_1 + 0x8c) = 0; + } + iVar1 = FUN_00415730(param_2,8,0x27); + *(int *)(param_1 + 0x8c) = iVar1; + return iVar1 != 0; +} + + + +// --- FUN_00430e90 at 0x00430E90 (size: 10) --- + +void __thiscall FUN_00430e90(int param_1,undefined1 param_2) + +{ + *(undefined1 *)(param_1 + 0x19) = param_2; + return; +} + + + +// --- FUN_00430ea0 at 0x00430EA0 (size: 17) --- + +uint __fastcall FUN_00430ea0(int param_1) + +{ + uint in_EAX; + uint uVar1; + + if (*(int **)(param_1 + 0x7c) != (int *)0x0) { + /* WARNING: Could not recover jumptable at 0x00430ea9. Too many branches */ + /* WARNING: Treating indirect jump as call */ + uVar1 = (**(code **)(**(int **)(param_1 + 0x7c) + 0x14))(); + return uVar1; + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00430ec0 at 0x00430EC0 (size: 20) --- + +void __thiscall FUN_00430ec0(int *param_1,int param_2) + +{ + *(undefined1 *)(param_2 + 0x20) = 1; + /* WARNING: Could not recover jumptable at 0x00430ece. Too many branches */ + /* WARNING: Treating indirect jump as call */ + (**(code **)(*param_1 + 0xb8))(); + return; +} + + + +// --- FUN_00430ee0 at 0x00430EE0 (size: 51) --- + +void __fastcall FUN_00430ee0(undefined4 *param_1) + +{ + *param_1 = 0; + param_1[1] = 0; + param_1[2] = 0xffffffff; + param_1[3] = 0; + param_1[4] = 0; + param_1[5] = 0xc0000000; + param_1[6] = 0; + param_1[7] = 0; + param_1[10] = 0; + param_1[0xb] = 0; + param_1[0xc] = 0; + param_1[0xd] = 0; + param_1[0x10] = 0; + return; +} + + + +// --- FUN_00430f20 at 0x00430F20 (size: 106) --- + +void __fastcall FUN_00430f20(int *param_1) + +{ + undefined4 *puVar1; + uint uVar2; + undefined4 local_4; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + *param_1 = 0; + param_1[1] = 0; + return; + } + if (*param_1 != 0) { + uVar2 = param_1[1] & 0x7fffffff; + while (uVar2 = uVar2 - 1, -1 < (int)uVar2) { + puVar1 = (undefined4 *)(*param_1 + uVar2 * 8); + *puVar1 = 0xffffffff; + puVar1[1] = local_4; + } + } + return; +} + + + +// --- FUN_00430f90 at 0x00430F90 (size: 91) --- + +float10 __fastcall FUN_00430f90(int param_1) + +{ + uint uVar1; + float *pfVar2; + uint uVar3; + uint uVar4; + float local_4; + + uVar1 = *(uint *)(param_1 + 0x24); + uVar4 = 0xffffffff; + local_4 = -2.0; + if ((uVar1 != 0) && (uVar3 = 0, uVar1 != 0)) { + pfVar2 = (float *)(*(int *)(param_1 + 0x1c) + 4); + do { + if (local_4 < ABS(*pfVar2)) { + uVar4 = uVar3; + local_4 = ABS(*pfVar2); + } + uVar3 = uVar3 + 1; + pfVar2 = pfVar2 + 2; + } while (uVar3 < uVar1); + if (-1 < (int)uVar4) { + return (float10)*(float *)(*(int *)(param_1 + 0x1c) + 4 + uVar4 * 8); + } + } + return (float10)DAT_00796344; +} + + + +// --- FUN_00430ff0 at 0x00430FF0 (size: 89) --- + +undefined4 * __thiscall FUN_00430ff0(undefined4 *param_1,undefined4 *param_2) + +{ + float10 fVar1; + + *param_1 = *param_2; + param_1[1] = 0; + param_1[2] = 0xffffffff; + param_1[3] = 0; + param_1[4] = 0; + fVar1 = (float10)FUN_00430f90(); + param_1[5] = (float)fVar1; + param_1[6] = 0; + param_1[7] = param_2[5]; + param_1[10] = param_2[2]; + param_1[0xb] = param_2[3]; + param_1[0xc] = 1; + param_1[0xd] = param_2[4]; + param_1[0x10] = param_2[6]; + return param_1; +} + + + +// --- FUN_00431050 at 0x00431050 (size: 64) --- + +undefined4 * __thiscall FUN_00431050(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00799330; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00431090 at 0x00431090 (size: 126) --- + +void __thiscall +FUN_00431090(int param_1,int *param_2,undefined4 param_3,undefined4 param_4,undefined4 param_5, + undefined4 param_6,undefined4 param_7) + +{ + int *piVar1; + char cVar2; + int iVar3; + + piVar1 = param_2; + if (param_1 != 0) { + FUN_004369a0(param_1,9,param_2,param_3,param_4,param_5,param_6,param_7); + } + if (DAT_008380c8 == 0) { + iVar3 = FUN_005df0f5(0x8100); + if (iVar3 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar2 = FUN_00433710(piVar1,¶m_2); + if ((cVar2 != '\0') && (iVar3 = (**(code **)(*param_2 + 0x44))(), iVar3 != 0)) { + *(undefined1 *)(iVar3 + 0x28) = 1; + } + return; +} + + + +// --- FUN_00431110 at 0x00431110 (size: 182) --- + +undefined4 __thiscall FUN_00431110(int *param_1,uint param_2) + +{ + int iVar1; + int iVar2; + int iVar3; + int iVar4; + + if (param_2 < (uint)param_1[2]) { + return 0; + } + if ((param_1[1] & 0x7fffffffU) < param_2) { + if (param_2 == 0) { + FUN_00430f20(); + return 1; + } + iVar4 = thunk_FUN_005df0f5(param_2 * 8); + if (iVar4 == 0) { + return 0; + } + FUN_00401000(iVar4,8,param_2,FUN_00677be0); + if (*param_1 != 0) { + iVar2 = param_1[2]; + while (iVar2 = iVar2 + -1, -1 < iVar2) { + iVar3 = *param_1; + iVar1 = iVar2 * 8; + *(undefined4 *)(iVar1 + iVar4) = *(undefined4 *)(iVar3 + iVar1); + *(undefined4 *)(iVar1 + 4 + iVar4) = *(undefined4 *)(iVar3 + iVar1 + 4); + } + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + } + } + *param_1 = iVar4; + param_1[1] = param_2 | 0x80000000; + } + return 1; +} + + + +// --- FUN_004311d0 at 0x004311D0 (size: 117) --- + +undefined4 __thiscall FUN_004311d0(int param_1,int param_2,undefined4 *param_3) + +{ + undefined4 *puVar1; + + puVar1 = (undefined4 *)FUN_005df0f5(0xc); + if (puVar1 == (undefined4 *)0x0) { + return 0; + } + *puVar1 = *param_3; + puVar1[1] = 0; + puVar1[2] = 0; + if (*(int *)(param_1 + 4) == 0) { + *(undefined4 **)(param_1 + 4) = puVar1; + *(undefined4 **)(param_1 + 8) = puVar1; + *(int *)(param_1 + 0xc) = *(int *)(param_1 + 0xc) + 1; + return 1; + } + puVar1[1] = param_2; + puVar1[2] = *(undefined4 *)(param_2 + 8); + if (*(int *)(param_2 + 8) != 0) { + *(undefined4 **)(*(int *)(param_2 + 8) + 4) = puVar1; + *(undefined4 **)(param_2 + 8) = puVar1; + *(int *)(param_1 + 0xc) = *(int *)(param_1 + 0xc) + 1; + return 1; + } + *(undefined4 **)(param_1 + 4) = puVar1; + *(undefined4 **)(param_2 + 8) = puVar1; + *(int *)(param_1 + 0xc) = *(int *)(param_1 + 0xc) + 1; + return 1; +} + + + +// --- FUN_00431250 at 0x00431250 (size: 98) --- + +undefined4 __thiscall FUN_00431250(int param_1,undefined4 *param_2) + +{ + int iVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)FUN_005df0f5(0x14); + if (puVar2 == (undefined4 *)0x0) { + return 0; + } + *puVar2 = *param_2; + puVar2[1] = param_2[1]; + puVar2[2] = param_2[2]; + puVar2[3] = 0; + puVar2[4] = 0; + if (*(int *)(param_1 + 4) == 0) { + *(undefined4 **)(param_1 + 4) = puVar2; + *(undefined4 **)(param_1 + 8) = puVar2; + *(int *)(param_1 + 0xc) = *(int *)(param_1 + 0xc) + 1; + return 1; + } + iVar1 = *(int *)(param_1 + 8); + *(undefined4 **)(iVar1 + 0xc) = puVar2; + puVar2[4] = iVar1; + *(undefined4 **)(param_1 + 8) = puVar2; + *(int *)(param_1 + 0xc) = *(int *)(param_1 + 0xc) + 1; + return 1; +} + + + +// --- FUN_004312c0 at 0x004312C0 (size: 133) --- + +undefined4 __thiscall FUN_004312c0(int param_1,int param_2,undefined4 *param_3) + +{ + undefined4 *puVar1; + + puVar1 = (undefined4 *)FUN_005df0f5(0x14); + if (puVar1 == (undefined4 *)0x0) { + return 0; + } + *puVar1 = *param_3; + puVar1[1] = param_3[1]; + puVar1[2] = param_3[2]; + puVar1[3] = 0; + puVar1[4] = 0; + if (*(int *)(param_1 + 4) == 0) { + *(undefined4 **)(param_1 + 4) = puVar1; + *(undefined4 **)(param_1 + 8) = puVar1; + *(int *)(param_1 + 0xc) = *(int *)(param_1 + 0xc) + 1; + return 1; + } + puVar1[3] = param_2; + puVar1[4] = *(undefined4 *)(param_2 + 0x10); + if (*(int *)(param_2 + 0x10) != 0) { + *(undefined4 **)(*(int *)(param_2 + 0x10) + 0xc) = puVar1; + *(undefined4 **)(param_2 + 0x10) = puVar1; + *(int *)(param_1 + 0xc) = *(int *)(param_1 + 0xc) + 1; + return 1; + } + *(undefined4 **)(param_1 + 4) = puVar1; + *(undefined4 **)(param_2 + 0x10) = puVar1; + *(int *)(param_1 + 0xc) = *(int *)(param_1 + 0xc) + 1; + return 1; +} + + + +// --- FUN_00431350 at 0x00431350 (size: 52) --- + +void __thiscall FUN_00431350(int param_1,undefined4 param_2) + +{ + undefined4 *puVar1; + int *piVar2; + + if ((*(int *)(param_1 + 0x30) != 0) && (*(char *)(param_1 + 0x1a) == '\x01')) { + puVar1 = *(undefined4 **)(param_1 + 0x30); + while (puVar1 != (undefined4 *)0x0) { + piVar2 = (int *)*puVar1; + puVar1 = (undefined4 *)puVar1[1]; + (**(code **)(*piVar2 + 0x10))(param_2); + } + } + return; +} + + + +// --- FUN_00431390 at 0x00431390 (size: 40) --- + +void __thiscall FUN_00431390(int param_1,undefined4 param_2,undefined4 param_3) + +{ + undefined4 *puVar1; + int *piVar2; + + puVar1 = *(undefined4 **)(param_1 + 0x50); + while (puVar1 != (undefined4 *)0x0) { + piVar2 = (int *)*puVar1; + puVar1 = (undefined4 *)puVar1[1]; + (**(code **)(*piVar2 + 4))(param_2,param_3); + } + return; +} + + + +// --- FUN_004313c0 at 0x004313C0 (size: 40) --- + +void __thiscall FUN_004313c0(int param_1,undefined4 param_2,undefined4 param_3) + +{ + undefined4 *puVar1; + int *piVar2; + + puVar1 = *(undefined4 **)(param_1 + 0x40); + while (puVar1 != (undefined4 *)0x0) { + piVar2 = (int *)*puVar1; + puVar1 = (undefined4 *)puVar1[1]; + (**(code **)(*piVar2 + 8))(param_2,param_3); + } + return; +} + + + +// --- FUN_004313f0 at 0x004313F0 (size: 74) --- + +void __thiscall FUN_004313f0(int param_1,undefined4 param_2) + +{ + undefined4 *puVar1; + int *piVar2; + byte bVar3; + + *(char *)(param_1 + 0x1b) = (char)param_2; + if (*(int *)(param_1 + 0x60) != 0) { + bVar3 = (*(char *)(param_1 + 0x1a) != '\0') + 1; + if (*(char *)(param_1 + 0x18) == '\0') { + bVar3 = bVar3 | 0x10; + } + else { + bVar3 = bVar3 | 4; + } + puVar1 = *(undefined4 **)(param_1 + 0x60); + while (puVar1 != (undefined4 *)0x0) { + piVar2 = (int *)*puVar1; + puVar1 = (undefined4 *)puVar1[1]; + (**(code **)(*piVar2 + 0xc))(param_2,bVar3); + } + } + return; +} + + + +// --- FUN_00431440 at 0x00431440 (size: 58) --- + +void __thiscall FUN_00431440(int param_1,int param_2) + +{ + undefined4 *puVar1; + undefined4 *puVar2; + char cVar3; + + if (((*(int **)(param_2 + 0x40) == (int *)0x0) || + (cVar3 = (**(code **)(**(int **)(param_2 + 0x40) + 4))(param_2), cVar3 == '\0')) && + (*(char *)(param_1 + 0x1b) != '\0')) { + puVar1 = *(undefined4 **)(param_1 + 0x20); + while (puVar1 != (undefined4 *)0x0) { + puVar2 = (undefined4 *)*puVar1; + puVar1 = (undefined4 *)puVar1[1]; + (**(code **)*puVar2)(param_2); + } + } + return; +} + + + +// --- FUN_00431480 at 0x00431480 (size: 99) --- + +uint __thiscall FUN_00431480(int param_1,void *param_2) + +{ + int iVar1; + undefined4 uVar2; + + uVar2 = 0; + if ((param_2 == (void *)0x0) || (*(void **)(param_1 + 4) == (void *)0x0)) { + return (uint)param_2 & 0xffffff00; + } + if (param_2 == *(void **)(param_1 + 4)) { + iVar1 = *(int *)((int)param_2 + 0xc); + *(int *)(param_1 + 4) = iVar1; + if (iVar1 == 0) { + *(undefined4 *)(param_1 + 8) = 0; + goto LAB_004314cd; + } + } + else { + *(undefined4 *)(*(int *)((int)param_2 + 0x10) + 0xc) = *(undefined4 *)((int)param_2 + 0xc); + iVar1 = *(int *)((int)param_2 + 0xc); + if (iVar1 == 0) { + *(undefined4 *)(param_1 + 8) = *(undefined4 *)((int)param_2 + 0x10); + goto LAB_004314cd; + } + uVar2 = *(undefined4 *)((int)param_2 + 0x10); + } + *(undefined4 *)(iVar1 + 0x10) = uVar2; +LAB_004314cd: + operator_delete(param_2); + iVar1 = *(int *)(param_1 + 0xc) + -1; + *(int *)(param_1 + 0xc) = iVar1; + return CONCAT31((int3)((uint)iVar1 >> 8),1); +} + + + +// --- FUN_004314f0 at 0x004314F0 (size: 99) --- + +uint __thiscall FUN_004314f0(int param_1,void *param_2) + +{ + int iVar1; + undefined4 uVar2; + + uVar2 = 0; + if ((param_2 == (void *)0x0) || (*(void **)(param_1 + 4) == (void *)0x0)) { + return (uint)param_2 & 0xffffff00; + } + if (param_2 == *(void **)(param_1 + 4)) { + iVar1 = *(int *)((int)param_2 + 4); + *(int *)(param_1 + 4) = iVar1; + if (iVar1 == 0) { + *(undefined4 *)(param_1 + 8) = 0; + goto LAB_0043153d; + } + } + else { + *(undefined4 *)(*(int *)((int)param_2 + 8) + 4) = *(undefined4 *)((int)param_2 + 4); + iVar1 = *(int *)((int)param_2 + 4); + if (iVar1 == 0) { + *(undefined4 *)(param_1 + 8) = *(undefined4 *)((int)param_2 + 8); + goto LAB_0043153d; + } + uVar2 = *(undefined4 *)((int)param_2 + 8); + } + *(undefined4 *)(iVar1 + 8) = uVar2; +LAB_0043153d: + operator_delete(param_2); + iVar1 = *(int *)(param_1 + 0xc) + -1; + *(int *)(param_1 + 0xc) = iVar1; + return CONCAT31((int3)((uint)iVar1 >> 8),1); +} + + + +// --- FUN_004315c0 at 0x004315C0 (size: 237) --- + +undefined4 __thiscall FUN_004315c0(int param_1,int param_2) + +{ + undefined4 *puVar1; + int iVar2; + bool bVar3; + uint uVar4; + uint uVar5; + int *piVar6; + undefined4 uVar7; + float local_10; + uint local_c; + undefined4 local_4; + + uVar5 = 0xffffffff; + bVar3 = false; + uVar4 = 0; + local_c = 0xffffffff; + local_10 = -2.0; + if (*(int *)(param_1 + 0x24) != 0) { + piVar6 = *(int **)(param_1 + 0x1c); + bVar3 = false; + do { + if (*(int *)(param_2 + 8) == *piVar6) { + bVar3 = true; + uVar5 = uVar4; + } + else if (local_10 < ABS((float)piVar6[1])) { + local_10 = ABS((float)piVar6[1]); + local_c = uVar4; + } + uVar4 = uVar4 + 1; + piVar6 = piVar6 + 2; + } while (uVar4 < *(uint *)(param_1 + 0x24)); + } + uVar7 = 2; + if (bVar3) { + if ((int)local_c < 0) { + uVar7 = 3; + *(undefined4 *)(param_1 + 0x18) = 0; + } + else if (local_10 < ABS(*(float *)(*(int *)(param_1 + 0x1c) + 4 + uVar5 * 8))) { + *(float *)(param_2 + 0x14) = local_10; + uVar7 = 1; + } + if (uVar5 < *(uint *)(param_1 + 0x24)) { + uVar4 = *(uint *)(param_1 + 0x24) - 1; + *(uint *)(param_1 + 0x24) = uVar4; + if (uVar5 != uVar4) { + iVar2 = *(int *)(param_1 + 0x1c); + *(undefined4 *)(iVar2 + uVar5 * 8) = *(undefined4 *)(iVar2 + uVar4 * 8); + *(undefined4 *)(iVar2 + 4 + uVar5 * 8) = *(undefined4 *)(iVar2 + 4 + uVar4 * 8); + puVar1 = (undefined4 *)(*(int *)(param_1 + 0x1c) + *(int *)(param_1 + 0x24) * 8); + *puVar1 = 0xffffffff; + puVar1[1] = local_4; + } + } + } + return uVar7; +} + + + +// --- FUN_004316b0 at 0x004316B0 (size: 63) --- + +void __thiscall FUN_004316b0(int param_1,int param_2) + +{ + int iVar1; + + iVar1 = *(int *)(param_1 + 4); + if (iVar1 != 0) { + while (*(int *)(param_2 + 8) < *(int *)(iVar1 + 8)) { + iVar1 = *(int *)(iVar1 + 0xc); + if (iVar1 == 0) { + FUN_00431250(param_2); + return; + } + } + if (iVar1 != 0) { + FUN_004312c0(iVar1,param_2); + return; + } + } + FUN_00431250(param_2); + return; +} + + + +// --- FUN_004316f0 at 0x004316F0 (size: 58) --- + +undefined4 __thiscall FUN_004316f0(int param_1,int *param_2) + +{ + int *piVar1; + + piVar1 = *(int **)(param_1 + 4); + if (piVar1 != (int *)0x0) { + do { + if (((*piVar1 == *param_2) && (piVar1[1] == param_2[1])) && (piVar1[2] == param_2[2])) + goto LAB_0043171d; + piVar1 = (int *)piVar1[3]; + } while (piVar1 != (int *)0x0); + } + piVar1 = (int *)0x0; +LAB_0043171d: + return CONCAT31((int3)((uint)piVar1 >> 8),piVar1 != (int *)0x0); +} + + + +// --- FUN_00431730 at 0x00431730 (size: 52) --- + +void __fastcall FUN_00431730(int param_1) + +{ + void *pvVar1; + int iVar2; + + while (pvVar1 = *(void **)(param_1 + 4), pvVar1 != (void *)0x0) { + iVar2 = *(int *)((int)pvVar1 + 0xc); + *(int *)(param_1 + 4) = iVar2; + if (iVar2 == 0) { + *(undefined4 *)(param_1 + 8) = 0; + } + else { + *(undefined4 *)(iVar2 + 0x10) = 0; + } + if (pvVar1 != (void *)0x0) { + operator_delete(pvVar1); + } + *(int *)(param_1 + 0xc) = *(int *)(param_1 + 0xc) + -1; + } + return; +} + + + +// --- FUN_00431870 at 0x00431870 (size: 62) --- + +undefined4 __thiscall FUN_00431870(int param_1,int param_2,int param_3) + +{ + int *piVar1; + undefined4 uVar2; + int *piVar3; + + uVar2 = 0; + piVar3 = *(int **)(param_1 + 0x70); + while (piVar3 != (int *)0x0) { + if ((*piVar3 == param_2) && (piVar3[1] == param_3)) { + piVar1 = (int *)piVar3[3]; + FUN_00431480(piVar3); + uVar2 = 1; + piVar3 = piVar1; + } + else { + piVar3 = (int *)piVar3[3]; + } + } + return uVar2; +} + + + +// --- FUN_004319b0 at 0x004319B0 (size: 305) --- + +void FUN_004319b0(void) + +{ + LONG LVar1; + undefined4 *puVar2; + int local_4; + + FUN_00401340("Mouse sensitivity when user is in mouse look mode."); + FUN_00431090(&DAT_0083804c,&local_4,0,0,0,0); + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("Mouse look smoothing amount."); + FUN_00431090(&DAT_00838050,&local_4,0,0,0,0); + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("Invert mouse look vertical rotation?"); + FUN_00411d90(&DAT_00838054,&local_4,0,0,0,0); + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("Turn your character with the camera turn button?"); + FUN_00411d90(&DAT_00838058,&local_4,0,0,0,0); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + return; +} + + + +// --- FUN_00431af0 at 0x00431AF0 (size: 52) --- + +undefined4 __thiscall FUN_00431af0(int param_1,uint param_2) + +{ + uint *puVar1; + bool bVar2; + + puVar1 = *(uint **)(*(int *)(param_1 + 0xf0) + (param_2 % *(uint *)(param_1 + 0xf8)) * 4); + bVar2 = puVar1 == (uint *)0x0; + if (!bVar2) { + do { + if (*puVar1 == param_2) break; + puVar1 = (uint *)puVar1[1]; + } while (puVar1 != (uint *)0x0); + bVar2 = puVar1 == (uint *)0x0; + } + return CONCAT31((int3)((uint)puVar1 >> 8),!bVar2); +} + + + +// --- FUN_00431b30 at 0x00431B30 (size: 74) --- + +undefined4 __thiscall FUN_00431b30(int *param_1,undefined4 *param_2) + +{ + undefined4 *puVar1; + undefined4 uVar2; + + if ((param_1[1] & 0x7fffffffU) <= (uint)param_1[2]) { + uVar2 = FUN_00453850((param_1[1] & 0x7fffffffU) + 1); + uVar2 = FUN_00431110(uVar2); + if ((char)uVar2 == '\0') { + return uVar2; + } + } + puVar1 = (undefined4 *)(*param_1 + param_1[2] * 8); + *puVar1 = *param_2; + puVar1[1] = param_2[1]; + param_1[2] = param_1[2] + 1; + return CONCAT31((int3)((uint)puVar1 >> 8),1); +} + + + +// --- FUN_00431b80 at 0x00431B80 (size: 36) --- + +undefined4 * __thiscall FUN_00431b80(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00799318; + FUN_0049f850(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00431bb0 at 0x00431BB0 (size: 36) --- + +undefined4 * __thiscall FUN_00431bb0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079931c; + FUN_00431730(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00431be0 at 0x00431BE0 (size: 228) --- + +void __fastcall FUN_00431be0(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_007993e8; + thunk_FUN_00436cf0(&DAT_0083804c); + thunk_FUN_00436cf0(&DAT_00838050); + thunk_FUN_00436cf0(&DAT_00838054); + thunk_FUN_00436cf0(&DAT_00838058); + if ((int *)param_1[0x23] != (int *)0x0) { + (**(code **)(*(int *)param_1[0x23] + 0x14))(); + param_1[0x23] = 0; + } + param_1[0x24] = &PTR_FUN_00799330; + if ((undefined4 *)param_1[0x3c] != param_1 + 0x25) { + operator_delete__((undefined4 *)param_1[0x3c]); + } + param_1[0x3c] = 0; + param_1[0x3d] = 0; + param_1[0x3e] = 0; + param_1[0x3f] = 0; + param_1[0x1b] = &PTR_FUN_0079931c; + FUN_00431730(); + param_1[0x17] = &PTR_FUN_00799318; + FUN_0049f850(); + param_1[0x13] = &PTR_FUN_00799318; + FUN_0049f850(); + param_1[0xf] = &PTR_FUN_00799318; + FUN_0049f850(); + param_1[0xb] = &PTR_FUN_00799318; + FUN_0049f850(); + param_1[7] = &PTR_FUN_00799318; + FUN_0049f850(); + *param_1 = &PTR_LAB_00799268; + return; +} + + + +// --- FUN_00431d60 at 0x00431D60 (size: 576) --- + +/* WARNING: Removing unreachable block (ram,0x00431f8b) */ +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __fastcall FUN_00431d60(int *param_1) + +{ + uint uVar1; + undefined4 uVar2; + undefined4 uVar3; + char cVar4; + undefined4 uVar5; + int iVar6; + uint uVar7; + uint *puVar8; + float10 fVar9; + int local_b4; + int local_a4; + undefined4 *local_a0; + undefined4 *local_9c; + uint local_98; + undefined4 local_94; + undefined4 local_90; + undefined4 local_8c; + undefined4 local_88; + float local_84; + undefined4 local_80; + undefined4 local_7c; + undefined1 local_78; + uint local_70; + uint local_6c; + undefined4 local_68; + uint local_64; + uint local_58; + undefined1 local_50 [32]; + undefined1 local_30; + int local_20; + + uVar3 = DAT_008379ac; + uVar2 = DAT_008379a8; + local_b4 = 0; + FUN_004180a0(param_1[0x3f]); + FUN_0052dcf0(&local_a4); + while (local_9c != (undefined4 *)0x0) { + do { + if ((3 < (uint)local_9c[5]) && ((uint)local_9c[5] < 6)) { + uVar5 = FUN_00453850(1); + cVar4 = FUN_004180a0(uVar5); + if (cVar4 != '\0') { + *(undefined4 *)(local_b4 * 4) = *local_9c; + local_b4 = local_b4 + 1; + } + } + local_9c = (undefined4 *)local_9c[1]; + } while (local_9c != (undefined4 *)0x0); + do { + local_a0 = local_a0 + 1; + if (local_a0 == (undefined4 *)(*(int *)(local_a4 + 0x60) + *(int *)(local_a4 + 0x68) * 4)) + goto joined_r0x00431e39; + local_9c = (undefined4 *)*local_a0; + } while (local_9c == (undefined4 *)0x0); + } +joined_r0x00431e39: + do { + do { + if (local_b4 == 0) { + return; + } + uVar1 = *(uint *)(local_b4 * 4 + -4); + local_b4 = local_b4 + -1; + puVar8 = *(uint **)(param_1[0x3c] + (uVar1 % (uint)param_1[0x3e]) * 4); + } while (puVar8 == (uint *)0x0); + do { + if (*puVar8 == uVar1) { + if (puVar8 != (uint *)0x0) { + if (puVar8[5] == 4) { + if (_DAT_00818a78 + *(double *)(puVar8 + 2) <= (double)CONCAT44(uVar3,uVar2)) { + iVar6 = FUN_005df4c4(); + uVar1 = puVar8[4]; + uVar7 = iVar6 + 1; + if (uVar1 < uVar7) { + puVar8[4] = uVar7; + FUN_00430ff0(puVar8); + local_30 = 1; + local_20 = uVar7 - uVar1; + (**(code **)(*param_1 + 0xb8))(local_50); + } + } + } + else if (puVar8[5] == 5) { + uVar1 = puVar8[4]; + local_98 = *puVar8; + puVar8[4] = uVar1 + 1; + local_94 = 0; + local_90 = 0xffffffff; + local_8c = 0; + local_88 = 0; + fVar9 = (float10)FUN_00430f90(); + local_84 = (float)fVar9; + local_6c = puVar8[3]; + local_70 = puVar8[2]; + local_58 = puVar8[6]; + local_80 = 0; + local_7c = 5; + local_68 = 1; + local_78 = 1; + local_64 = uVar1 + 1; + (**(code **)(*param_1 + 0xb8))(&local_98); + } + } + break; + } + puVar8 = (uint *)puVar8[1]; + } while (puVar8 != (uint *)0x0); + } while( true ); +} + + + +// --- FUN_00431fa0 at 0x00431FA0 (size: 290) --- + +undefined4 __thiscall FUN_00431fa0(int param_1,int param_2) + +{ + int *piVar1; + undefined4 *puVar2; + float fVar3; + bool bVar4; + char cVar5; + undefined4 uVar6; + undefined4 uVar7; + uint uVar8; + float local_10; + undefined4 local_c; + undefined4 local_4; + + uVar7 = DAT_008379a8; + if (*(int *)(param_1 + 0x24) == 0) { + *(undefined4 *)(param_2 + 0x2c) = DAT_008379ac; + *(undefined4 *)(param_2 + 0x28) = uVar7; + *(undefined4 *)(param_1 + 8) = uVar7; + *(undefined4 *)(param_1 + 0xc) = *(undefined4 *)(param_2 + 0x2c); + *(undefined4 *)(param_1 + 0x14) = *(undefined4 *)(param_2 + 0x1c); + local_c = *(undefined4 *)(param_2 + 0x14); + local_10 = *(float *)(param_2 + 8); + FUN_00431b30(&local_10); + *(undefined4 *)(param_1 + 0x18) = *(undefined4 *)(param_2 + 0x40); + return 0; + } + bVar4 = false; + uVar8 = 0; + local_10 = -2.0; + if (*(int *)(param_1 + 0x24) != 0) { + do { + piVar1 = (int *)(*(int *)(param_1 + 0x1c) + uVar8 * 8); + fVar3 = ABS(*(float *)(*(int *)(param_1 + 0x1c) + 4 + uVar8 * 8)); + if (local_10 < fVar3) { + local_10 = fVar3; + } + if (*(int *)(param_2 + 8) == *piVar1) { + if ((float)piVar1[1] != *(float *)(param_2 + 0x14)) { + piVar1[1] = *(int *)(param_2 + 0x14); + } + bVar4 = true; + } + uVar8 = uVar8 + 1; + } while (uVar8 < *(uint *)(param_1 + 0x24)); + if (bVar4) goto LAB_0043209d; + } + local_4 = *(undefined4 *)(param_2 + 0x14); + uVar7 = *(undefined4 *)(param_2 + 8); + uVar8 = *(uint *)(param_1 + 0x20) & 0x7fffffff; + if (uVar8 <= *(uint *)(param_1 + 0x24)) { + uVar6 = FUN_00453850(uVar8 + 1); + cVar5 = FUN_00431110(uVar6); + if (cVar5 == '\0') goto LAB_0043209d; + } + puVar2 = (undefined4 *)(*(int *)(param_1 + 0x1c) + *(int *)(param_1 + 0x24) * 8); + *puVar2 = uVar7; + puVar2[1] = local_4; + *(int *)(param_1 + 0x24) = *(int *)(param_1 + 0x24) + 1; +LAB_0043209d: + uVar7 = 1; + if (ABS(*(float *)(param_2 + 0x14)) <= local_10) { + uVar7 = 2; + } + return uVar7; +} + + + +// --- FUN_004320d0 at 0x004320D0 (size: 73) --- + +void __fastcall FUN_004320d0(int param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + undefined4 local_4; + + puVar1 = PTR_DAT_00818558; + local_4 = *(undefined4 *)(param_1 + 0x68); + puVar2 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,local_4,0); + if ((puVar2 != (undefined4 *)puVar1) || (puVar2 = puVar2 + -1, puVar2 != (undefined4 *)puVar1)) { + puVar2 = puVar2 + 1; + } + FUN_004322f0(*puVar2); + return; +} + + + +// --- FUN_00432120 at 0x00432120 (size: 30) --- + +void * __thiscall FUN_00432120(void *param_1,byte param_2) + +{ + FUN_00431be0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00432260 at 0x00432260 (size: 143) --- + +undefined4 * __thiscall FUN_00432260(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00799330; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_004322f0 at 0x004322F0 (size: 310) --- + +undefined4 __thiscall FUN_004322f0(int param_1,int param_2) + +{ + int iVar1; + int iVar2; + uint *puVar3; + undefined4 *puVar4; + int *piVar5; + uint *puVar6; + uint *puVar7; + undefined4 *puVar8; + uint *puVar9; + uint uVar10; + uint *puVar11; + + iVar2 = param_2; + if (param_2 == *(int *)(param_1 + 0x68)) { + return 0; + } + iVar1 = *(int *)(param_1 + 0x6c); + puVar3 = (uint *)0x0; + do { + if (iVar1 == 0) { + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_00693b20(iVar2); + puVar4 = (undefined4 *)PTR_DAT_00818558; + while (puVar3 != (uint *)0x0) { + param_2 = *(int *)(param_1 + 0x68); + puVar11 = (uint *)puVar3[1]; + PTR_DAT_00818558 = (undefined *)puVar4; + if (param_2 * 2 < *(int *)(param_1 + 0x6c) + 1) { + puVar8 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,puVar4,¶m_2,param_2,0); + if ((puVar8 != puVar4) || (puVar8 = puVar8 + -1, puVar8 != puVar4)) { + puVar8 = puVar8 + 1; + } + FUN_004322f0(*puVar8); + } + uVar10 = *puVar3 % *(uint *)(param_1 + 0x68); + iVar2 = *(int *)(param_1 + 0x60); + puVar3[1] = *(uint *)(iVar2 + uVar10 * 4); + *(uint **)(iVar2 + uVar10 * 4) = puVar3; + uVar10 = iVar2 + uVar10 * 4; + if (uVar10 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar10; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + puVar4 = (undefined4 *)PTR_DAT_00818558; + puVar3 = puVar11; + } + PTR_DAT_00818558 = (undefined *)puVar4; + return 1; + } + piVar5 = *(int **)(param_1 + 100); + while (piVar5 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + puVar11 = *(uint **)(param_1 + 100); + puVar9 = (uint *)*puVar11; + goto LAB_0043233f; + } + piVar5 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar5; + } + puVar11 = (uint *)0x0; + puVar9 = (uint *)0x0; +LAB_0043233f: + puVar7 = (uint *)*puVar11; + if (puVar7 == puVar9) { +LAB_00432352: + *puVar11 = puVar7[1]; + } + else { + do { + puVar6 = puVar7; + puVar7 = (uint *)puVar6[1]; + } while (puVar7 != puVar9); + if (puVar6 == (uint *)0x0) goto LAB_00432352; + puVar6[1] = puVar7[1]; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + puVar9[1] = (uint)puVar3; + iVar1 = *(int *)(param_1 + 0x6c); + puVar3 = puVar9; + } while( true ); +} + + + +// --- FUN_00432430 at 0x00432430 (size: 360) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 * __fastcall FUN_00432430(undefined4 *param_1) + +{ + double dVar1; + BOOL BVar2; + uint local_8 [2]; + + *param_1 = &PTR_FUN_007993e8; + param_1[4] = 0; + param_1[5] = 0; + *(undefined1 *)(param_1 + 6) = 0; + *(undefined1 *)((int)param_1 + 0x19) = 0; + *(undefined1 *)((int)param_1 + 0x1a) = 0; + *(undefined1 *)((int)param_1 + 0x1b) = 0; + param_1[8] = 0; + param_1[9] = 0; + param_1[10] = 0; + param_1[7] = &PTR_FUN_00799318; + param_1[0xb] = &PTR_FUN_00799318; + param_1[0xc] = 0; + param_1[0xd] = 0; + param_1[0xe] = 0; + param_1[0xf] = &PTR_FUN_00799318; + param_1[0x10] = 0; + param_1[0x11] = 0; + param_1[0x12] = 0; + param_1[0x13] = &PTR_FUN_00799318; + param_1[0x14] = 0; + param_1[0x15] = 0; + param_1[0x16] = 0; + param_1[0x17] = &PTR_FUN_00799318; + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = &PTR_FUN_0079931c; + param_1[0x1c] = 0; + param_1[0x1d] = 0; + param_1[0x1e] = 0; + param_1[0x1f] = 0; + param_1[0x20] = 0x3e800000; + param_1[0x21] = 0; + *(undefined1 *)(param_1 + 0x22) = 0; + *(undefined1 *)((int)param_1 + 0x89) = 0; + param_1[0x23] = 0; + FUN_00432260(10); + FUN_004319b0(); + BVar2 = SystemParametersInfoA(0x16,0,local_8,0); + if (BVar2 != 0) { + dVar1 = (double)(int)local_8[0]; + if ((int)local_8[0] < 0) { + dVar1 = dVar1 + _DAT_00795518; + } + _DAT_00818a78 = (dVar1 + _DAT_007938c0) * _DAT_007994a8; + } + BVar2 = SystemParametersInfoA(10,0,local_8,0); + if (BVar2 != 0) { + if (0x1f < local_8[0]) { + _DAT_00818a80 = 0.03333333333333333; + return param_1; + } + if (local_8[0] != 0) { + dVar1 = (double)(int)local_8[0]; + if ((int)local_8[0] < 0) { + dVar1 = dVar1 + _DAT_00795518; + } + _DAT_00818a80 = _DAT_00799320 - dVar1 * _DAT_00799328; + return param_1; + } + _DAT_00818a80 = 0.4; + } + return param_1; +} + + + +// --- FUN_004325a0 at 0x004325A0 (size: 120) --- + +uint __thiscall FUN_004325a0(int param_1,uint *param_2) + +{ + uint *puVar1; + int iVar2; + uint uVar3; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + do { + if (puVar1 == (uint *)0x0) { +LAB_004325cb: + if ((int)(*(uint *)(param_1 + 0x68) * 2) < *(int *)(param_1 + 0x6c) + 1) { + FUN_004320d0(); + } + uVar3 = *param_2 % *(uint *)(param_1 + 0x68); + iVar2 = *(int *)(param_1 + 0x60); + param_2[1] = *(uint *)(iVar2 + uVar3 * 4); + *(uint **)(iVar2 + uVar3 * 4) = param_2; + uVar3 = iVar2 + uVar3 * 4; + if (uVar3 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar3; + } + iVar2 = *(int *)(param_1 + 0x6c) + 1; + *(int *)(param_1 + 0x6c) = iVar2; + return CONCAT31((int3)((uint)iVar2 >> 8),1); + } + if (*puVar1 == *param_2) { + if (puVar1 != (uint *)0x0) { + return (uint)puVar1 & 0xffffff00; + } + goto LAB_004325cb; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_00432620 at 0x00432620 (size: 169) --- + +void __thiscall FUN_00432620(int *param_1,undefined4 *param_2) + +{ + void *pvVar1; + undefined4 *puVar2; + + pvVar1 = (void *)FUN_004171e0(param_2); + if (pvVar1 != (void *)0x0) { + *(undefined1 *)(param_2 + 8) = 0; + (**(code **)(*param_1 + 0xb8))(param_2); + if ((*(uint *)((int)pvVar1 + 0x20) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)((int)pvVar1 + 0x1c)); + } + operator_delete(pvVar1); + return; + } + puVar2 = (undefined4 *)FUN_005df0f5(0x28); + if (puVar2 == (undefined4 *)0x0) { + puVar2 = (undefined4 *)0x0; + } + else { + *puVar2 = *param_2; + puVar2[1] = 0; + puVar2[2] = 0; + puVar2[3] = 0; + puVar2[4] = 0; + puVar2[6] = 0; + puVar2[7] = 0; + puVar2[8] = 0; + puVar2[9] = 0; + } + FUN_004325a0(puVar2); + *(undefined1 *)(param_2 + 8) = 1; + (**(code **)(*param_1 + 0xb8))(param_2); + return; +} + + + +// --- FUN_004326d0 at 0x004326D0 (size: 161) --- + +void __thiscall FUN_004326d0(int *param_1,uint *param_2) + +{ + int iVar1; + uint *puVar2; + + puVar2 = *(uint **)(param_1[0x3c] + (*param_2 % (uint)param_1[0x3e]) * 4); + if (puVar2 != (uint *)0x0) { + while (*puVar2 != *param_2) { + puVar2 = (uint *)puVar2[1]; + if (puVar2 == (uint *)0x0) { + return; + } + } + if (puVar2 != (uint *)0x0) { + iVar1 = FUN_004315c0(param_2); + if (iVar1 == 1) { + *(undefined1 *)(param_2 + 8) = 1; + (**(code **)(*param_1 + 0xb8))(param_2); + } + else if (iVar1 == 3) { + FUN_004171e0(param_2); + *(undefined1 *)(param_2 + 8) = 0; + (**(code **)(*param_1 + 0xb8))(param_2); + if ((puVar2[8] & 0x80000000) == 0x80000000) { + operator_delete__((void *)puVar2[7]); + } + operator_delete(puVar2); + return; + } + } + } + return; +} + + + +// --- FUN_00432780 at 0x00432780 (size: 111) --- + +void __fastcall FUN_00432780(int *param_1) + +{ + void *pvVar1; + undefined1 local_48 [20]; + undefined4 local_34; + undefined1 local_28; + + pvVar1 = (void *)FUN_004171e0(&DAT_0079923c); + if (pvVar1 != (void *)0x0) { + FUN_00430ff0(pvVar1); + local_34 = 0; + local_28 = 0; + (**(code **)(*param_1 + 0xb8))(local_48); + if ((*(uint *)((int)pvVar1 + 0x20) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)((int)pvVar1 + 0x1c)); + } + operator_delete(pvVar1); + } + return; +} + + + +// --- FUN_004327f0 at 0x004327F0 (size: 192) --- + +void __thiscall FUN_004327f0(int *param_1,uint *param_2) + +{ + uint uVar1; + uint *puVar2; + int iVar3; + + for (puVar2 = *(uint **)(param_1[0x3c] + (*param_2 % (uint)param_1[0x3e]) * 4); + (puVar2 != (uint *)0x0 && (*puVar2 != *param_2)); puVar2 = (uint *)puVar2[1]) { + } + if (puVar2 == (uint *)0x0) { + puVar2 = (uint *)FUN_005df0f5(0x28); + if (puVar2 == (uint *)0x0) { + puVar2 = (uint *)0x0; + } + else { + *puVar2 = *param_2; + puVar2[1] = 0; + puVar2[2] = 0; + puVar2[3] = 0; + puVar2[4] = 0; + puVar2[6] = 0; + puVar2[7] = 0; + puVar2[8] = 0; + puVar2[9] = 0; + } + FUN_004325a0(puVar2); + } + iVar3 = FUN_00431fa0(param_2); + if (iVar3 == 0) { + uVar1 = *param_2; + if (((uVar1 == 0x29) || (uVar1 == 0x2a)) || (uVar1 == 0x2b)) { + FUN_00432780(); + } + } + else if (iVar3 != 1) { + return; + } + *(undefined1 *)(param_2 + 8) = 1; + (**(code **)(*param_1 + 0xb8))(param_2); + return; +} + + + +// --- FUN_004328c0 at 0x004328C0 (size: 174) --- + +void __thiscall FUN_004328c0(int param_1,undefined4 *param_2) + +{ + uint uVar1; + int iVar2; + + if (*(int *)(param_1 + 0x8c) != 0) { + iVar2 = FUN_006863a0(*param_2,param_2[1]); + param_2[7] = iVar2; + if (iVar2 == 0) { + param_2[7] = 3; + } + uVar1 = param_2[7]; + if ((float)param_2[5] == DAT_00796344) { + if ((uVar1 == 1) || ((3 < uVar1 && (uVar1 < 6)))) { + FUN_004326d0(param_2); + return; + } + } + else { + switch(uVar1) { + case 1: + FUN_004327f0(param_2); + if ((*(byte *)(param_2 + 4) & 0xa9) == 0) { + FUN_004326d0(param_2); + return; + } + break; + case 2: + FUN_00432620(param_2); + return; + case 3: + FUN_00430ec0(param_2); + return; + default: + FUN_004327f0(param_2); + } + } + } + return; +} + + + +// --- FUN_00432a50 at 0x00432A50 (size: 64) --- + +undefined4 * __thiscall FUN_00432a50(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007994f4; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00432a90 at 0x00432A90 (size: 64) --- + +undefined4 * __thiscall FUN_00432a90(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_007994f8; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00432ad0 at 0x00432AD0 (size: 87) --- + +undefined4 FUN_00432ad0(undefined4 *param_1,undefined4 *param_2) + +{ + byte bVar1; + byte *pbVar2; + int iVar3; + byte *pbVar4; + bool bVar5; + + pbVar4 = (byte *)*param_2; + pbVar2 = (byte *)*param_1; + while( true ) { + bVar1 = *pbVar2; + bVar5 = bVar1 < *pbVar4; + if (bVar1 != *pbVar4) break; + if (bVar1 == 0) { + return 0; + } + bVar1 = pbVar2[1]; + bVar5 = bVar1 < pbVar4[1]; + if (bVar1 != pbVar4[1]) break; + pbVar2 = pbVar2 + 2; + pbVar4 = pbVar4 + 2; + if (bVar1 == 0) { + return 0; + } + } + iVar3 = (1 - (uint)bVar5) - (uint)(bVar5 != 0); + return CONCAT31((int3)((uint)iVar3 >> 8),iVar3 < 0); +} + + + +// --- FUN_00432b30 at 0x00432B30 (size: 78) --- + +void __thiscall FUN_00432b30(int param_1,int *param_2) + +{ + int iVar1; + uint uVar2; + uint uVar3; + + iVar1 = *param_2; + uVar3 = *(uint *)(iVar1 + -8); + uVar2 = *(uint *)(param_1 + 0x68); + if (uVar3 == 0xffffffff) { + uVar3 = FUN_004016b0(iVar1); + *(uint *)(iVar1 + -8) = uVar3; + } + uVar3 = uVar3 % uVar2; + iVar1 = *(int *)(param_1 + 0x60); + param_2[1] = *(int *)(iVar1 + uVar3 * 4); + *(int **)(iVar1 + uVar3 * 4) = param_2; + uVar3 = iVar1 + uVar3 * 4; + if (uVar3 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar3; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + return; +} + + + +// --- FUN_00432b80 at 0x00432B80 (size: 92) --- + +void __thiscall FUN_00432b80(int param_1,undefined1 *param_2) + +{ + LONG LVar1; + undefined4 *puVar2; + + if ((*(int *)(param_1 + 0x10) == 2) && + (**(undefined1 **)(param_1 + 0xc) = *param_2, *(int *)(param_1 + 0x14) != 0)) { + param_2 = *(undefined1 **)(param_1 + 4); + InterlockedIncrement((LONG *)((int)param_2 + -0x10)); + (**(code **)(param_1 + 0x14))(¶m_2); + puVar2 = (undefined4 *)((int)param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)((int)param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + } + return; +} + + + +// --- FUN_00432be0 at 0x00432BE0 (size: 146) --- + +undefined4 * FUN_00432be0(undefined4 *param_1,undefined4 *param_2,undefined4 *param_3) + +{ + byte bVar1; + char cVar2; + byte *pbVar3; + int iVar4; + byte *pbVar5; + bool bVar6; + + pbVar3 = (byte *)*param_1; + pbVar5 = (byte *)*param_2; + do { + bVar1 = *pbVar3; + bVar6 = bVar1 < *pbVar5; + if (bVar1 != *pbVar5) { +LAB_00432c19: + iVar4 = (1 - (uint)bVar6) - (uint)(bVar6 != 0); + goto LAB_00432c1e; + } + if (bVar1 == 0) break; + bVar1 = pbVar3[1]; + bVar6 = bVar1 < pbVar5[1]; + if (bVar1 != pbVar5[1]) goto LAB_00432c19; + pbVar3 = pbVar3 + 2; + pbVar5 = pbVar5 + 2; + } while (bVar1 != 0); + iVar4 = 0; +LAB_00432c1e: + if (iVar4 < 0) { + cVar2 = FUN_00432ad0(param_2,param_3); + if (cVar2 == '\0') { + cVar2 = FUN_00432ad0(param_1,param_3); + if (cVar2 == '\0') { + return param_1; + } + return param_3; + } + } + else { + cVar2 = FUN_00432ad0(param_1,param_3); + if (cVar2 != '\0') { + return param_1; + } + cVar2 = FUN_00432ad0(param_2,param_3); + if (cVar2 != '\0') { + return param_3; + } + } + return param_2; +} + + + +// --- FUN_00432c80 at 0x00432C80 (size: 155) --- + +void FUN_00432c80(int *param_1,int *param_2) + +{ + int iVar1; + int iVar2; + LONG LVar3; + + iVar1 = *param_1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + iVar2 = *param_1; + if (iVar2 != *param_2) { + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar2 = *param_2; + *param_1 = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + } + iVar2 = *param_2; + if (iVar2 != iVar1) { + LVar3 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + *param_2 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + LVar3 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + return; +} + + + +// --- FUN_00432d20 at 0x00432D20 (size: 258) --- + +void FUN_00432d20(int *param_1,byte *param_2) + +{ + byte bVar1; + byte *pbVar2; + byte *pbVar3; + int iVar4; + LONG LVar5; + byte *pbVar6; + int *piVar7; + bool bVar8; + + pbVar2 = (byte *)param_1[-1]; + pbVar3 = param_2; + pbVar6 = pbVar2; + do { + bVar1 = *pbVar3; + bVar8 = bVar1 < *pbVar6; + if (bVar1 != *pbVar6) { +LAB_00432d58: + iVar4 = (1 - (uint)bVar8) - (uint)(bVar8 != 0); + goto joined_r0x00432d5f; + } + if (bVar1 == 0) break; + bVar1 = pbVar3[1]; + bVar8 = bVar1 < pbVar6[1]; + if (bVar1 != pbVar6[1]) goto LAB_00432d58; + pbVar3 = pbVar3 + 2; + pbVar6 = pbVar6 + 2; + } while (bVar1 != 0); + iVar4 = 0; +joined_r0x00432d5f: + do { + if (-1 < iVar4) { + pbVar2 = (byte *)*param_1; + if (pbVar2 != param_2) { + LVar5 = InterlockedDecrement((LONG *)(pbVar2 + -0x10)); + if ((LVar5 == 0) && (pbVar2 + -0x14 != (byte *)0x0)) { + (*(code *)**(undefined4 **)(pbVar2 + -0x14))(1); + } + *param_1 = (int)param_2; + InterlockedIncrement((LONG *)(param_2 + -0x10)); + } + LVar5 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar5 == 0) && (param_2 + -0x14 != (byte *)0x0)) { + (*(code *)**(undefined4 **)(param_2 + -0x14))(1); + } + return; + } + piVar7 = param_1 + -1; + pbVar3 = (byte *)*param_1; + if (pbVar3 != pbVar2) { + LVar5 = InterlockedDecrement((LONG *)(pbVar3 + -0x10)); + if ((LVar5 == 0) && (pbVar3 + -0x14 != (byte *)0x0)) { + (*(code *)**(undefined4 **)(pbVar3 + -0x14))(1); + } + *param_1 = *piVar7; + InterlockedIncrement((LONG *)(*piVar7 + -0x10)); + } + pbVar2 = (byte *)param_1[-2]; + pbVar3 = param_2; + pbVar6 = pbVar2; + do { + bVar1 = *pbVar3; + bVar8 = bVar1 < *pbVar6; + param_1 = piVar7; + if (bVar1 != *pbVar6) { +LAB_00432dc4: + iVar4 = (1 - (uint)bVar8) - (uint)(bVar8 != 0); + goto joined_r0x00432d5f; + } + if (bVar1 == 0) break; + bVar1 = pbVar3[1]; + bVar8 = bVar1 < pbVar6[1]; + if (bVar1 != pbVar6[1]) goto LAB_00432dc4; + pbVar3 = pbVar3 + 2; + pbVar6 = pbVar6 + 2; + } while (bVar1 != 0); + iVar4 = 0; + } while( true ); +} + + + +// --- FUN_00432e30 at 0x00432E30 (size: 242) --- + +void FUN_00432e30(int param_1,int param_2,int param_3,byte *param_4) + +{ + byte bVar1; + int iVar2; + byte *pbVar3; + int iVar4; + LONG LVar5; + byte *pbVar6; + bool bVar7; + + while (iVar2 = param_2, param_3 < iVar2) { + param_2 = (iVar2 + -1) / 2; + pbVar3 = *(byte **)(param_1 + param_2 * 4); + pbVar6 = param_4; + do { + bVar1 = *pbVar3; + bVar7 = bVar1 < *pbVar6; + if (bVar1 != *pbVar6) { +LAB_00432e7b: + iVar4 = (1 - (uint)bVar7) - (uint)(bVar7 != 0); + goto LAB_00432e80; + } + if (bVar1 == 0) break; + bVar1 = pbVar3[1]; + bVar7 = bVar1 < pbVar6[1]; + if (bVar1 != pbVar6[1]) goto LAB_00432e7b; + pbVar3 = pbVar3 + 2; + pbVar6 = pbVar6 + 2; + } while (bVar1 != 0); + iVar4 = 0; +LAB_00432e80: + if (-1 < iVar4) break; + iVar4 = *(int *)(param_1 + iVar2 * 4); + if (iVar4 != *(int *)(param_1 + param_2 * 4)) { + LVar5 = InterlockedDecrement((LONG *)(iVar4 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(iVar4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar4 + -0x14))(1); + } + iVar4 = *(int *)(param_1 + param_2 * 4); + *(int *)(param_1 + iVar2 * 4) = iVar4; + InterlockedIncrement((LONG *)(iVar4 + -0x10)); + } + } + pbVar3 = *(byte **)(param_1 + iVar2 * 4); + if (pbVar3 != param_4) { + LVar5 = InterlockedDecrement((LONG *)(pbVar3 + -0x10)); + if ((LVar5 == 0) && (pbVar3 + -0x14 != (byte *)0x0)) { + (*(code *)**(undefined4 **)(pbVar3 + -0x14))(1); + } + *(byte **)(param_1 + iVar2 * 4) = param_4; + InterlockedIncrement((LONG *)(param_4 + -0x10)); + } + LVar5 = InterlockedDecrement((LONG *)(param_4 + -0x10)); + if ((LVar5 == 0) && (param_4 + -0x14 != (byte *)0x0)) { + (*(code *)**(undefined4 **)(param_4 + -0x14))(1); + } + return; +} + + + +// --- FUN_00432f30 at 0x00432F30 (size: 112) --- + +int * FUN_00432f30(int param_1,int *param_2,int *param_3) + +{ + int iVar1; + LONG LVar2; + int *piVar3; + + iVar1 = (int)param_2 - param_1 >> 2; + piVar3 = param_2; + param_2 = (int *)iVar1; + if (iVar1 < 1) { + return param_3; + } + do { + iVar1 = param_3[-1]; + param_3 = param_3 + -1; + if (iVar1 != piVar3[-1]) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = piVar3[-1]; + *param_3 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + param_2 = (int *)((int)param_2 + -1); + piVar3 = piVar3 + -1; + } while (param_2 != (int *)0x0); + return param_3; +} + + + +// --- FUN_00432fa0 at 0x00432FA0 (size: 19) --- + +undefined4 __fastcall FUN_00432fa0(int param_1) + +{ + int iVar1; + int *piVar2; + int iVar3; + int iVar4; + undefined1 auStack_c [12]; + + if (*(int *)(param_1 + 0x807c) != 0) { + return 0; + } + piVar2 = (int *)FUN_0052dcf0(auStack_c); + iVar4 = piVar2[2]; + iVar1 = *piVar2; + piVar2 = (int *)piVar2[1]; + do { + if (iVar4 == 0) { + return 1; + } + do { + iVar3 = (**(code **)(**(int **)(iVar4 + 8) + 0x3c))(); + if (iVar3 == 0) { + return 0; + } + iVar4 = *(int *)(iVar4 + 4); + } while (iVar4 != 0); + do { + piVar2 = piVar2 + 1; + if (piVar2 == (int *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) { + return 1; + } + iVar4 = *piVar2; + } while (iVar4 == 0); + } while( true ); +} + + + +// --- FUN_00432fb3 at 0x00432FB3 (size: 98) --- + +undefined4 FUN_00432fb3(void) + +{ + int iVar1; + int *piVar2; + int iVar3; + int iVar4; + + piVar2 = (int *)FUN_0052dcf0(&stack0x00000000); + iVar4 = piVar2[2]; + iVar1 = *piVar2; + piVar2 = (int *)piVar2[1]; + do { + if (iVar4 == 0) { + return 1; + } + do { + iVar3 = (**(code **)(**(int **)(iVar4 + 8) + 0x3c))(); + if (iVar3 == 0) { + return 0; + } + iVar4 = *(int *)(iVar4 + 4); + } while (iVar4 != 0); + do { + piVar2 = piVar2 + 1; + if (piVar2 == (int *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) { + return 1; + } + iVar4 = *piVar2; + } while (iVar4 == 0); + } while( true ); +} + + + +// --- FUN_00433020 at 0x00433020 (size: 218) --- + +void __fastcall FUN_00433020(int param_1) + +{ + int *piVar1; + int *piVar2; + int iVar3; + int iVar4; + undefined1 local_c [12]; + + piVar1 = (int *)FUN_0052dcf0(local_c); + piVar2 = (int *)piVar1[1]; + iVar4 = piVar1[2]; + while (iVar4 != 0) { + do { + iVar4 = *(int *)(iVar4 + 4); + } while (iVar4 != 0); + do { + piVar2 = piVar2 + 1; + if (piVar2 == (int *)(*(int *)(*piVar1 + 0x60) + *(int *)(*piVar1 + 0x68) * 4)) + goto LAB_00433067; + iVar4 = *piVar2; + } while (iVar4 == 0); + } +LAB_00433067: + piVar2 = *(int **)(param_1 + 33000); + do { + if (piVar2 == (int *)(*(int *)(param_1 + 0x80e4) + *(int *)(param_1 + 0x80ec) * 4)) { + piVar2 = (int *)0x0; + iVar4 = 0; +joined_r0x004330aa: + do { + if (iVar4 == 0) { + return; + } + do { + iVar3 = (**(code **)(**(int **)(iVar4 + 8) + 0x3c))(); + if (iVar3 == 0) { + (**(code **)(**(int **)(iVar4 + 8) + 0x34))(); + } + iVar4 = *(int *)(iVar4 + 4); + } while (iVar4 != 0); + do { + piVar2 = piVar2 + 1; + if (piVar2 == (int *)(*(int *)(param_1 + 0x80e4) + *(int *)(param_1 + 0x80ec) * 4)) { + return; + } + iVar4 = *piVar2; + } while (iVar4 == 0); + } while( true ); + } + if (**(int **)(param_1 + 33000) != 0) { + piVar2 = *(int **)(param_1 + 33000); + iVar4 = *piVar2; + goto joined_r0x004330aa; + } + piVar2 = *(int **)(param_1 + 33000) + 1; + *(int **)(param_1 + 33000) = piVar2; + } while( true ); +} + + + +// --- FUN_00433100 at 0x00433100 (size: 91) --- + +void __thiscall FUN_00433100(int param_1,int *param_2,int *param_3) + +{ + int iVar1; + uint uVar2; + int iVar3; + char cVar4; + uint uVar5; + + iVar1 = *param_3; + uVar5 = *(uint *)(iVar1 + -8); + uVar2 = *(uint *)(param_1 + 0x68); + if (uVar5 == 0xffffffff) { + uVar5 = FUN_004016b0(iVar1); + *(uint *)(iVar1 + -8) = uVar5; + } + uVar5 = uVar5 % uVar2; + iVar1 = *(int *)(param_1 + 0x60); + iVar3 = *(int *)(iVar1 + uVar5 * 4); + while ((iVar3 != 0 && (cVar4 = FUN_00401920(param_3), cVar4 == '\0'))) { + iVar3 = *(int *)(iVar3 + 4); + } + *param_2 = param_1; + param_2[2] = iVar3; + param_2[1] = iVar1 + uVar5 * 4; + return; +} + + + +// --- FUN_00433160 at 0x00433160 (size: 67) --- + +void FUN_00433160(int *param_1,int *param_2,undefined4 param_3,undefined4 param_4) + +{ + int iVar1; + undefined4 uVar2; + + for (; param_1 != param_2; param_1 = param_1 + 1) { + iVar1 = *param_1; + uVar2 = param_4; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + FUN_00432d20(param_1,iVar1,uVar2); + } + return; +} + + + +// --- FUN_004331b0 at 0x004331B0 (size: 294) --- + +void FUN_004331b0(int param_1,int param_2,int param_3,int param_4,undefined4 param_5) + +{ + byte bVar1; + int iVar2; + byte *pbVar3; + int iVar4; + LONG LVar5; + int iVar6; + int iVar7; + byte *pbVar8; + bool bVar9; + + iVar7 = param_2; + do { + iVar6 = iVar7; + iVar2 = iVar6 * 2; + iVar7 = iVar2 + 2; + if (param_3 <= iVar7) { + if (iVar7 == param_3) { + iVar4 = *(int *)(param_1 + iVar6 * 4); + if (iVar4 != *(int *)(param_1 + -4 + iVar7 * 4)) { + LVar5 = InterlockedDecrement((LONG *)(iVar4 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(iVar4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar4 + -0x14))(1); + } + iVar7 = *(int *)(param_1 + -4 + iVar7 * 4); + *(int *)(param_1 + iVar6 * 4) = iVar7; + InterlockedIncrement((LONG *)(iVar7 + -0x10)); + } + iVar6 = iVar2 + 1; + } + iVar7 = param_4; + InterlockedIncrement((LONG *)(param_4 + -0x10)); + FUN_00432e30(param_1,iVar6,param_2,iVar7,param_5); + LVar5 = InterlockedDecrement((LONG *)(param_4 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(param_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_4 + -0x14))(1); + } + return; + } + pbVar8 = *(byte **)(param_1 + -4 + iVar7 * 4); + pbVar3 = *(byte **)(param_1 + iVar7 * 4); + do { + bVar1 = *pbVar3; + bVar9 = bVar1 < *pbVar8; + if (bVar1 != *pbVar8) { +LAB_004331fc: + iVar4 = (1 - (uint)bVar9) - (uint)(bVar9 != 0); + goto LAB_00433201; + } + if (bVar1 == 0) break; + bVar1 = pbVar3[1]; + bVar9 = bVar1 < pbVar8[1]; + if (bVar1 != pbVar8[1]) goto LAB_004331fc; + pbVar3 = pbVar3 + 2; + pbVar8 = pbVar8 + 2; + } while (bVar1 != 0); + iVar4 = 0; +LAB_00433201: + if (iVar4 < 0) { + iVar7 = iVar2 + 1; + } + iVar2 = *(int *)(param_1 + iVar6 * 4); + if (iVar2 != *(int *)(param_1 + iVar7 * 4)) { + LVar5 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar2 = *(int *)(param_1 + iVar7 * 4); + *(int *)(param_1 + iVar6 * 4) = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + } + } while( true ); +} + + + +// --- FUN_004332e0 at 0x004332E0 (size: 355) --- + +void __fastcall FUN_004332e0(undefined4 *param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + undefined4 *local_4; + + *param_1 = &PTR_LAB_00799534; + local_4 = param_1; + FUN_00401340("Toggle"); + FUN_00436830(&local_4); + puVar2 = local_4 + -5; + LVar1 = InterlockedDecrement(local_4 + -4); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(&DAT_00799528); + FUN_00436830(&local_4); + puVar2 = local_4 + -5; + LVar1 = InterlockedDecrement(local_4 + -4); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(&DAT_00799520); + FUN_00436830(&local_4); + puVar2 = local_4 + -5; + LVar1 = InterlockedDecrement(local_4 + -4); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340(&DAT_00799518); + FUN_00436830(&local_4); + puVar2 = local_4 + -5; + LVar1 = InterlockedDecrement(local_4 + -4); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("ListObjects"); + FUN_00436830(&local_4); + puVar2 = local_4 + -5; + LVar1 = InterlockedDecrement(local_4 + -4); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("ListCommands"); + FUN_00436830(&local_4); + puVar2 = local_4 + -5; + LVar1 = InterlockedDecrement(local_4 + -4); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return; +} + + + +// --- FUN_00433450 at 0x00433450 (size: 295) --- + +undefined4 * FUN_00433450(undefined4 *param_1,undefined4 *param_2,byte *param_3) + +{ + byte bVar1; + byte *pbVar2; + int iVar3; + LONG LVar4; + byte *pbVar5; + undefined4 *puVar6; + bool bVar7; + + do { + pbVar2 = (byte *)*param_1; + pbVar5 = param_3; + do { + bVar1 = *pbVar2; + bVar7 = bVar1 < *pbVar5; + if (bVar1 != *pbVar5) { +LAB_00433488: + iVar3 = (1 - (uint)bVar7) - (uint)(bVar7 != 0); + goto joined_r0x0043348f; + } + if (bVar1 == 0) break; + bVar1 = pbVar2[1]; + bVar7 = bVar1 < pbVar5[1]; + if (bVar1 != pbVar5[1]) goto LAB_00433488; + pbVar2 = pbVar2 + 2; + pbVar5 = pbVar5 + 2; + } while (bVar1 != 0); + iVar3 = 0; +joined_r0x0043348f: + if (iVar3 < 0) { + pbVar2 = (byte *)param_1[1]; + param_1 = param_1 + 1; + pbVar5 = param_3; + do { + bVar1 = *pbVar2; + bVar7 = bVar1 < *pbVar5; + if (bVar1 != *pbVar5) { +LAB_004334c4: + iVar3 = (1 - (uint)bVar7) - (uint)(bVar7 != 0); + goto joined_r0x0043348f; + } + if (bVar1 == 0) break; + bVar1 = pbVar2[1]; + bVar7 = bVar1 < pbVar5[1]; + if (bVar1 != pbVar5[1]) goto LAB_004334c4; + pbVar2 = pbVar2 + 2; + pbVar5 = pbVar5 + 2; + } while (bVar1 != 0); + iVar3 = 0; + goto joined_r0x0043348f; + } + pbVar2 = (byte *)param_2[-1]; + pbVar5 = param_3; + do { + bVar1 = *pbVar5; + bVar7 = bVar1 < *pbVar2; + puVar6 = param_2; + if (bVar1 != *pbVar2) { +LAB_004334f9: + iVar3 = (1 - (uint)bVar7) - (uint)(bVar7 != 0); + goto joined_r0x00433500; + } + if (bVar1 == 0) break; + bVar1 = pbVar5[1]; + bVar7 = bVar1 < pbVar2[1]; + if (bVar1 != pbVar2[1]) goto LAB_004334f9; + pbVar5 = pbVar5 + 2; + pbVar2 = pbVar2 + 2; + } while (bVar1 != 0); + iVar3 = 0; +joined_r0x00433500: + param_2 = puVar6 + -1; + if (iVar3 < 0) { + pbVar2 = (byte *)puVar6[-2]; + pbVar5 = param_3; + do { + bVar1 = *pbVar5; + bVar7 = bVar1 < *pbVar2; + puVar6 = param_2; + if (bVar1 != *pbVar2) { +LAB_00433534: + iVar3 = (1 - (uint)bVar7) - (uint)(bVar7 != 0); + goto joined_r0x00433500; + } + if (bVar1 == 0) break; + bVar1 = pbVar5[1]; + bVar7 = bVar1 < pbVar2[1]; + if (bVar1 != pbVar2[1]) goto LAB_00433534; + pbVar5 = pbVar5 + 2; + pbVar2 = pbVar2 + 2; + } while (bVar1 != 0); + iVar3 = 0; + goto joined_r0x00433500; + } + if (param_2 <= param_1) { + LVar4 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar4 == 0) && (param_3 + -0x14 != (byte *)0x0)) { + (*(code *)**(undefined4 **)(param_3 + -0x14))(1); + } + return param_1; + } + FUN_00432c80(param_1,param_2); + param_1 = param_1 + 1; + } while( true ); +} + + + +// --- FUN_00433580 at 0x00433580 (size: 138) --- + +void FUN_00433580(int *param_1,int param_2,int *param_3,int param_4,undefined4 param_5) + +{ + LONG LVar1; + int iVar2; + + iVar2 = *param_3; + if (iVar2 != *param_1) { + LVar1 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar2 = *param_1; + *param_3 = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + } + iVar2 = param_4; + InterlockedIncrement((LONG *)(param_4 + -0x10)); + FUN_004331b0(param_1,0,param_2 - (int)param_1 >> 2,iVar2,param_5); + LVar1 = InterlockedDecrement((LONG *)(param_4 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(param_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_4 + -0x14))(1); + } + return; +} + + + +// --- FUN_00433610 at 0x00433610 (size: 78) --- + +void FUN_00433610(int param_1,int param_2,undefined4 param_3) + +{ + int iVar1; + int iVar2; + int iVar3; + undefined4 uVar4; + + iVar1 = param_2 - param_1 >> 2; + if (1 < iVar1) { + iVar2 = (iVar1 + -2) / 2; + while( true ) { + iVar3 = *(int *)(param_1 + iVar2 * 4); + uVar4 = param_3; + InterlockedIncrement((LONG *)(iVar3 + -0x10)); + FUN_004331b0(param_1,iVar2,iVar1,iVar3,uVar4); + if (iVar2 == 0) break; + iVar2 = iVar2 + -1; + } + } + return; +} + + + +// --- FUN_00433660 at 0x00433660 (size: 173) --- + +undefined4 FUN_00433660(int *param_1,char *param_2) + +{ + undefined4 *puVar1; + LONG LVar2; + char *pcVar3; + undefined1 local_c [8]; + int local_4; + + puVar1 = (undefined4 *)param_2; + *(undefined4 *)param_2 = 0; + param_2 = (char *)*param_1; + InterlockedIncrement((LONG *)(param_2 + -0x10)); + FUN_004080c0(); + _strlwr(param_2); + FUN_00433100(local_c,¶m_2); + pcVar3 = param_2 + -0x14; + if (local_4 != 0) { + *puVar1 = *(undefined4 *)(local_4 + 8); + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && (pcVar3 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar3)(1); + } + return 1; + } + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && (pcVar3 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar3)(1); + } + return 0; +} + + + +// --- FUN_00433710 at 0x00433710 (size: 173) --- + +undefined4 FUN_00433710(int *param_1,char *param_2) + +{ + undefined4 *puVar1; + LONG LVar2; + char *pcVar3; + undefined1 local_c [8]; + int local_4; + + puVar1 = (undefined4 *)param_2; + *(undefined4 *)param_2 = 0; + param_2 = (char *)*param_1; + InterlockedIncrement((LONG *)(param_2 + -0x10)); + FUN_004080c0(); + _strlwr(param_2); + FUN_00433100(local_c,¶m_2); + pcVar3 = param_2 + -0x14; + if (local_4 != 0) { + *puVar1 = *(undefined4 *)(local_4 + 8); + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && (pcVar3 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar3)(1); + } + return 1; + } + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && (pcVar3 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar3)(1); + } + return 0; +} + + + +// --- FUN_004337c0 at 0x004337C0 (size: 143) --- + +undefined4 * __thiscall FUN_004337c0(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_007994f4; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00433850 at 0x00433850 (size: 143) --- + +undefined4 * __thiscall FUN_00433850(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_007994f8; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_004338e0 at 0x004338E0 (size: 200) --- + +void FUN_004338e0(undefined4 *param_1,int param_2,byte *param_3,undefined4 param_4) + +{ + byte bVar1; + undefined4 *puVar2; + byte *pbVar3; + byte *pbVar4; + int iVar5; + LONG LVar6; + byte *pbVar7; + bool bVar8; + undefined4 uVar9; + + pbVar3 = param_3; + puVar2 = param_1; + pbVar7 = (byte *)*param_1; + pbVar4 = param_3; + do { + bVar1 = *pbVar4; + bVar8 = bVar1 < *pbVar7; + if (bVar1 != *pbVar7) { +LAB_00433914: + iVar5 = (1 - (uint)bVar8) - (uint)(bVar8 != 0); + goto LAB_00433919; + } + if (bVar1 == 0) break; + bVar1 = pbVar4[1]; + bVar8 = bVar1 < pbVar7[1]; + if (bVar1 != pbVar7[1]) goto LAB_00433914; + pbVar4 = pbVar4 + 2; + pbVar7 = pbVar7 + 2; + } while (bVar1 != 0); + iVar5 = 0; +LAB_00433919: + if (iVar5 < 0) { + FUN_00432f30(param_1,param_2,param_2 + 4,¶m_1,0); + pbVar7 = (byte *)*puVar2; + if (pbVar7 != pbVar3) { + LVar6 = InterlockedDecrement((LONG *)(pbVar7 + -0x10)); + if ((LVar6 == 0) && (pbVar7 + -0x14 != (byte *)0x0)) { + (*(code *)**(undefined4 **)(pbVar7 + -0x14))(1); + } + *puVar2 = pbVar3; + InterlockedIncrement((LONG *)(pbVar3 + -0x10)); + } + } + else { + pbVar7 = param_3; + uVar9 = param_4; + InterlockedIncrement((LONG *)(param_3 + -0x10)); + FUN_00432d20(param_2,pbVar7,uVar9); + } + LVar6 = InterlockedDecrement((LONG *)(pbVar3 + -0x10)); + if ((LVar6 == 0) && (pbVar3 + -0x14 != (byte *)0x0)) { + (*(code *)**(undefined4 **)(pbVar3 + -0x14))(1); + } + return; +} + + + +// --- FUN_004339b0 at 0x004339B0 (size: 88) --- + +void FUN_004339b0(int param_1,int param_2,undefined4 param_3) + +{ + int *piVar1; + int iVar2; + undefined4 uVar3; + undefined4 uVar4; + + if (4 < (int)(param_2 - param_1 & 0xfffffffcU)) { + piVar1 = (int *)(param_2 + -4); + do { + iVar2 = *piVar1; + uVar4 = 0; + uVar3 = param_3; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + FUN_00433580(param_1,piVar1,piVar1,iVar2,uVar3,uVar4); + piVar1 = piVar1 + -1; + } while (4 < (int)((4 - param_1) + (int)piVar1 & 0xfffffffcU)); + } + return; +} + + + +// --- FUN_00433a10 at 0x00433A10 (size: 169) --- + +void __fastcall FUN_00433a10(int param_1) + +{ + int iVar1; + int *piVar2; + int *piVar3; + LONG LVar4; + int *piVar5; + int *piVar6; + undefined4 *puVar7; + + iVar1 = *(int *)(param_1 + 0x6c); + do { + if (iVar1 == 0) { + return; + } + piVar5 = *(int **)(param_1 + 100); + while (piVar5 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar5 = *(int **)(param_1 + 100); + piVar6 = (int *)*piVar5; + goto LAB_00433a54; + } + piVar5 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar5; + } + piVar5 = (int *)0x0; + piVar6 = (int *)0x0; +LAB_00433a54: + piVar3 = (int *)*piVar5; + if (piVar3 == piVar6) { +LAB_00433a6d: + *piVar5 = piVar3[1]; + } + else { + do { + piVar2 = piVar3; + piVar3 = (int *)piVar2[1]; + } while (piVar3 != piVar6); + if (piVar2 == (int *)0x0) goto LAB_00433a6d; + piVar2[1] = piVar3[1]; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + if (piVar6 != (int *)0x0) { + puVar7 = (undefined4 *)(*piVar6 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*piVar6 + -0x10)); + if ((LVar4 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + operator_delete(piVar6); + } + iVar1 = *(int *)(param_1 + 0x6c); + } while( true ); +} + + + +// --- FUN_00433ac0 at 0x00433AC0 (size: 69) --- + +void FUN_00433ac0(int *param_1,int *param_2,undefined4 param_3) + +{ + int *piVar1; + int iVar2; + undefined4 uVar3; + + piVar1 = param_1; + if (param_1 != param_2) { + while (piVar1 = piVar1 + 1, piVar1 != param_2) { + iVar2 = *piVar1; + uVar3 = param_3; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + FUN_004338e0(param_1,piVar1,iVar2,uVar3); + } + } + return; +} + + + +// --- FUN_00433b10 at 0x00433B10 (size: 165) --- + +void FUN_00433b10(undefined4 *param_1,undefined4 *param_2,undefined4 *param_3,undefined4 param_4, + undefined4 param_5) + +{ + byte bVar1; + byte *pbVar2; + int iVar3; + undefined4 *puVar4; + byte *pbVar5; + bool bVar6; + byte *pbVar7; + undefined4 uVar8; + undefined4 uVar9; + + FUN_00433610(param_1,param_2,param_5,0,0); + puVar4 = param_2; + do { + if (param_3 <= puVar4) { + FUN_004339b0(param_1,param_2,param_5); + return; + } + pbVar7 = (byte *)*puVar4; + pbVar5 = (byte *)*param_1; + pbVar2 = pbVar7; + do { + bVar1 = *pbVar2; + bVar6 = bVar1 < *pbVar5; + if (bVar1 != *pbVar5) { +LAB_00433b64: + iVar3 = (1 - (uint)bVar6) - (uint)(bVar6 != 0); + goto LAB_00433b69; + } + if (bVar1 == 0) break; + bVar1 = pbVar2[1]; + bVar6 = bVar1 < pbVar5[1]; + if (bVar1 != pbVar5[1]) goto LAB_00433b64; + pbVar2 = pbVar2 + 2; + pbVar5 = pbVar5 + 2; + } while (bVar1 != 0); + iVar3 = 0; +LAB_00433b69: + if (iVar3 < 0) { + uVar9 = 0; + uVar8 = param_5; + InterlockedIncrement((LONG *)(pbVar7 + -0x10)); + FUN_00433580(param_1,param_2,puVar4,pbVar7,uVar8,uVar9); + } + puVar4 = puVar4 + 1; + } while( true ); +} + + + +// --- FUN_00433bc0 at 0x00433BC0 (size: 82) --- + +undefined4 * __thiscall FUN_00433bc0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079954c; + FUN_00433a10(); + param_1[1] = &PTR_FUN_007994f4; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00433c20 at 0x00433C20 (size: 82) --- + +undefined4 * __thiscall FUN_00433c20(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00799550; + FUN_00433a10(); + param_1[1] = &PTR_FUN_007994f8; + if ((undefined4 *)param_1[0x19] != param_1 + 2) { + operator_delete__((undefined4 *)param_1[0x19]); + } + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00433c80 at 0x00433C80 (size: 157) --- + +void __thiscall +FUN_00433c80(undefined4 param_1,int param_2,int param_3,undefined4 param_4,int param_5, + undefined4 param_6) + +{ + int *piVar1; + int iVar2; + undefined4 extraout_ECX; + + if (0x40 < (int)(param_3 - param_2 & 0xfffffffcU)) { + while (param_5 != 0) { + param_5 = param_5 + -1; + piVar1 = (int *)FUN_00432be0(param_2,param_2 + ((param_3 - param_2 >> 2) - + (param_3 - param_2 >> 0x1f) >> 1) * 4, + param_3 + -4,param_6,param_1); + iVar2 = *piVar1; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + iVar2 = FUN_00433450(param_2,param_3,iVar2); + FUN_00433c80(iVar2,param_3,0,param_5,param_6); + param_1 = extraout_ECX; + param_3 = iVar2; + if ((int)(iVar2 - param_2 & 0xfffffffcU) < 0x41) { + return; + } + } + FUN_00433b10(param_2,param_3,param_3,0,param_6); + } + return; +} + + + +// --- FUN_00433d20 at 0x00433D20 (size: 83) --- + +undefined4 * __fastcall FUN_00433d20(undefined4 *param_1) + +{ + *param_1 = 0; + param_1[1] = 0; + param_1[2] = 0; + param_1[0x2003] = &PTR_FUN_0079954c; + FUN_004337c0(0x17); + param_1[0x2020] = &PTR_FUN_00799550; + FUN_00433850(0x17); + param_1[0x203d] = 0; + param_1[0x203e] = 0; + param_1[0x203f] = 0; + return param_1; +} + + + +// --- FUN_00433d80 at 0x00433D80 (size: 1009) --- + +void __fastcall FUN_00433d80(int param_1) + +{ + void *pvVar1; + int *piVar2; + int iVar3; + LONG LVar4; + int *piVar5; + int *piVar6; + int *piVar7; + int *piVar8; + int *piVar9; + undefined4 *puVar10; + int iVar11; + undefined1 local_c [12]; + + piVar2 = (int *)FUN_0052dcf0(local_c); + iVar11 = *piVar2; + piVar7 = (int *)piVar2[2]; + piVar2 = (int *)piVar2[1]; +joined_r0x00433da9: + while (piVar9 = piVar7, piVar9 != (int *)0x0) { + do { + iVar3 = (**(code **)(*(int *)piVar9[2] + 0x3c))(); + if (iVar3 != 0) { + pvVar1 = (void *)piVar9[2]; + if (pvVar1 != (void *)0x0) { + puVar10 = (undefined4 *)(*(int *)((int)pvVar1 + 8) + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*(int *)((int)pvVar1 + 8) + -0x10)); + if ((LVar4 == 0) && (puVar10 != (undefined4 *)0x0)) { + (**(code **)*puVar10)(1); + } + puVar10 = (undefined4 *)(*(int *)((int)pvVar1 + 4) + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*(int *)((int)pvVar1 + 4) + -0x10)); + if ((LVar4 == 0) && (puVar10 != (undefined4 *)0x0)) { + (**(code **)*puVar10)(1); + } + operator_delete(pvVar1); + } + piVar9[2] = 0; + piVar6 = (int *)piVar9[1]; + piVar8 = piVar2; + piVar7 = piVar6; + if (piVar6 != (int *)0x0) goto LAB_00433e45; + goto LAB_00433e36; + } + piVar9 = (int *)piVar9[1]; + } while (piVar9 != (int *)0x0); + do { + piVar2 = piVar2 + 1; + if (piVar2 == (int *)(*(int *)(iVar11 + 0x60) + *(int *)(iVar11 + 0x68) * 4)) + goto LAB_00433ed7; + piVar7 = (int *)*piVar2; + } while ((int *)*piVar2 == (int *)0x0); + } +LAB_00433ed7: + piVar7 = (int *)FUN_0052dcf0(local_c); + iVar3 = piVar7[2]; + iVar11 = *piVar7; + piVar7 = (int *)piVar7[1]; + while (iVar3 != 0) { + do { + pvVar1 = *(void **)(iVar3 + 8); + if (pvVar1 != (void *)0x0) { + puVar10 = (undefined4 *)(*(int *)((int)pvVar1 + 8) + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*(int *)((int)pvVar1 + 8) + -0x10)); + if ((LVar4 == 0) && (puVar10 != (undefined4 *)0x0)) { + (**(code **)*puVar10)(1); + } + puVar10 = (undefined4 *)(*(int *)((int)pvVar1 + 4) + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*(int *)((int)pvVar1 + 4) + -0x10)); + if ((LVar4 == 0) && (puVar10 != (undefined4 *)0x0)) { + (**(code **)*puVar10)(1); + } + operator_delete(pvVar1); + } + *(undefined4 *)(iVar3 + 8) = 0; + iVar3 = *(int *)(iVar3 + 4); + } while (iVar3 != 0); + do { + piVar7 = piVar7 + 1; + if (piVar7 == (int *)(*(int *)(iVar11 + 0x60) + *(int *)(iVar11 + 0x68) * 4)) + goto LAB_00433f88; + iVar3 = *piVar7; + } while (iVar3 == 0); + } +LAB_00433f88: + FUN_00433a10(); + piVar7 = *(int **)(param_1 + 33000); + do { + if (piVar7 == (int *)(*(int *)(param_1 + 0x80e4) + *(int *)(param_1 + 0x80ec) * 4)) { + piVar7 = (int *)0x0; + iVar11 = 0; +joined_r0x00433fdc: + while (iVar11 != 0) { + do { + pvVar1 = *(void **)(iVar11 + 8); + if (pvVar1 != (void *)0x0) { + puVar10 = (undefined4 *)(*(int *)((int)pvVar1 + 8) + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*(int *)((int)pvVar1 + 8) + -0x10)); + if ((LVar4 == 0) && (puVar10 != (undefined4 *)0x0)) { + (**(code **)*puVar10)(1); + } + puVar10 = (undefined4 *)(*(int *)((int)pvVar1 + 4) + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*(int *)((int)pvVar1 + 4) + -0x10)); + if ((LVar4 == 0) && (puVar10 != (undefined4 *)0x0)) { + (**(code **)*puVar10)(1); + } + operator_delete(pvVar1); + } + *(undefined4 *)(iVar11 + 8) = 0; + iVar11 = *(int *)(iVar11 + 4); + } while (iVar11 != 0); + do { + piVar7 = piVar7 + 1; + if (piVar7 == (int *)(*(int *)(param_1 + 0x80e4) + *(int *)(param_1 + 0x80ec) * 4)) + goto LAB_0043406b; + iVar11 = *piVar7; + } while (iVar11 == 0); + } +LAB_0043406b: + FUN_00433a10(); + *(undefined4 *)(param_1 + 0x80fc) = 0; + if ((*(uint *)(param_1 + 0x80f8) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)(param_1 + 0x80f4)); + *(undefined4 *)(param_1 + 0x80f4) = 0; + *(undefined4 *)(param_1 + 0x80f8) = 0; + } + else if (*(int *)(param_1 + 0x80f4) != 0) { + iVar11 = (*(uint *)(param_1 + 0x80f8) & 0x7fffffff) - 1; + while (-1 < iVar11) { + iVar11 = iVar11 + -1; + *(undefined4 *)(*(int *)(param_1 + 0x80f4) + 4 + iVar11 * 4) = 0; + } + } + if ((*(uint *)(param_1 + 0x80f8) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)(param_1 + 0x80f4)); + } + *(undefined ***)(param_1 + 0x8080) = &PTR_FUN_00799550; + FUN_00433a10(); + *(undefined ***)(param_1 + 0x8084) = &PTR_FUN_007994f8; + if (*(void **)(param_1 + 0x80e4) != (void *)(param_1 + 0x8088)) { + operator_delete__(*(void **)(param_1 + 0x80e4)); + } + *(undefined4 *)(param_1 + 0x80e4) = 0; + *(undefined4 *)(param_1 + 33000) = 0; + *(undefined4 *)(param_1 + 0x80ec) = 0; + *(undefined4 *)(param_1 + 0x80f0) = 0; + *(undefined ***)(param_1 + 0x800c) = &PTR_FUN_0079954c; + FUN_00433a10(); + *(undefined ***)(param_1 + 0x8010) = &PTR_FUN_007994f4; + if (*(void **)(param_1 + 0x8070) != (void *)(param_1 + 0x8014)) { + operator_delete__(*(void **)(param_1 + 0x8070)); + } + *(undefined4 *)(param_1 + 0x8070) = 0; + *(undefined4 *)(param_1 + 0x8074) = 0; + *(undefined4 *)(param_1 + 0x8078) = 0; + *(undefined4 *)(param_1 + 0x807c) = 0; + return; + } + if (**(int **)(param_1 + 33000) != 0) { + piVar7 = *(int **)(param_1 + 33000); + iVar11 = *piVar7; + goto joined_r0x00433fdc; + } + piVar7 = *(int **)(param_1 + 33000) + 1; + *(int **)(param_1 + 33000) = piVar7; + } while( true ); + while (piVar7 = (int *)*piVar8, piVar7 == (int *)0x0) { +LAB_00433e36: + piVar8 = piVar8 + 1; + piVar7 = piVar6; + if (piVar8 == (int *)(*(int *)(iVar11 + 0x60) + *(int *)(iVar11 + 0x68) * 4)) break; + } +LAB_00433e45: + piVar6 = (int *)*piVar2; + if (piVar6 != piVar9) { + do { + piVar5 = piVar6; + piVar6 = (int *)piVar5[1]; + } while (piVar6 != piVar9); + if (piVar5 != (int *)0x0) { + piVar5[1] = piVar6[1]; + goto LAB_00433e6a; + } + } + *piVar2 = piVar6[1]; +LAB_00433e6a: + *(int *)(iVar11 + 0x6c) = *(int *)(iVar11 + 0x6c) + -1; + piVar2 = piVar8; + if (piVar9 != (int *)0x0) { + puVar10 = (undefined4 *)(*piVar9 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*piVar9 + -0x10)); + if ((LVar4 == 0) && (puVar10 != (undefined4 *)0x0)) { + (**(code **)*puVar10)(1); + } + operator_delete(piVar9); + } + goto joined_r0x00433da9; +} + + + +// --- FUN_00434180 at 0x00434180 (size: 334) --- + +undefined1 FUN_00434180(int *param_1) + +{ + undefined *puVar1; + char cVar2; + int iVar3; + int *piVar4; + LONG LVar5; + undefined1 uVar6; + undefined4 *puVar7; + undefined *puStack_4; + + piVar4 = param_1; + if (param_1[2] == 0) { + return 0; + } + uVar6 = 1; + if (DAT_008380c8 == 0) { + iVar3 = FUN_005df0f5(0x8100); + if (iVar3 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar2 = FUN_00433710(*piVar4,¶m_1); + if (cVar2 == '\0') { + param_1 = (int *)PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00402710(¶m_1,"Unrecognized object: %s\n\n",*(undefined4 *)*piVar4); + FUN_004355a0(¶m_1); + puVar1 = (undefined *)param_1; + uVar6 = 0; + iVar3 = InterlockedDecrement((LONG *)((int)param_1 + -0x10)); + } + else { + piVar4 = (int *)(**(code **)(*param_1 + 0x34))(); + if (piVar4 == (int *)0x0) { + return 1; + } + puStack_4 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + (**(code **)(*piVar4 + 0x4c))(&puStack_4); + param_1 = (int *)PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00402710(¶m_1,"%s == %s\n\n",piVar4[1],puStack_4); + FUN_004355a0(¶m_1); + puVar7 = (undefined4 *)((int)param_1 + -0x14); + LVar5 = InterlockedDecrement((LONG *)((int)param_1 + -0x10)); + if ((LVar5 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + puVar1 = puStack_4; + iVar3 = InterlockedDecrement((LONG *)(puStack_4 + -0x10)); + } + if ((iVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + return uVar6; +} + + + +// --- FUN_004346f0 at 0x004346F0 (size: 729) --- + +undefined4 FUN_004346f0(void) + +{ + uint uVar1; + char cVar2; + LONG LVar3; + int iVar4; + int *piVar5; + int iVar6; + int iVar7; + int iVar8; + char *pcVar9; + int iVar10; + char *pcVar11; + int iVar12; + undefined4 *puVar13; + int *piVar14; + char *local_28; + int local_24; + uint local_20; + uint local_1c; + int iStack_18; + int *piStack_14; + undefined1 auStack_c [12]; + + FUN_00401340("Listing available commands:\n\n"); + FUN_004355a0(&local_28); + pcVar11 = local_28 + -0x14; + LVar3 = InterlockedDecrement((LONG *)(local_28 + -0x10)); + if ((LVar3 == 0) && (pcVar11 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar11)(1); + } + iVar10 = 0; + local_24 = 0; + local_20 = 0; + local_1c = 0; + if (DAT_008380c8 == 0) { + iVar4 = FUN_005df0f5(0x8100); + if (iVar4 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + piVar5 = (int *)FUN_0052dcf0(auStack_c); + iStack_18 = *piVar5; + piVar14 = (int *)piVar5[1]; + iVar4 = piVar5[2]; + piStack_14 = piVar14; + if (DAT_008380c8 == 0) { + iVar6 = FUN_005df0f5(0x8100); + if (iVar6 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + while (iVar4 != 0) { + do { + iVar6 = *(int *)(iVar4 + 8); + if (local_1c < (local_20 & 0x7fffffff)) { +LAB_00434833: + local_1c = local_1c + 1; + } + else { + pcVar11 = (char *)((local_20 & 0x7fffffff) + 1); + if (pcVar11 < (char *)0x9) { + pcVar11 = (char *)0x8; + } + else if (pcVar11 < (char *)0x4001) { + iVar10 = 0x1f; + if (pcVar11 != (char *)0x0) { + for (; (uint)pcVar11 >> iVar10 == 0; iVar10 = iVar10 + -1) { + } + } + pcVar9 = (char *)(1 << ((byte)iVar10 & 0x1f)); + piVar14 = piStack_14; + local_28 = pcVar11; + if (pcVar9 < pcVar11) { + pcVar11 = (char *)((int)pcVar9 * 2); + } + } + else if (((uint)pcVar11 & 0x3fff) != 0) { + pcVar11 = pcVar11 + (0x4000 - ((uint)pcVar11 & 0x3fff)); + } + cVar2 = FUN_004082c0(pcVar11); + iVar10 = local_24; + if (cVar2 != '\0') goto LAB_00434833; + } + FUN_00402710(iVar10 + -4 + local_1c * 4,"%s - %s\n",*(undefined4 *)(iVar6 + 4), + *(undefined4 *)(iVar6 + 8)); + iVar4 = *(int *)(iVar4 + 4); + } while (iVar4 != 0); + do { + piVar14 = piVar14 + 1; + piStack_14 = piVar14; + if (piVar14 == (int *)(*(int *)(iStack_18 + 0x60) + *(int *)(iStack_18 + 0x68) * 4)) + goto LAB_0043488b; + iVar4 = *piVar14; + } while (iVar4 == 0); + } +LAB_0043488b: + iVar4 = iVar10 + local_1c * 4; + iVar6 = iVar10; + uVar1 = local_1c; + if (iVar10 != iVar4) { + iVar8 = 0; + iVar12 = iVar4 - iVar10 >> 2; + for (iVar7 = iVar12; iVar7 != 1; iVar7 = iVar7 >> 1) { + iVar8 = iVar8 + 1; + } + FUN_00433c80(iVar10,iVar4,0,iVar8 * 2,local_28); + pcVar11 = local_28; + if (iVar12 < 0x11) { + FUN_00433ac0(iVar10,iVar4,local_28); + uVar1 = local_1c; + } + else { + FUN_00433ac0(iVar10,iVar10 + 0x40,local_28); + FUN_00433160(iVar10 + 0x40,iVar4,0,pcVar11); + uVar1 = local_1c; + } + } + for (; uVar1 != 0; uVar1 = uVar1 - 1) { + FUN_004355a0(iVar6); + iVar6 = iVar6 + 4; + } + pcVar11 = "\n"; + do { + pcVar9 = pcVar11; + pcVar11 = pcVar9 + 1; + } while (*pcVar9 != '\0'); + FUN_00401280(pcVar9 + -0x795508); + pcVar9 = "\n"; + pcVar11 = local_28; + do { + cVar2 = *pcVar9; + pcVar9 = pcVar9 + 1; + *pcVar11 = cVar2; + pcVar11 = pcVar11 + 1; + } while (cVar2 != '\0'); + FUN_004355a0(&local_28); + pcVar11 = local_28 + -0x14; + LVar3 = InterlockedDecrement((LONG *)(local_28 + -0x10)); + if ((LVar3 == 0) && (pcVar11 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar11)(1); + } + if (((local_20 & 0x80000000) == 0x80000000) && (iVar10 != 0)) { + iVar6 = *(int *)(iVar10 + -4); + iVar4 = iVar10 + iVar6 * 4; + if (-1 < iVar6 + -1) { + do { + piVar14 = (int *)(iVar4 + -4); + iVar4 = iVar4 + -4; + puVar13 = (undefined4 *)(*piVar14 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(*piVar14 + -0x10)); + if ((LVar3 == 0) && (puVar13 != (undefined4 *)0x0)) { + (**(code **)*puVar13)(1); + } + iVar6 = iVar6 + -1; + } while (iVar6 != 0); + } + operator_delete__((void *)(iVar10 + -4)); + } + return 1; +} + + + +// --- FUN_004349d0 at 0x004349D0 (size: 729) --- + +undefined4 FUN_004349d0(void) + +{ + uint uVar1; + char cVar2; + LONG LVar3; + int iVar4; + int *piVar5; + int iVar6; + int iVar7; + int iVar8; + char *pcVar9; + int iVar10; + char *pcVar11; + int iVar12; + undefined4 *puVar13; + int *piVar14; + char *local_28; + int local_24; + uint local_20; + uint local_1c; + int iStack_18; + int *piStack_14; + undefined1 auStack_c [12]; + + FUN_00401340("Listing available objects:\n\n"); + FUN_004355a0(&local_28); + pcVar11 = local_28 + -0x14; + LVar3 = InterlockedDecrement((LONG *)(local_28 + -0x10)); + if ((LVar3 == 0) && (pcVar11 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar11)(1); + } + iVar10 = 0; + local_24 = 0; + local_20 = 0; + local_1c = 0; + if (DAT_008380c8 == 0) { + iVar4 = FUN_005df0f5(0x8100); + if (iVar4 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + piVar5 = (int *)FUN_0052dcf0(auStack_c); + iStack_18 = *piVar5; + piVar14 = (int *)piVar5[1]; + iVar4 = piVar5[2]; + piStack_14 = piVar14; + if (DAT_008380c8 == 0) { + iVar6 = FUN_005df0f5(0x8100); + if (iVar6 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + while (iVar4 != 0) { + do { + iVar6 = *(int *)(iVar4 + 8); + if (local_1c < (local_20 & 0x7fffffff)) { +LAB_00434b13: + local_1c = local_1c + 1; + } + else { + pcVar11 = (char *)((local_20 & 0x7fffffff) + 1); + if (pcVar11 < (char *)0x9) { + pcVar11 = (char *)0x8; + } + else if (pcVar11 < (char *)0x4001) { + iVar10 = 0x1f; + if (pcVar11 != (char *)0x0) { + for (; (uint)pcVar11 >> iVar10 == 0; iVar10 = iVar10 + -1) { + } + } + pcVar9 = (char *)(1 << ((byte)iVar10 & 0x1f)); + piVar14 = piStack_14; + local_28 = pcVar11; + if (pcVar9 < pcVar11) { + pcVar11 = (char *)((int)pcVar9 * 2); + } + } + else if (((uint)pcVar11 & 0x3fff) != 0) { + pcVar11 = pcVar11 + (0x4000 - ((uint)pcVar11 & 0x3fff)); + } + cVar2 = FUN_004082c0(pcVar11); + iVar10 = local_24; + if (cVar2 != '\0') goto LAB_00434b13; + } + FUN_00402710(iVar10 + -4 + local_1c * 4,"%s - %s\n",*(undefined4 *)(iVar6 + 4), + *(undefined4 *)(iVar6 + 8)); + iVar4 = *(int *)(iVar4 + 4); + } while (iVar4 != 0); + do { + piVar14 = piVar14 + 1; + piStack_14 = piVar14; + if (piVar14 == (int *)(*(int *)(iStack_18 + 0x60) + *(int *)(iStack_18 + 0x68) * 4)) + goto LAB_00434b6b; + iVar4 = *piVar14; + } while (iVar4 == 0); + } +LAB_00434b6b: + iVar4 = iVar10 + local_1c * 4; + iVar6 = iVar10; + uVar1 = local_1c; + if (iVar10 != iVar4) { + iVar8 = 0; + iVar12 = iVar4 - iVar10 >> 2; + for (iVar7 = iVar12; iVar7 != 1; iVar7 = iVar7 >> 1) { + iVar8 = iVar8 + 1; + } + FUN_00433c80(iVar10,iVar4,0,iVar8 * 2,local_28); + pcVar11 = local_28; + if (iVar12 < 0x11) { + FUN_00433ac0(iVar10,iVar4,local_28); + uVar1 = local_1c; + } + else { + FUN_00433ac0(iVar10,iVar10 + 0x40,local_28); + FUN_00433160(iVar10 + 0x40,iVar4,0,pcVar11); + uVar1 = local_1c; + } + } + for (; uVar1 != 0; uVar1 = uVar1 - 1) { + FUN_004355a0(iVar6); + iVar6 = iVar6 + 4; + } + pcVar11 = "\n"; + do { + pcVar9 = pcVar11; + pcVar11 = pcVar9 + 1; + } while (*pcVar9 != '\0'); + FUN_00401280(pcVar9 + -0x795508); + pcVar9 = "\n"; + pcVar11 = local_28; + do { + cVar2 = *pcVar9; + pcVar9 = pcVar9 + 1; + *pcVar11 = cVar2; + pcVar11 = pcVar11 + 1; + } while (cVar2 != '\0'); + FUN_004355a0(&local_28); + pcVar11 = local_28 + -0x14; + LVar3 = InterlockedDecrement((LONG *)(local_28 + -0x10)); + if ((LVar3 == 0) && (pcVar11 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar11)(1); + } + if (((local_20 & 0x80000000) == 0x80000000) && (iVar10 != 0)) { + iVar6 = *(int *)(iVar10 + -4); + iVar4 = iVar10 + iVar6 * 4; + if (-1 < iVar6 + -1) { + do { + piVar14 = (int *)(iVar4 + -4); + iVar4 = iVar4 + -4; + puVar13 = (undefined4 *)(*piVar14 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(*piVar14 + -0x10)); + if ((LVar3 == 0) && (puVar13 != (undefined4 *)0x0)) { + (**(code **)*puVar13)(1); + } + iVar6 = iVar6 + -1; + } while (iVar6 != 0); + } + operator_delete__((void *)(iVar10 + -4)); + } + return 1; +} + + + +// --- FUN_00434e60 at 0x00434E60 (size: 931) --- + +undefined4 * __fastcall FUN_00434e60(undefined4 *param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + int local_c; + int local_8; + int iStack_4; + + *param_1 = &PTR_LAB_00799534; + FUN_00401340("Displays a list of each command with a brief description"); + FUN_00401340("ListCommands"); + FUN_00436580(FUN_004346f0,&local_c,&local_8); + puVar2 = (undefined4 *)(local_c + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_8 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("Displays a list of each object with a brief description"); + FUN_00401340("ListObjects"); + FUN_00436580(FUN_004349d0,&local_8,&local_c); + puVar2 = (undefined4 *)(local_8 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_c + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340( + "Help [command name] (if you omit the command name, a list of available commands will be provided.)" + ); + FUN_00401340("Displays description and usage information for commands and variables"); + FUN_00401340(&DAT_00799518); + FUN_004366d0(&LAB_00434cb0,&local_8,&local_c,&iStack_4); + puVar2 = (undefined4 *)(local_8 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_c + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(iStack_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(iStack_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("Dump "); + FUN_00401340("Displays information about an object"); + FUN_00401340(&DAT_00799520); + FUN_004366d0(FUN_00434180,&iStack_4,&local_8,&local_c); + puVar2 = (undefined4 *)(iStack_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(iStack_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_8 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_c + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("Set [component name] "); + FUN_00401340("Sets the contents of an object"); + FUN_00401340(&DAT_00799528); + FUN_004366d0(&LAB_004342d0,&iStack_4,&local_8,&local_c); + puVar2 = (undefined4 *)(iStack_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(iStack_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_8 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_c + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("Toggle "); + FUN_00401340("Toggles the contents of a boolean variable"); + FUN_00401340("Toggle"); + FUN_004366d0(&LAB_00434560,&iStack_4,&local_8,&local_c); + puVar2 = (undefined4 *)(iStack_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(iStack_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + LVar1 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(local_8 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_8 + -0x14))(1); + } + LVar1 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(local_c + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_c + -0x14))(1); + } + FUN_00401340("Console initialized.\n\n"); + FUN_004355a0(&iStack_4); + LVar1 = InterlockedDecrement((LONG *)(iStack_4 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(iStack_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iStack_4 + -0x14))(1); + } + return param_1; +} + + + +// --- FUN_00435210 at 0x00435210 (size: 8) --- + +void FUN_00435210(void) + +{ + FUN_00405f70(); + return; +} + + + +// --- FUN_00435220 at 0x00435220 (size: 34) --- + +int __thiscall FUN_00435220(int param_1,byte param_2) + +{ + FUN_00435250(); + if ((param_2 & 1) != 0) { + operator_delete((void *)(param_1 + -4)); + } + return param_1 + -4; +} + + + +// --- FUN_00435250 at 0x00435250 (size: 37) --- + +void __fastcall FUN_00435250(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_007998e8; + param_1[-1] = &PTR_LAB_007998ec; + *(undefined ***)(-(uint)(param_1 != (undefined4 *)0x4) & (uint)param_1) = &PTR_FUN_007952f4; + FUN_004332e0(); + return; +} + + + +// --- FUN_004352e0 at 0x004352E0 (size: 59) --- + +void FUN_004352e0(void) + +{ + int iVar1; + + if (DAT_008380c8 == 0) { + iVar1 = FUN_005df0f5(0x8100); + if (iVar1 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + FUN_00693b70(&stack0x00000004); + return; +} + + + +// --- FUN_00435320 at 0x00435320 (size: 99) --- + +void __fastcall FUN_00435320(int param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)(*(int *)(param_1 + 0xc) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)(param_1 + 0xc) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(*(int *)(param_1 + 8) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)(param_1 + 8) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(*(int *)(param_1 + 4) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)(param_1 + 4) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return; +} + + + +// --- FUN_00435390 at 0x00435390 (size: 110) --- + +void __thiscall FUN_00435390(int *param_1,int param_2) + +{ + int *piVar1; + LONG *lpAddend; + int *piVar2; + + param_1[1] = param_2; + piVar1 = (int *)thunk_FUN_005df0f5(param_2 * 4 + 4); + if (piVar1 == (int *)0x0) { + *param_1 = 0; + return; + } + *piVar1 = param_2; + piVar2 = piVar1 + 1; + if (-1 < param_2 + -1) { + do { + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *piVar2 = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + param_2 = param_2 + -1; + piVar2 = piVar2 + 1; + } while (param_2 != 0); + } + *param_1 = (int)(piVar1 + 1); + return; +} + + + +// --- FUN_00435400 at 0x00435400 (size: 67) --- + +undefined4 * __fastcall FUN_00435400(undefined4 *param_1) + +{ + LONG *pLVar1; + + *param_1 = &PTR_FUN_00799930; + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[1] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[2] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + *param_1 = &PTR_FUN_00799978; + param_1[3] = 0; + return param_1; +} + + + +// --- FUN_00435450 at 0x00435450 (size: 84) --- + +undefined4 * __fastcall FUN_00435450(undefined4 *param_1) + +{ + LONG *pLVar1; + + *param_1 = &PTR_FUN_00799930; + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[1] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[2] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + *param_1 = &PTR_FUN_007999c0; + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[3] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + param_1[4] = 0; + return param_1; +} + + + +// --- FUN_004354b0 at 0x004354B0 (size: 77) --- + +undefined4 * __fastcall FUN_004354b0(undefined4 *param_1) + +{ + LONG *pLVar1; + + *param_1 = &PTR_FUN_00799930; + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[1] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[2] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + *param_1 = &PTR_FUN_00799a08; + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[3] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + return param_1; +} + + + +// --- FUN_00435500 at 0x00435500 (size: 71) --- + +void __thiscall FUN_00435500(int param_1,int *param_2) + +{ + int iVar1; + LONG LVar2; + + iVar1 = *param_2; + if (iVar1 != *(int *)(param_1 + 0xc)) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *(int *)(param_1 + 0xc); + *param_2 = iVar1; + /* WARNING: Could not recover jumptable at 0x0043553c. Too many branches */ + /* WARNING: Treating indirect jump as call */ + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + return; + } + return; +} + + + +// --- FUN_00435550 at 0x00435550 (size: 68) --- + +undefined4 __thiscall FUN_00435550(int param_1,int *param_2) + +{ + int iVar1; + LONG LVar2; + + iVar1 = *(int *)(param_1 + 0xc); + if (iVar1 != *param_2) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *param_2; + *(int *)(param_1 + 0xc) = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + return 1; +} + + + +// --- FUN_004355a0 at 0x004355A0 (size: 287) --- + +void FUN_004355a0(int *param_1) + +{ + uint *puVar1; + int iVar2; + uint uVar3; + uint uVar4; + int iVar5; + int *piVar6; + int iVar7; + int *piVar8; + uint uVar9; + + iVar7 = *(int *)(*param_1 + -4); + if (iVar7 != 0) { + uVar9 = 0; + piVar8 = DAT_008380c8; + if (iVar7 != 1) { + do { + iVar2 = *param_1; + uVar3 = *(uint *)(iVar2 + -4); + uVar4 = uVar3 - 1; + if (uVar9 < uVar3) { + uVar4 = uVar9; + } + piVar6 = piVar8; + if (piVar8 == (int *)0x0) { + iVar5 = FUN_005df0f5(0x8100); + if (iVar5 == 0) { + piVar6 = (int *)0x0; + DAT_008380c8 = piVar6; + } + else { + piVar6 = (int *)FUN_00433d20(); + DAT_008380c8 = piVar6; + } + } + uVar3 = piVar6[2]; + puVar1 = (uint *)(piVar6 + 2); + piVar8 = piVar6; + if (uVar3 == 0x8000) { + *(undefined1 *)((int)piVar6 + *piVar6 + 0xc) = 0; + if (*piVar6 == 0x7fff) { + *piVar6 = 0; + } + else { + *piVar6 = *piVar6 + 1; + } + *puVar1 = *puVar1 - 1; + uVar3 = *puVar1; + piVar8 = DAT_008380c8; + } + if (uVar3 < 0x8000) { + *(undefined1 *)((int)piVar6 + piVar6[1] + 0xc) = *(undefined1 *)(uVar4 + iVar2); + if (piVar6[1] == 0x7fff) { + piVar6[1] = 0; + } + else { + piVar6[1] = piVar6[1] + 1; + } + *puVar1 = *puVar1 + 1; + piVar8 = DAT_008380c8; + } + uVar9 = uVar9 + 1; + } while (uVar9 < iVar7 - 1U); + } + uVar9 = 0; + while( true ) { + if (piVar8 == (int *)0x0) { + iVar7 = FUN_005df0f5(0x8100); + if (iVar7 == 0) { + piVar8 = (int *)0x0; + DAT_008380c8 = piVar8; + } + else { + piVar8 = (int *)FUN_00433d20(); + DAT_008380c8 = piVar8; + } + } + if ((uint)piVar8[0x203f] <= uVar9) break; + (**(code **)**(undefined4 **)(piVar8[0x203d] + uVar9 * 4))(param_1); + uVar9 = uVar9 + 1; + piVar8 = DAT_008380c8; + } + } + return; +} + + + +// --- FUN_004356c0 at 0x004356C0 (size: 91) --- + +void * __thiscall FUN_004356c0(void *param_1,byte param_2) + +{ + LONG LVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)(*(int *)((int)param_1 + 8) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)((int)param_1 + 8) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(*(int *)((int)param_1 + 4) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)((int)param_1 + 4) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00435720 at 0x00435720 (size: 324) --- + +void __thiscall FUN_00435720(int *param_1,char param_2,char param_3,char *param_4) + +{ + char cVar1; + undefined *puVar2; + char *pcVar3; + LONG LVar4; + LONG *lpAddend; + int iVar5; + char *pcVar6; + + pcVar6 = (char *)*param_1; + iVar5 = *(int *)(pcVar6 + -4) + -1; + if (param_2 != '\0') { + cVar1 = *pcVar6; + while ((cVar1 != '\0' && (pcVar3 = strchr(param_4,(int)cVar1), pcVar3 != (char *)0x0))) { + cVar1 = pcVar6[1]; + pcVar6 = pcVar6 + 1; + iVar5 = iVar5 + -1; + } + } + if (param_3 != '\0') { + while ((iVar5 != 0 && (pcVar3 = strchr(param_4,(int)pcVar6[iVar5 + -1]), pcVar3 != (char *)0x0)) + ) { + iVar5 = iVar5 + -1; + } + } + pcVar3 = (char *)*param_1; + if ((pcVar6 == pcVar3) && (iVar5 == *(int *)(pcVar3 + -4) + -1)) { + LVar4 = InterlockedDecrement((LONG *)(param_4 + -0x10)); + if ((LVar4 == 0) && (param_4 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(param_4 + -0x14))(1); + return; + } + } + else { + InterlockedIncrement((LONG *)(pcVar3 + -0x10)); + puVar2 = (undefined *)*param_1; + if (puVar2 != PTR_DAT_00818344) { + LVar4 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + if (iVar5 != 0) { + FUN_00404ef0(pcVar6,iVar5); + } + LVar4 = InterlockedDecrement((LONG *)(pcVar3 + -0x10)); + if ((LVar4 == 0) && (pcVar3 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(pcVar3 + -0x14))(1); + } + LVar4 = InterlockedDecrement((LONG *)(param_4 + -0x10)); + if ((LVar4 == 0) && (param_4 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(param_4 + -0x14))(1); + } + } + return; +} + + + +// --- FUN_00435870 at 0x00435870 (size: 86) --- + +undefined4 * __fastcall FUN_00435870(undefined4 *param_1) + +{ + LONG *pLVar1; + + *param_1 = &PTR_FUN_00799930; + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[1] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[2] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + param_1[3] = 0; + param_1[4] = 0; + param_1[5] = 0; + *param_1 = &PTR_FUN_00799a60; + param_1[6] = 0; + param_1[7] = 0; + param_1[8] = 0; + param_1[9] = 0; + *(undefined1 *)(param_1 + 10) = 0; + return param_1; +} + + + +// --- FUN_004358e0 at 0x004358E0 (size: 62) --- + +void __thiscall FUN_004358e0(int param_1,undefined4 param_2) + +{ + float *pfVar1; + uint uVar2; + + if (*(int *)(param_1 + 0x1c) != 0) { + switch(*(undefined4 *)(param_1 + 0x10)) { + case 3: + break; + case 4: + break; + case 5: + break; + case 6: + break; + case 7: + break; + case 8: + break; + default: + goto LAB_0043595b; + } + uVar2 = FUN_00435b30(); + if ((uVar2 != 0xffffffff) && (uVar2 < *(uint *)(param_1 + 0x1c))) { + FUN_00402070(); + return; + } + } +LAB_0043595b: + switch(*(undefined4 *)(param_1 + 0x10)) { + case 1: + FUN_00402710(); + return; + case 2: + if (**(char **)(param_1 + 0xc) != '\x01') { + FUN_00405000(); + return; + } + FUN_00405000(); + return; + case 3: + case 4: + break; + case 5: + break; + case 6: + break; + case 7: + break; + case 8: + break; + case 9: + FUN_00402710(param_2,&DAT_00799ad8,(double)**(float **)(param_1 + 0xc)); + return; + case 10: + FUN_00402710(param_2,&DAT_00799ad8,**(undefined8 **)(param_1 + 0xc)); + return; + case 0xb: + pfVar1 = *(float **)(param_1 + 0xc); + FUN_00402710(param_2,"%.2f %.2f %.2f",(double)*pfVar1,(double)pfVar1[1],(double)pfVar1[2]); + return; + case 0xc: + pfVar1 = *(float **)(param_1 + 0xc); + FUN_00402710(param_2,"%.2f %.2f %.2f %.2f",(double)*pfVar1,(double)pfVar1[1],(double)pfVar1[2], + (double)pfVar1[3]); + return; + case 0xd: + FUN_00402070(); + return; + case 0xe: + FUN_005b2c30(); + FUN_00402070(); + FUN_004011b0(); + default: + return; + } + FUN_00402710(); + return; +} + + + +// --- FUN_00435b30 at 0x00435B30 (size: 58) --- + +uint __thiscall FUN_00435b30(int param_1,uint param_2) + +{ + uint uVar1; + uint uVar2; + uint *puVar3; + + uVar1 = *(uint *)(param_1 + 0x24); + if (uVar1 == *(uint *)(param_1 + 0x1c)) { + uVar2 = 0; + if (uVar1 != 0) { + puVar3 = *(uint **)(param_1 + 0x20); + do { + if (param_2 == *puVar3) { + return uVar2; + } + uVar2 = uVar2 + 1; + puVar3 = puVar3 + 1; + } while (uVar2 < uVar1); + return 0xffffffff; + } + } + else if (param_2 < *(uint *)(param_1 + 0x1c)) { + return param_2; + } + return 0xffffffff; +} + + + +// --- FUN_00435ed0 at 0x00435ED0 (size: 105) --- + +undefined4 FUN_00435ed0(undefined4 *param_1,undefined4 *param_2) + +{ + int iVar1; + undefined4 local_10; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + iVar1 = sscanf((char *)*param_1,"%f %f %f %f",&local_10,&local_c,&local_8,&local_4); + if (iVar1 == 3) { + local_4 = 0x3f800000; + } + else if (iVar1 != 4) { + return 0; + } + *param_2 = local_10; + param_2[1] = local_c; + param_2[2] = local_8; + param_2[3] = local_4; + return 1; +} + + + +// --- FUN_00435f40 at 0x00435F40 (size: 48) --- + +undefined4 FUN_00435f40(undefined4 *param_1,undefined4 *param_2) + +{ + char *_Str; + int *piVar1; + double dVar2; + + _Str = (char *)*param_1; + piVar1 = _errno(); + *piVar1 = 0; + dVar2 = strtod(_Str,(char **)0x0); + param_2[1] = (float)dVar2; + *param_2 = 1; + return 1; +} + + + +// --- FUN_00435f70 at 0x00435F70 (size: 294) --- + +undefined4 FUN_00435f70(undefined4 param_1,undefined4 param_2) + +{ + bool bVar1; + char cVar2; + LONG LVar3; + int local_10; + int local_c; + int iStack_8; + int local_4; + + FUN_00401340("False"); + cVar2 = FUN_00404d20(&local_4,0); + if (cVar2 == '\0') { + FUN_00401340(&DAT_00799b04); + cVar2 = FUN_00404d20(&local_10,0); + LVar3 = InterlockedDecrement((LONG *)(local_10 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(local_10 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_10 + -0x14))(1); + } + if (cVar2 == '\0') { + FUN_00401340(&DAT_00799b00); + cVar2 = FUN_00404d20(&local_c,0); + LVar3 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(local_c + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_c + -0x14))(1); + } + if (cVar2 == '\0') { + FUN_00401340(&DAT_00799afc); + cVar2 = FUN_00404d20(&iStack_8,0); + LVar3 = InterlockedDecrement((LONG *)(iStack_8 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iStack_8 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iStack_8 + -0x14))(1); + } + bVar1 = false; + if (cVar2 == '\0') goto LAB_00436064; + } + } + } + bVar1 = true; +LAB_00436064: + LVar3 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + *(bool *)param_2 = !bVar1; + return 1; +} + + + +// --- FUN_004360a0 at 0x004360A0 (size: 113) --- + +void __fastcall FUN_004360a0(int param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + operator_delete__(*(void **)(param_1 + 0x20)); + *(undefined4 *)(param_1 + 0x20) = 0; + *(undefined4 *)(param_1 + 0x24) = 0; + if (*(int *)(param_1 + 0x18) != 0) { + FUN_00407920(3); + } + *(undefined4 *)(param_1 + 0x18) = 0; + *(undefined4 *)(param_1 + 0x1c) = 0; + puVar2 = (undefined4 *)(*(int *)(param_1 + 8) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)(param_1 + 8) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(*(int *)(param_1 + 4) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)(param_1 + 4) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return; +} + + + +// --- FUN_00436120 at 0x00436120 (size: 105) --- + +void FUN_00436120(undefined4 param_1) + +{ + int *piVar1; + char cVar2; + int iVar3; + uint uVar4; + undefined4 uVar5; + + if (DAT_008380c8 == 0) { + iVar3 = FUN_005df0f5(0x8100); + if (iVar3 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + iVar3 = DAT_008380c8; + piVar1 = (int *)(DAT_008380c8 + 0x80f4); + uVar4 = *(uint *)(DAT_008380c8 + 0x80f8) & 0x7fffffff; + if (uVar4 <= *(uint *)(DAT_008380c8 + 0x80fc)) { + uVar5 = FUN_00453850(uVar4 + 1); + cVar2 = FUN_004180a0(uVar5); + if (cVar2 == '\0') { + return; + } + } + *(undefined4 *)(*piVar1 + *(int *)(iVar3 + 0x80fc) * 4) = param_1; + piVar1 = (int *)(iVar3 + 0x80fc); + *piVar1 = *piVar1 + 1; + return; +} + + + +// --- FUN_00436190 at 0x00436190 (size: 897) --- + +/* WARNING: Type propagation algorithm not settling */ + +void FUN_00436190(int *param_1) + +{ + char cVar1; + int iVar2; + LONG LVar3; + undefined4 extraout_ECX; + int iVar4; + undefined4 *puVar5; + int *piVar6; + undefined4 uVar7; + undefined *local_2c; + int *piStack_28; + int local_24; + int iStack_20; + int local_1c; + uint local_18; + undefined4 local_14; + undefined **local_10; + int *local_c; + undefined4 local_8; + int local_4; + + piVar6 = param_1; + local_24 = *param_1; + InterlockedIncrement((LONG *)(local_24 + -0x10)); + uVar7 = extraout_ECX; + FUN_00401340(&DAT_00795098); + FUN_00435720(1,1,uVar7); + iVar4 = 0; + local_10 = &PTR_FUN_00795074; + local_c = (int *)0x0; + local_8 = 0; + local_4 = 0; + cVar1 = thunk_FUN_0040c2d0(piVar6,0x20,&local_10); + if (cVar1 == '\0') { + local_10 = &PTR_FUN_00795074; + FUN_00405210(); + } + else { + if (local_4 != 0) { + local_2c = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + local_1c = 0; + local_18 = 0; + local_14 = 0; + piVar6 = local_c; +LAB_00436260: + do { + if (piVar6 == (int *)0x0) goto LAB_004362af; + if (iVar4 == 0) { + if (local_2c != (undefined *)*piVar6) { + puVar5 = (undefined4 *)(local_2c + -0x14); + LVar3 = InterlockedDecrement((LONG *)(local_2c + -0x10)); + if ((LVar3 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + local_2c = (undefined *)*piVar6; + InterlockedIncrement((LONG *)(local_2c + -0x10)); + piVar6 = (int *)piVar6[1]; + iVar4 = 1; + goto LAB_00436260; + } + } + else { + FUN_0040c440(piVar6); + } + piVar6 = (int *)piVar6[1]; + iVar4 = iVar4 + 1; + } while( true ); + } + local_10 = &PTR_FUN_00795074; + FUN_00405210(); + } + iVar4 = local_24; + iVar2 = InterlockedDecrement((LONG *)(local_24 + -0x10)); + goto joined_r0x004364fb; +LAB_004362af: + if (DAT_008380c8 == 0) { + iVar4 = FUN_005df0f5(0x8100); + if (iVar4 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar1 = FUN_00433660(&local_2c,&piStack_28); + if (cVar1 == '\0') { + param_1 = (int *)PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00402710(¶m_1,"Unrecognized command: %s\n\n",local_2c); + FUN_004355a0(¶m_1); + piVar6 = param_1; + LVar3 = InterlockedDecrement(param_1 + -4); +joined_r0x0043648b: + if ((LVar3 == 0) && ((int *)((int)piVar6 + 0xffffffecU) != (int *)0x0)) { + (*(code *)**(undefined4 **)((int)piVar6 + 0xffffffecU))(1); + } + } + else { + iVar4 = (**(code **)(*piStack_28 + 0x14))(); + iVar2 = (**(code **)(*piStack_28 + 0x1c))(); + if (iVar4 == 0) { + if (iVar2 != 0) { + cVar1 = (**(code **)(iVar2 + 0x10))(&local_1c); + goto joined_r0x00436329; + } +LAB_0043632f: + FUN_00401340("Command failed.\n\n"); + FUN_004355a0(&iStack_20); + puVar5 = (undefined4 *)(iStack_20 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(iStack_20 + -0x10)); + if ((LVar3 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + param_1 = (int *)PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00402710(¶m_1," Name: %s\n",piStack_28[1]); + FUN_004355a0(¶m_1); + if (*(int *)(piStack_28[2] + -4) != 1) { + FUN_00402710(¶m_1," Description: %s\n",piStack_28[2]); + FUN_004355a0(¶m_1); + } + if ((iVar2 != 0) && (*(int *)(*(int *)(iVar2 + 0xc) + -4) != 1)) { + FUN_00402710(¶m_1," Usage: %s\n",*(int *)(iVar2 + 0xc)); + FUN_004355a0(¶m_1); + } + FUN_00401340(&DAT_00795508); + FUN_004355a0(&iStack_20); + LVar3 = InterlockedDecrement((LONG *)(iStack_20 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iStack_20 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iStack_20 + -0x14))(1); + } + piVar6 = param_1; + LVar3 = InterlockedDecrement(param_1 + -4); + goto joined_r0x0043648b; + } + cVar1 = (**(code **)(iVar4 + 0xc))(); +joined_r0x00436329: + if (cVar1 == '\0') goto LAB_0043632f; + } + if (((local_18 & 0x80000000) == 0x80000000) && (local_1c != 0)) { + FUN_00407920(3); + } + puVar5 = (undefined4 *)(local_2c + -0x14); + LVar3 = InterlockedDecrement((LONG *)(local_2c + -0x10)); + if ((LVar3 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + local_10 = &PTR_FUN_00795074; + FUN_00405210(); + iVar4 = local_24; + iVar2 = InterlockedDecrement((LONG *)(local_24 + -0x10)); +joined_r0x004364fb: + if ((iVar2 == 0) && ((undefined4 *)(iVar4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar4 + -0x14))(1); + } + return; +} + + + +// --- FUN_00436520 at 0x00436520 (size: 83) --- + +undefined4 FUN_00436520(undefined4 param_1,int *param_2) + +{ + int *piVar1; + LONG LVar2; + undefined4 *puVar3; + + piVar1 = (int *)FUN_005ded90(param_1); + if (piVar1 != (int *)0x0) { + *param_2 = piVar1[2]; + puVar3 = (undefined4 *)(*piVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(*piVar1 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + operator_delete(piVar1); + return 1; + } + return 0; +} + + + +// --- FUN_00436580 at 0x00436580 (size: 326) --- + +void FUN_00436580(int param_1,int *param_2,undefined4 param_3) + +{ + int *piVar1; + char cVar2; + char *pcVar3; + int iVar4; + LONG LVar5; + char **ppcVar6; + undefined4 *puVar7; + char *pcStack_c; + char *local_8; + undefined1 auStack_4 [4]; + + FUN_00401340(&DAT_00795098); + piVar1 = param_2; + pcVar3 = strstr((char *)*param_2,local_8); + if (pcVar3 == (char *)0x0) { + iVar4 = -1; + } + else { + iVar4 = (int)pcVar3 - *piVar1; + } + LVar5 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar5 == 0) && (local_8 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(local_8 + -0x14))(1); + } + if ((iVar4 == -1) && (param_1 != 0)) { + if (DAT_008380c8 == 0) { + iVar4 = FUN_005df0f5(0x8100); + if (iVar4 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar2 = FUN_00433660(piVar1,auStack_4); + if (cVar2 == '\0') { + iVar4 = FUN_005df0f5(0x10); + if (iVar4 == 0) { + iVar4 = 0; + } + else { + iVar4 = FUN_00435400(); + } + FUN_00402070(piVar1); + FUN_00402070(param_3); + *(int *)(iVar4 + 0xc) = param_1; + pcStack_c = (char *)*piVar1; + InterlockedIncrement((LONG *)(pcStack_c + -0x10)); + FUN_004080c0(); + _strlwr(pcStack_c); + puVar7 = ¶m_2; + ppcVar6 = &pcStack_c; + param_2 = (int *)iVar4; + FUN_00401750(ppcVar6,puVar7); + cVar2 = FUN_0068c4c0(ppcVar6,puVar7); + if (cVar2 == '\0') { + FUN_004356c0(1); + } + FUN_004011b0(); + } + } + return; +} + + + +// --- FUN_004366d0 at 0x004366D0 (size: 346) --- + +void FUN_004366d0(int param_1,int *param_2,undefined4 param_3,undefined4 param_4) + +{ + int *piVar1; + char cVar2; + char *pcVar3; + int iVar4; + LONG LVar5; + void *pvVar6; + char **ppcVar7; + undefined4 *puVar8; + char *pcStack_c; + char *local_8; + undefined1 auStack_4 [4]; + + FUN_00401340(&DAT_00795098); + piVar1 = param_2; + pcVar3 = strstr((char *)*param_2,local_8); + if (pcVar3 == (char *)0x0) { + iVar4 = -1; + } + else { + iVar4 = (int)pcVar3 - *piVar1; + } + LVar5 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar5 == 0) && (local_8 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(local_8 + -0x14))(1); + } + if ((iVar4 == -1) && (param_1 != 0)) { + if (DAT_008380c8 == 0) { + iVar4 = FUN_005df0f5(0x8100); + if (iVar4 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar2 = FUN_00433660(piVar1,auStack_4); + if (cVar2 == '\0') { + iVar4 = FUN_005df0f5(0x14); + if (iVar4 == 0) { + pvVar6 = (void *)0x0; + } + else { + pvVar6 = (void *)FUN_00435450(); + } + FUN_00402070(piVar1); + FUN_00402070(param_3); + *(int *)((int)pvVar6 + 0x10) = param_1; + FUN_00402070(param_4); + pcStack_c = (char *)*piVar1; + InterlockedIncrement((LONG *)(pcStack_c + -0x10)); + FUN_004080c0(); + _strlwr(pcStack_c); + puVar8 = ¶m_2; + ppcVar7 = &pcStack_c; + param_2 = pvVar6; + FUN_00401750(ppcVar7,puVar8); + cVar2 = FUN_0068c4c0(ppcVar7,puVar8); + if (cVar2 == '\0') { + FUN_00435320(); + operator_delete(pvVar6); + } + FUN_004011b0(); + } + } + return; +} + + + +// --- FUN_00436830 at 0x00436830 (size: 355) --- + +void FUN_00436830(int *param_1) + +{ + void *pvVar1; + char cVar2; + int iVar3; + LONG LVar4; + undefined4 *puVar5; + char *pcVar6; + char *local_c; + void *local_8; + undefined1 local_4 [4]; + + if (DAT_008380c8 == (void *)0x0) { + iVar3 = FUN_005df0f5(0x8100); + if (iVar3 == 0) { + DAT_008380c8 = (void *)0x0; + } + else { + DAT_008380c8 = (void *)FUN_00433d20(); + } + } + cVar2 = FUN_00433660(param_1,&local_8); + if (cVar2 != '\0') { + local_c = (char *)*param_1; + InterlockedIncrement((LONG *)(local_c + -0x10)); + FUN_004080c0(); + _strlwr(local_c); + if (DAT_008380c8 == (void *)0x0) { + iVar3 = FUN_005df0f5(0x8100); + if (iVar3 == 0) { + DAT_008380c8 = (void *)0x0; + } + else { + DAT_008380c8 = (void *)FUN_00433d20(); + } + } + FUN_00436520(&local_c,local_4); + if (local_8 != (void *)0x0) { + puVar5 = (undefined4 *)(*(int *)((int)local_8 + 8) + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*(int *)((int)local_8 + 8) + -0x10)); + if ((LVar4 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + puVar5 = (undefined4 *)(*(int *)((int)local_8 + 4) + -0x14); + LVar4 = InterlockedDecrement((LONG *)(*(int *)((int)local_8 + 4) + -0x10)); + if ((LVar4 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + operator_delete(local_8); + } + pcVar6 = local_c + -0x14; + local_8 = (void *)0x0; + LVar4 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar4 == 0) && (pcVar6 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar6)(1); + } + } + if ((DAT_008380c8 != (void *)0x0) && + (cVar2 = FUN_00432fa0(), pvVar1 = DAT_008380c8, cVar2 != '\0')) { + if (DAT_008380c8 != (void *)0x0) { + FUN_00433d80(); + operator_delete(pvVar1); + } + DAT_008380c8 = (void *)0x0; + } + return; +} + + + +// --- FUN_004369a0 at 0x004369A0 (size: 830) --- + +void FUN_004369a0(int param_1,int param_2,int *param_3,undefined4 param_4,int param_5,char *param_6, + int param_7,int param_8) + +{ + bool bVar1; + char cVar2; + char *pcVar3; + int iVar4; + LONG LVar5; + int *piVar6; + int *piVar7; + undefined4 *puVar8; + code *pcVar9; + int **ppiVar10; + char *pcStack_14; + int *piStack_10; + undefined *puStack_c; + int *local_8; + undefined1 auStack_4 [4]; + + if ((param_6 == (char *)0x0) || (param_7 != 0)) { + FUN_00401340(&DAT_00795098); + pcVar3 = strstr((char *)*param_3,param_6); + if (pcVar3 == (char *)0x0) { + iVar4 = -1; + } + else { + iVar4 = (int)pcVar3 - *param_3; + } + LVar5 = InterlockedDecrement((LONG *)(param_6 + -0x10)); + if ((LVar5 == 0) && (param_6 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(param_6 + -0x14))(1); + } + if (((iVar4 == -1) && (param_1 != 0)) && (param_2 != 0)) { + ppiVar10 = &local_8; + piVar7 = param_3; + FUN_00401750(param_3,ppiVar10); + cVar2 = FUN_00433710(piVar7,ppiVar10); + piVar7 = (int *)0x0; + if ((cVar2 == '\0') || + (piVar7 = (int *)(**(code **)(*local_8 + 0x3c))(), piVar7 != (int *)0x0)) { + iVar4 = FUN_005df0f5(0x2c); + if (iVar4 == 0) { + piVar6 = (int *)0x0; + } + else { + piVar6 = (int *)FUN_00435870(); + } + FUN_00402070(param_3); + FUN_00402070(param_4); + piVar6[3] = param_1; + piVar6[4] = param_2; + piVar6[5] = param_5; + *(undefined1 *)(piVar6 + 10) = 0; + if (param_6 != (char *)0x0) { + FUN_00435390(param_6); + pcVar3 = (char *)0x0; + if (param_6 != (char *)0x0) { + do { + FUN_00402070((int)pcVar3 * 4 + param_7); + pcVar3 = pcVar3 + 1; + } while (pcVar3 < param_6); + } + if (param_8 != 0) { + piVar6[9] = (int)param_6; + iVar4 = thunk_FUN_005df0f5((int)param_6 * 4); + piVar6[8] = iVar4; + pcVar3 = (char *)0x0; + if (param_6 != (char *)0x0) { + do { + *(undefined4 *)(piVar6[8] + (int)pcVar3 * 4) = + *(undefined4 *)(param_8 + (int)pcVar3 * 4); + pcVar3 = pcVar3 + 1; + } while (pcVar3 < param_6); + } + } + } + puStack_c = PTR_DAT_00818344; + bVar1 = false; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + if (piVar7 != (int *)0x0) { + *(undefined1 *)(piVar6 + 10) = 1; + (**(code **)(*piVar7 + 0x4c))(&puStack_c); + piStack_10 = (int *)*param_3; + bVar1 = true; + InterlockedIncrement(piStack_10 + -4); + FUN_004080c0(); + _strlwr((char *)piStack_10); + if (DAT_008380c8 == 0) { + iVar4 = FUN_005df0f5(0x8100); + if (iVar4 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + FUN_00436520(&piStack_10,auStack_4); + FUN_00435320(); + operator_delete(piVar7); + piVar7 = piStack_10 + -5; + LVar5 = InterlockedDecrement(piStack_10 + -4); + if ((LVar5 == 0) && (piVar7 != (int *)0x0)) { + (**(code **)*piVar7)(1); + } + } + pcStack_14 = (char *)*param_3; + InterlockedIncrement((LONG *)(pcStack_14 + -0x10)); + FUN_004080c0(); + _strlwr(pcStack_14); + piStack_10 = piVar6; + if (DAT_008380c8 == 0) { + iVar4 = FUN_005df0f5(0x8100); + if (iVar4 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar2 = FUN_0068c4c0(&pcStack_14,&piStack_10); + if (cVar2 == '\0') { + FUN_004360a0(); + operator_delete(piVar6); + pcVar9 = InterlockedDecrement_exref; + pcVar3 = pcStack_14 + -0x14; + LVar5 = InterlockedDecrement((LONG *)(pcStack_14 + -0x10)); + if ((LVar5 == 0) && (pcVar3 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar3)(1); + } + } + else { + if (bVar1) { + (**(code **)(*piVar6 + 0x50))(&puStack_c); + } + pcVar9 = InterlockedDecrement_exref; + pcVar3 = pcStack_14 + -0x14; + LVar5 = InterlockedDecrement((LONG *)(pcStack_14 + -0x10)); + if ((LVar5 == 0) && (pcVar3 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar3)(1); + } + } + puVar8 = (undefined4 *)(puStack_c + -0x14); + iVar4 = (*pcVar9)(puStack_c + -0x10); + if ((iVar4 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + } + } + } + return; +} + + + +// --- FUN_00436cf0 at 0x00436CF0 (size: 452) --- + +void FUN_00436cf0(int *param_1) + +{ + char cVar1; + int iVar2; + int *piVar3; + LONG LVar4; + char *pcVar5; + void *pvVar6; + char **ppcVar7; + void **ppvVar8; + char *pcStack_c; + int *local_8; + void *pvStack_4; + + if (DAT_008380c8 == (void *)0x0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = (void *)0x0; + } + else { + DAT_008380c8 = (void *)FUN_00433d20(); + } + } + cVar1 = FUN_00433710(param_1,&local_8); + if (cVar1 != '\0') { + piVar3 = (int *)(**(code **)(*local_8 + 0x44))(); + if (piVar3 == (int *)0x0) { + return; + } + pvVar6 = (void *)0x0; + cVar1 = (**(code **)(*piVar3 + 0x48))(); + if (cVar1 != '\0') { + iVar2 = FUN_005df0f5(0x10); + if (iVar2 == 0) { + pvVar6 = (void *)0x0; + } + else { + pvVar6 = (void *)FUN_004354b0(); + } + FUN_00402070(piVar3 + 1); + FUN_00402070(piVar3 + 2); + (**(code **)(*piVar3 + 0x4c))((int)pvVar6 + 0xc); + } + pcStack_c = (char *)*param_1; + InterlockedIncrement((LONG *)(pcStack_c + -0x10)); + FUN_004080c0(); + _strlwr(pcStack_c); + if (DAT_008380c8 == (void *)0x0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = (void *)0x0; + } + else { + DAT_008380c8 = (void *)FUN_00433d20(); + } + } + FUN_00436520(&pcStack_c,&pvStack_4); + FUN_004360a0(); + operator_delete(piVar3); + if (pvVar6 != (void *)0x0) { + ppvVar8 = &pvStack_4; + ppcVar7 = &pcStack_c; + pvStack_4 = pvVar6; + FUN_00401750(ppcVar7,ppvVar8); + cVar1 = FUN_0068c4c0(ppcVar7,ppvVar8); + if (cVar1 == '\0') { + FUN_00435320(); + operator_delete(pvVar6); + FUN_004011b0(); + return; + } + } + pcVar5 = pcStack_c + -0x14; + LVar4 = InterlockedDecrement((LONG *)(pcStack_c + -0x10)); + if ((LVar4 == 0) && (pcVar5 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar5)(1); + } + } + if ((DAT_008380c8 != (void *)0x0) && + (cVar1 = FUN_00432fa0(), pvVar6 = DAT_008380c8, cVar1 != '\0')) { + if (DAT_008380c8 != (void *)0x0) { + FUN_00433d80(); + operator_delete(pvVar6); + } + DAT_008380c8 = (void *)0x0; + } + return; +} + + + +// --- FUN_00436ec0 at 0x00436EC0 (size: 492) --- + +void FUN_00436ec0(int *param_1,undefined4 param_2) + +{ + undefined *puVar1; + char *_String; + char cVar2; + int iVar3; + int *piVar4; + int *piVar5; + LONG LVar6; + LONG *lpAddend; + int *local_8 [2]; + + if (DAT_008380c8 == 0) { + iVar3 = FUN_005df0f5(); + if (iVar3 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar2 = FUN_00433710(param_1,local_8); + if ((cVar2 != '\0') && (iVar3 = (**(code **)(*local_8[0] + 0x34))(), iVar3 != 0)) { + piVar4 = (int *)(**(code **)(*local_8[0] + 0x34))(); + piVar5 = (int *)(**(code **)(*piVar4 + 0x44))(); + if ((piVar5 != (int *)0x0) && (cVar2 = (**(code **)(*piVar5 + 0x48))(), cVar2 == '\0')) { + *(undefined1 *)(piVar5 + 10) = 1; + } + (**(code **)(*piVar4 + 0x50))(param_2); + return; + } + iVar3 = FUN_005df0f5(0x10); + if (iVar3 == 0) { + piVar4 = (int *)0x0; + } + else { + piVar4 = (int *)FUN_004354b0(); + } + iVar3 = piVar4[1]; + if (iVar3 != *param_1) { + LVar6 = InterlockedDecrement((LONG *)(iVar3 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(iVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar3 + -0x14))(1); + } + iVar3 = *param_1; + piVar4[1] = iVar3; + InterlockedIncrement((LONG *)(iVar3 + -0x10)); + } + puVar1 = (undefined *)piVar4[2]; + if (puVar1 != PTR_DAT_00818344) { + LVar6 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + piVar4[2] = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + (**(code **)(*piVar4 + 0x50))(param_2); + _String = (char *)*param_1; + InterlockedIncrement((LONG *)(_String + -0x10)); + FUN_004080c0(); + _strlwr(_String); + local_8[0] = piVar4; + if (DAT_008380c8 == 0) { + iVar3 = FUN_005df0f5(0x8100); + if (iVar3 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar2 = FUN_0068c4c0(&stack0xfffffff0,local_8); + if (cVar2 == '\0') { + FUN_00435320(); + operator_delete(piVar4); + LVar6 = InterlockedDecrement((LONG *)(_String + -0x10)); + if ((LVar6 == 0) && (_String + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(_String + -0x14))(1); + return; + } + } + else { + LVar6 = InterlockedDecrement((LONG *)(_String + -0x10)); + if ((LVar6 == 0) && (_String + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(_String + -0x14))(1); + } + } + return; +} + + + +// --- thunk_FUN_00436cf0 at 0x004370B0 (size: 5) --- + +void thunk_FUN_00436cf0(int *param_1) + +{ + char cVar1; + int iVar2; + int *piVar3; + LONG LVar4; + char *pcVar5; + void *pvVar6; + char **ppcVar7; + void **ppvVar8; + char *pcStack_c; + int *piStack_8; + void *pvStack_4; + + if (DAT_008380c8 == (void *)0x0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = (void *)0x0; + } + else { + DAT_008380c8 = (void *)FUN_00433d20(); + } + } + cVar1 = FUN_00433710(param_1,&piStack_8); + if (cVar1 != '\0') { + piVar3 = (int *)(**(code **)(*piStack_8 + 0x44))(); + if (piVar3 == (int *)0x0) { + return; + } + pvVar6 = (void *)0x0; + cVar1 = (**(code **)(*piVar3 + 0x48))(); + if (cVar1 != '\0') { + iVar2 = FUN_005df0f5(0x10); + if (iVar2 == 0) { + pvVar6 = (void *)0x0; + } + else { + pvVar6 = (void *)FUN_004354b0(); + } + FUN_00402070(piVar3 + 1); + FUN_00402070(piVar3 + 2); + (**(code **)(*piVar3 + 0x4c))((int)pvVar6 + 0xc); + } + pcStack_c = (char *)*param_1; + InterlockedIncrement((LONG *)(pcStack_c + -0x10)); + FUN_004080c0(); + _strlwr(pcStack_c); + if (DAT_008380c8 == (void *)0x0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = (void *)0x0; + } + else { + DAT_008380c8 = (void *)FUN_00433d20(); + } + } + FUN_00436520(&pcStack_c,&pvStack_4); + FUN_004360a0(); + operator_delete(piVar3); + if (pvVar6 != (void *)0x0) { + ppvVar8 = &pvStack_4; + ppcVar7 = &pcStack_c; + pvStack_4 = pvVar6; + FUN_00401750(ppcVar7,ppvVar8); + cVar1 = FUN_0068c4c0(ppcVar7,ppvVar8); + if (cVar1 == '\0') { + FUN_00435320(); + operator_delete(pvVar6); + FUN_004011b0(); + return; + } + } + pcVar5 = pcStack_c + -0x14; + LVar4 = InterlockedDecrement((LONG *)(pcStack_c + -0x10)); + if ((LVar4 == 0) && (pcVar5 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar5)(1); + } + } + if ((DAT_008380c8 != (void *)0x0) && + (cVar1 = FUN_00432fa0(), pvVar6 = DAT_008380c8, cVar1 != '\0')) { + if (DAT_008380c8 != (void *)0x0) { + FUN_00433d80(); + operator_delete(pvVar6); + } + DAT_008380c8 = (void *)0x0; + } + return; +} + + + +// --- FUN_004370c0 at 0x004370C0 (size: 114) --- + +undefined4 FUN_004370c0(undefined4 param_1,int param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + int *local_4; + + if (DAT_008380c8 == 0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar1 = FUN_00433710(param_1,&local_4); + if ((((cVar1 != '\0') && (piVar3 = (int *)(**(code **)(*local_4 + 0x44))(), piVar3 != (int *)0x0)) + && (cVar1 = (**(code **)(*piVar3 + 0x48))(), cVar1 != '\0')) && + ((param_2 == 0 || (piVar3[4] == param_2)))) { + return 1; + } + return 0; +} + + + +// --- FUN_00437140 at 0x00437140 (size: 113) --- + +undefined4 FUN_00437140(undefined4 param_1,int *param_2) + +{ + int *piVar1; + char cVar2; + int iVar3; + int *piVar4; + + piVar1 = param_2; + *param_2 = 0; + if (DAT_008380c8 == 0) { + iVar3 = FUN_005df0f5(0x8100); + if (iVar3 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar2 = FUN_00433710(param_1,¶m_2); + if (cVar2 != '\0') { + piVar4 = (int *)(**(code **)(*param_2 + 0x34))(); + if ((piVar4 != (int *)0x0) && (cVar2 = (**(code **)(*piVar4 + 0x48))(), cVar2 != '\0')) { + *piVar1 = (int)piVar4; + return 1; + } + } + return 0; +} + + + +// --- FUN_004371c0 at 0x004371C0 (size: 181) --- + +bool FUN_004371c0(undefined4 param_1,undefined1 *param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + bool bVar4; + int *piStack_8; + int *local_4; + + if (DAT_008380c8 == 0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar1 = FUN_00433710(param_1,&local_4); + if (cVar1 != '\0') { + piVar3 = (int *)(**(code **)(*local_4 + 0x44))(); + if (((piVar3 != (int *)0x0) && (cVar1 = (**(code **)(*piVar3 + 0x48))(), cVar1 != '\0')) && + (piVar3[4] == 2)) { + piStack_8 = (int *)0x0; + cVar1 = FUN_00437140(param_1,&piStack_8); + bVar4 = false; + if (cVar1 != '\0') { + iVar2 = (**(code **)(*piStack_8 + 0x44))(); + bVar4 = iVar2 != 0; + if (((bVar4) && (iVar2 != 0)) && (*(int *)(iVar2 + 0x10) == 2)) { + *param_2 = **(undefined1 **)(iVar2 + 0xc); + } + } + return bVar4; + } + } + return false; +} + + + +// --- FUN_00437280 at 0x00437280 (size: 181) --- + +bool FUN_00437280(undefined4 param_1,undefined4 *param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + bool bVar4; + int *piStack_8; + int *local_4; + + if (DAT_008380c8 == 0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar1 = FUN_00433710(param_1,&local_4); + if (cVar1 != '\0') { + piVar3 = (int *)(**(code **)(*local_4 + 0x44))(); + if (((piVar3 != (int *)0x0) && (cVar1 = (**(code **)(*piVar3 + 0x48))(), cVar1 != '\0')) && + (piVar3[4] == 3)) { + piStack_8 = (int *)0x0; + cVar1 = FUN_00437140(param_1,&piStack_8); + bVar4 = false; + if (cVar1 != '\0') { + iVar2 = (**(code **)(*piStack_8 + 0x44))(); + bVar4 = iVar2 != 0; + if (((bVar4) && (iVar2 != 0)) && (*(int *)(iVar2 + 0x10) == 3)) { + *param_2 = **(undefined4 **)(iVar2 + 0xc); + } + } + return bVar4; + } + } + return false; +} + + + +// --- FUN_00437340 at 0x00437340 (size: 181) --- + +bool FUN_00437340(undefined4 param_1,undefined4 *param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + bool bVar4; + int *piStack_8; + int *local_4; + + if (DAT_008380c8 == 0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar1 = FUN_00433710(param_1,&local_4); + if (cVar1 != '\0') { + piVar3 = (int *)(**(code **)(*local_4 + 0x44))(); + if (((piVar3 != (int *)0x0) && (cVar1 = (**(code **)(*piVar3 + 0x48))(), cVar1 != '\0')) && + (piVar3[4] == 4)) { + piStack_8 = (int *)0x0; + cVar1 = FUN_00437140(param_1,&piStack_8); + bVar4 = false; + if (cVar1 != '\0') { + iVar2 = (**(code **)(*piStack_8 + 0x44))(); + bVar4 = iVar2 != 0; + if (((bVar4) && (iVar2 != 0)) && (*(int *)(iVar2 + 0x10) == 4)) { + *param_2 = **(undefined4 **)(iVar2 + 0xc); + } + } + return bVar4; + } + } + return false; +} + + + +// --- FUN_00437400 at 0x00437400 (size: 181) --- + +bool FUN_00437400(undefined4 param_1,undefined4 *param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + bool bVar4; + int *piStack_8; + int *local_4; + + if (DAT_008380c8 == 0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar1 = FUN_00433710(param_1,&local_4); + if (cVar1 != '\0') { + piVar3 = (int *)(**(code **)(*local_4 + 0x44))(); + if (((piVar3 != (int *)0x0) && (cVar1 = (**(code **)(*piVar3 + 0x48))(), cVar1 != '\0')) && + (piVar3[4] == 9)) { + piStack_8 = (int *)0x0; + cVar1 = FUN_00437140(param_1,&piStack_8); + bVar4 = false; + if (cVar1 != '\0') { + iVar2 = (**(code **)(*piStack_8 + 0x44))(); + bVar4 = iVar2 != 0; + if (((bVar4) && (iVar2 != 0)) && (*(int *)(iVar2 + 0x10) == 9)) { + *param_2 = **(undefined4 **)(iVar2 + 0xc); + } + } + return bVar4; + } + } + return false; +} + + + +// --- FUN_004374c0 at 0x004374C0 (size: 70) --- + +void __fastcall FUN_004374c0(int *param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)(param_1[1] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[1] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(*param_1 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*param_1 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return; +} + + + +// --- FUN_00437510 at 0x00437510 (size: 204) --- + +undefined4 FUN_00437510(int *param_1) + +{ + char cVar1; + LONG LVar2; + undefined4 *puVar3; + undefined *local_4; + + local_4 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + cVar1 = FUN_0040dc00(param_1,&local_4); + if ((cVar1 == '\0') && (local_4 != (undefined *)*param_1)) { + puVar3 = (undefined4 *)(local_4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + local_4 = (undefined *)*param_1; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + } + thunk_FUN_0040da10(&local_4,0); + if (DAT_00838188 != local_4) { + puVar3 = (undefined4 *)(DAT_00838188 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(DAT_00838188 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + DAT_00838188 = local_4; + InterlockedIncrement((LONG *)(local_4 + -0x10)); + } + puVar3 = (undefined4 *)(local_4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + return 1; +} + + + +// --- FUN_004375e0 at 0x004375E0 (size: 92) --- + +void __thiscall FUN_004375e0(int param_1,undefined4 *param_2) + +{ + LONG LVar1; + undefined4 *puVar2; + + if ((*(int *)(param_1 + 0x10) == 3) && + (**(undefined4 **)(param_1 + 0xc) = *param_2, *(int *)(param_1 + 0x14) != 0)) { + param_2 = *(undefined4 **)(param_1 + 4); + InterlockedIncrement((LONG *)((int)param_2 + -0x10)); + (**(code **)(param_1 + 0x14))(¶m_2); + puVar2 = (undefined4 *)((int)param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)((int)param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + } + return; +} + + + +// --- FUN_00437640 at 0x00437640 (size: 92) --- + +void __thiscall FUN_00437640(int param_1,undefined4 *param_2) + +{ + LONG LVar1; + undefined4 *puVar2; + + if ((*(int *)(param_1 + 0x10) == 4) && + (**(undefined4 **)(param_1 + 0xc) = *param_2, *(int *)(param_1 + 0x14) != 0)) { + param_2 = *(undefined4 **)(param_1 + 4); + InterlockedIncrement((LONG *)((int)param_2 + -0x10)); + (**(code **)(param_1 + 0x14))(¶m_2); + puVar2 = (undefined4 *)((int)param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)((int)param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + } + return; +} + + + +// --- FUN_004376a0 at 0x004376A0 (size: 92) --- + +void __thiscall FUN_004376a0(int param_1,undefined4 *param_2) + +{ + LONG LVar1; + undefined4 *puVar2; + + if ((*(int *)(param_1 + 0x10) == 9) && + (**(undefined4 **)(param_1 + 0xc) = *param_2, *(int *)(param_1 + 0x14) != 0)) { + param_2 = *(undefined4 **)(param_1 + 4); + InterlockedIncrement((LONG *)((int)param_2 + -0x10)); + (**(code **)(param_1 + 0x14))(¶m_2); + puVar2 = (undefined4 *)((int)param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)((int)param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + } + return; +} + + + +// --- FUN_00437700 at 0x00437700 (size: 151) --- + +void __thiscall FUN_00437700(int param_1,int *param_2) + +{ + int *piVar1; + int iVar2; + int *piVar3; + LONG LVar4; + undefined4 *puVar5; + + piVar3 = param_2; + if (*(int *)(param_1 + 0x10) == 0xd) { + piVar1 = *(int **)(param_1 + 0xc); + iVar2 = *piVar1; + if (iVar2 != *param_2) { + LVar4 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar2 = *piVar3; + *piVar1 = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + } + if (*(int *)(param_1 + 0x14) != 0) { + param_2 = *(int **)(param_1 + 4); + InterlockedIncrement((LONG *)((int)param_2 + -0x10)); + (**(code **)(param_1 + 0x14))(¶m_2); + puVar5 = (undefined4 *)((int)param_2 + -0x14); + LVar4 = InterlockedDecrement((LONG *)((int)param_2 + -0x10)); + if ((LVar4 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + } + } + return; +} + + + +// --- FUN_004377a0 at 0x004377A0 (size: 76) --- + +void __thiscall FUN_004377a0(int param_1,int *param_2) + +{ + int iVar1; + int *piVar2; + LONG LVar3; + + if (*(int *)(param_1 + 0x10) == 0xd) { + iVar1 = *param_2; + piVar2 = *(int **)(param_1 + 0xc); + if (iVar1 != *piVar2) { + LVar3 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *piVar2; + *param_2 = iVar1; + /* WARNING: Could not recover jumptable at 0x004377e1. Too many branches */ + /* WARNING: Treating indirect jump as call */ + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + return; + } + } + return; +} + + + +// --- FUN_004377f0 at 0x004377F0 (size: 157) --- + +void * __thiscall FUN_004377f0(void *param_1,byte param_2) + +{ + int *piVar1; + LONG LVar2; + undefined4 *puVar3; + int *piVar4; + int local_4; + + if ((param_2 & 2) == 0) { + FUN_004374c0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; + } + local_4 = *(int *)((int)param_1 + -4); + piVar4 = (int *)((int)param_1 + local_4 * 8); + if (-1 < local_4 + -1) { + do { + piVar1 = piVar4 + -1; + piVar4 = piVar4 + -2; + puVar3 = (undefined4 *)(*piVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(*piVar1 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + puVar3 = (undefined4 *)(*piVar4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(*piVar4 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + local_4 = local_4 + -1; + } while (local_4 != 0); + } + if ((param_2 & 1) != 0) { + operator_delete__((void *)((int)param_1 + -4)); + } + return (void *)((int)param_1 + -4); +} + + + +// --- FUN_00437890 at 0x00437890 (size: 119) --- + +int * __thiscall FUN_00437890(int *param_1,int *param_2) + +{ + int iVar1; + LONG LVar2; + + iVar1 = *param_1; + if (iVar1 != *param_2) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *param_2; + *param_1 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + iVar1 = param_1[1]; + if (iVar1 != param_2[1]) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = param_2[1]; + param_1[1] = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + return param_1; +} + + + +// --- FUN_00437940 at 0x00437940 (size: 217) --- + +void __fastcall FUN_00437940(int *param_1) + +{ + uint uVar1; + LONG LVar2; + undefined4 *puVar3; + undefined *local_8; + undefined *local_4; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) != 0x80000000) { + if (*param_1 != 0) { + uVar1 = param_1[1] & 0x7fffffff; + while (uVar1 = uVar1 - 1, -1 < (int)uVar1) { + local_8 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + local_4 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00437890(&local_8); + puVar3 = (undefined4 *)(local_4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + puVar3 = (undefined4 *)(local_8 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + } + } + return; + } + if (*param_1 != 0) { + FUN_004377f0(3); + } + *param_1 = 0; + param_1[1] = 0; + return; +} + + + +// --- FUN_00437a20 at 0x00437A20 (size: 179) --- + +bool FUN_00437a20(undefined4 param_1) + +{ + char cVar1; + int iVar2; + int *piVar3; + bool bVar4; + int *piStack_8; + int *local_4; + + if (DAT_008380c8 == 0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar1 = FUN_00433710(param_1,&local_4); + if ((((cVar1 != '\0') && (piVar3 = (int *)(**(code **)(*local_4 + 0x44))(), piVar3 != (int *)0x0)) + && (cVar1 = (**(code **)(*piVar3 + 0x48))(), cVar1 != '\0')) && (piVar3[4] == 2)) { + piStack_8 = (int *)0x0; + cVar1 = FUN_00437140(param_1,&piStack_8); + bVar4 = false; + if (cVar1 != '\0') { + iVar2 = (**(code **)(*piStack_8 + 0x44))(); + bVar4 = iVar2 != 0; + if ((bVar4) && (iVar2 != 0)) { + FUN_00432b80(&stack0x00000008); + } + } + return bVar4; + } + return false; +} + + + +// --- FUN_00437ae0 at 0x00437AE0 (size: 179) --- + +bool FUN_00437ae0(undefined4 param_1) + +{ + char cVar1; + int iVar2; + int *piVar3; + bool bVar4; + int *piStack_8; + int *local_4; + + if (DAT_008380c8 == 0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar1 = FUN_00433710(param_1,&local_4); + if ((((cVar1 != '\0') && (piVar3 = (int *)(**(code **)(*local_4 + 0x44))(), piVar3 != (int *)0x0)) + && (cVar1 = (**(code **)(*piVar3 + 0x48))(), cVar1 != '\0')) && (piVar3[4] == 3)) { + piStack_8 = (int *)0x0; + cVar1 = FUN_00437140(param_1,&piStack_8); + bVar4 = false; + if (cVar1 != '\0') { + iVar2 = (**(code **)(*piStack_8 + 0x44))(); + bVar4 = iVar2 != 0; + if ((bVar4) && (iVar2 != 0)) { + FUN_004375e0(&stack0x00000008); + } + } + return bVar4; + } + return false; +} + + + +// --- FUN_00437ba0 at 0x00437BA0 (size: 179) --- + +bool FUN_00437ba0(undefined4 param_1) + +{ + char cVar1; + int iVar2; + int *piVar3; + bool bVar4; + int *piStack_8; + int *local_4; + + if (DAT_008380c8 == 0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar1 = FUN_00433710(param_1,&local_4); + if ((((cVar1 != '\0') && (piVar3 = (int *)(**(code **)(*local_4 + 0x44))(), piVar3 != (int *)0x0)) + && (cVar1 = (**(code **)(*piVar3 + 0x48))(), cVar1 != '\0')) && (piVar3[4] == 4)) { + piStack_8 = (int *)0x0; + cVar1 = FUN_00437140(param_1,&piStack_8); + bVar4 = false; + if (cVar1 != '\0') { + iVar2 = (**(code **)(*piStack_8 + 0x44))(); + bVar4 = iVar2 != 0; + if ((bVar4) && (iVar2 != 0)) { + FUN_00437640(&stack0x00000008); + } + } + return bVar4; + } + return false; +} + + + +// --- FUN_00437c60 at 0x00437C60 (size: 179) --- + +bool FUN_00437c60(undefined4 param_1) + +{ + char cVar1; + int iVar2; + int *piVar3; + bool bVar4; + int *piStack_8; + int *local_4; + + if (DAT_008380c8 == 0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar1 = FUN_00433710(param_1,&local_4); + if ((((cVar1 != '\0') && (piVar3 = (int *)(**(code **)(*local_4 + 0x44))(), piVar3 != (int *)0x0)) + && (cVar1 = (**(code **)(*piVar3 + 0x48))(), cVar1 != '\0')) && (piVar3[4] == 9)) { + piStack_8 = (int *)0x0; + cVar1 = FUN_00437140(param_1,&piStack_8); + bVar4 = false; + if (cVar1 != '\0') { + iVar2 = (**(code **)(*piStack_8 + 0x44))(); + bVar4 = iVar2 != 0; + if ((bVar4) && (iVar2 != 0)) { + FUN_004376a0(&stack0x00000008); + } + } + return bVar4; + } + return false; +} + + + +// --- FUN_00437d20 at 0x00437D20 (size: 179) --- + +bool FUN_00437d20(undefined4 param_1,undefined4 param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + bool bVar4; + int *piStack_8; + int *local_4; + + if (DAT_008380c8 == 0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar1 = FUN_00433710(param_1,&local_4); + if ((((cVar1 != '\0') && (piVar3 = (int *)(**(code **)(*local_4 + 0x44))(), piVar3 != (int *)0x0)) + && (cVar1 = (**(code **)(*piVar3 + 0x48))(), cVar1 != '\0')) && (piVar3[4] == 0xd)) { + piStack_8 = (int *)0x0; + cVar1 = FUN_00437140(param_1,&piStack_8); + bVar4 = false; + if (cVar1 != '\0') { + iVar2 = (**(code **)(*piStack_8 + 0x44))(); + bVar4 = iVar2 != 0; + if ((bVar4) && (iVar2 != 0)) { + FUN_00437700(param_2); + } + } + return bVar4; + } + return false; +} + + + +// --- FUN_00437de0 at 0x00437DE0 (size: 179) --- + +bool FUN_00437de0(undefined4 param_1,undefined4 param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + bool bVar4; + int *piStack_8; + int *local_4; + + if (DAT_008380c8 == 0) { + iVar2 = FUN_005df0f5(0x8100); + if (iVar2 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar1 = FUN_00433710(param_1,&local_4); + if ((((cVar1 != '\0') && (piVar3 = (int *)(**(code **)(*local_4 + 0x44))(), piVar3 != (int *)0x0)) + && (cVar1 = (**(code **)(*piVar3 + 0x48))(), cVar1 != '\0')) && (piVar3[4] == 0xd)) { + piStack_8 = (int *)0x0; + cVar1 = FUN_00437140(param_1,&piStack_8); + bVar4 = false; + if (cVar1 != '\0') { + iVar2 = (**(code **)(*piStack_8 + 0x44))(); + bVar4 = iVar2 != 0; + if ((bVar4) && (iVar2 != 0)) { + FUN_004377a0(param_2); + } + } + return bVar4; + } + return false; +} + + + +// --- FUN_00437ea0 at 0x00437EA0 (size: 191) --- + +undefined4 __thiscall FUN_00437ea0(int *param_1,uint param_2) + +{ + uint *puVar1; + int iVar2; + uint *puVar3; + + if ((uint)param_1[2] <= param_2) { + if (param_2 <= (param_1[1] & 0x7fffffffU)) { + return 1; + } + if (param_2 == 0) { + FUN_00437940(); + return 1; + } + puVar3 = (uint *)thunk_FUN_005df0f5(param_2 * 8 + 4); + if (puVar3 != (uint *)0x0) { + puVar1 = puVar3 + 1; + *puVar3 = param_2; + FUN_00401000(puVar1,8,param_2,&LAB_00437910); + if (puVar1 != (uint *)0x0) { + if (*param_1 != 0) { + iVar2 = param_1[2]; + while (iVar2 = iVar2 + -1, -1 < iVar2) { + FUN_00437890(*param_1 + iVar2 * 8); + } + if (((param_1[1] & 0x80000000U) == 0x80000000) && (*param_1 != 0)) { + FUN_004377f0(3); + } + } + *param_1 = (int)puVar1; + param_1[1] = param_2 | 0x80000000; + return 1; + } + } + } + return 0; +} + + + +// --- FUN_00437f60 at 0x00437F60 (size: 125) --- + +void FUN_00437f60(void) + +{ + LONG LVar1; + undefined4 *puVar2; + int local_4; + + FUN_00401340("LoadPreferences"); + FUN_00436830(&local_4); + puVar2 = (undefined4 *)(local_4 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("SavePreferences"); + FUN_00436830(&local_4); + LVar1 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + return; +} + + + +// --- FUN_00437fe0 at 0x00437FE0 (size: 578) --- + +undefined1 FUN_00437fe0(int *param_1) + +{ + undefined *puVar1; + undefined1 uVar2; + LONG LVar3; + int iVar4; + LONG *lpAddend; + int unaff_EBX; + undefined4 *puVar5; + code *pcVar6; + undefined *local_14; + int local_10; + undefined *local_c; + undefined *local_8; + int local_4; + + FUN_00401340("UserPreferences.ini"); + local_14 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + if (*(int *)(DAT_00838188 + -4) == 1) { + if ((DAT_00818afc == '\0') || (DAT_00837cd0 == '\0')) { + local_c = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_0040c230(&local_4); + thunk_FUN_0040c780(&local_c,&local_4); + FUN_00402710(&local_14,&DAT_00799b90,local_c,local_10); + thunk_FUN_0040da10(&local_14,0); + pcVar6 = InterlockedDecrement_exref; + puVar1 = (undefined *)*param_1; + if (puVar1 != local_14) { + LVar3 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + *param_1 = (int)local_14; + InterlockedIncrement((LONG *)(local_14 + -0x10)); + } + uVar2 = FUN_0040b320(&local_14,0); + LVar3 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + local_8 = local_c; + if ((LVar3 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + local_8 = local_c; + } + } + else { + FUN_00423430(&local_8,&DAT_00838168); + FUN_00402710(&local_14,"%s\\%s",local_8,local_10); + thunk_FUN_0040da10(&local_14,0); + FUN_00402070(&local_14); + uVar2 = FUN_0040b320(&local_14,0); + pcVar6 = InterlockedDecrement_exref; + } + iVar4 = (*pcVar6)(local_8 + -0x10); + if ((iVar4 == 0) && ((undefined4 *)(local_8 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_8 + -0x14))(1); + } + iVar4 = (*pcVar6)(unaff_EBX + -0x10); + if ((iVar4 == 0) && ((undefined4 *)(unaff_EBX + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(unaff_EBX + -0x14))(1); + } + iVar4 = (*pcVar6)(unaff_EBX + -0x10); + local_10 = unaff_EBX; + } + else { + iVar4 = *param_1; + if (iVar4 != DAT_00838188) { + LVar3 = InterlockedDecrement((LONG *)(iVar4 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(iVar4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar4 + -0x14))(1); + } + lpAddend = (LONG *)(DAT_00838188 + -0x10); + *param_1 = DAT_00838188; + InterlockedIncrement(lpAddend); + } + uVar2 = FUN_0040b320(param_1,0); + puVar5 = (undefined4 *)(local_14 + -0x14); + LVar3 = InterlockedDecrement((LONG *)(local_14 + -0x10)); + if ((LVar3 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + iVar4 = InterlockedDecrement((LONG *)(local_10 + -0x10)); + } + if ((iVar4 == 0) && ((undefined4 *)(local_10 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_10 + -0x14))(1); + } + return uVar2; +} + + + +// --- FUN_00438230 at 0x00438230 (size: 1155) --- + +undefined1 FUN_00438230(void) + +{ + uint uVar1; + uint uVar2; + undefined *puVar3; + char cVar4; + char cVar5; + LONG LVar6; + int iVar7; + int *piVar8; + int iVar9; + undefined4 uVar10; + int *piVar11; + uint uVar12; + uint uVar13; + code *pcVar14; + undefined4 *puVar15; + int iVar16; + LPCSTR lpKeyName; + LPCSTR pCVar17; + LPCSTR pCVar18; + undefined4 uStack_3c; + LPCSTR pCStack_38; + LPCSTR local_34; + undefined *local_30; + uint uStack_2c; + LPCSTR pCStack_28; + int *piStack_24; + int iStack_20; + int iStack_1c; + void *local_18; + uint local_14; + uint local_10; + undefined1 auStack_c [12]; + + local_34 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + cVar4 = FUN_00437fe0(&local_34); + uStack_3c = (LPCSTR)CONCAT13(cVar4,(undefined3)uStack_3c); + if (cVar4 == '\0') { + uStack_3c._3_1_ = 0; + if (*(int *)(local_34 + -4) == 1) goto LAB_0043868f; + local_30 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + cVar5 = thunk_FUN_0040c780(&local_30,&local_34); + cVar4 = '\0'; + if (cVar5 != '\0') { + cVar4 = thunk_FUN_0040df20(&local_30); + } + uStack_3c = (LPCSTR)CONCAT13(cVar4,(undefined3)uStack_3c); + puVar15 = (undefined4 *)(local_30 + -0x14); + LVar6 = InterlockedDecrement((LONG *)(local_30 + -0x10)); + if ((LVar6 == 0) && (puVar15 != (undefined4 *)0x0)) { + (**(code **)*puVar15)(1); + } + if (cVar4 != '\0') goto LAB_004382d9; + } + else { +LAB_004382d9: + local_18 = (void *)0x0; + local_14 = 0; + local_10 = 0; + if (DAT_008380c8 == 0) { + iVar7 = FUN_005df0f5(0x8100); + if (iVar7 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + piVar8 = (int *)FUN_0052dcf0(auStack_c); + iVar7 = *piVar8; + piVar11 = (int *)piVar8[1]; + iVar16 = piVar8[2]; + if (DAT_008380c8 == 0) { + iVar9 = FUN_005df0f5(0x8100); + if (iVar9 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + while (iVar16 != 0) { + do { + piVar8 = (int *)(**(code **)(**(int **)(iVar16 + 8) + 0x30))(); + if ((piVar8 != (int *)0x0) && (cVar4 = (**(code **)(*piVar8 + 0x48))(), cVar4 != '\0')) { + if ((local_14 & 0x7fffffff) <= local_10) { + uVar10 = FUN_00453850((local_14 & 0x7fffffff) + 1); + cVar4 = FUN_004180a0(uVar10); + if (cVar4 == '\0') goto LAB_004383b3; + } + *(int **)((int)local_18 + local_10 * 4) = piVar8; + local_10 = local_10 + 1; + } +LAB_004383b3: + iVar16 = *(int *)(iVar16 + 4); + } while (iVar16 != 0); + do { + piVar11 = piVar11 + 1; + if (piVar11 == (int *)(*(int *)(iVar7 + 0x60) + *(int *)(iVar7 + 0x68) * 4)) + goto LAB_004383d6; + iVar16 = *piVar11; + } while (iVar16 == 0); + } +LAB_004383d6: + uStack_2c = 0; + if (local_10 != 0) { + do { + piStack_24 = *(int **)((int)local_18 + uStack_2c * 4); + if (piStack_24 != (int *)0x0) { + pCVar17 = (LPCSTR)piStack_24[1]; + pCStack_28 = pCVar17; + InterlockedIncrement((LONG *)(pCVar17 + -0x10)); + lpKeyName = PTR_DAT_00818344; + uVar1 = *(uint *)(pCVar17 + -4); + if (uVar1 < 2) { + iVar7 = InterlockedDecrement((LONG *)(pCVar17 + -0x10)); + } + else { + for (uVar12 = uVar1 - 2; uVar13 = 0xffffffff, -1 < (int)uVar12; uVar12 = uVar12 - 1) { + uVar2 = uVar1 - 1; + if (uVar12 < uVar1) { + uVar2 = uVar12; + } + uVar13 = uVar12; + if (pCVar17[uVar2] == '.') break; + } + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + puVar3 = PTR_DAT_00818344; + pCStack_38 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + if ((int)uVar13 < 1) { + if (lpKeyName != pCVar17) { + LVar6 = InterlockedDecrement((LONG *)(lpKeyName + -0x10)); + if ((LVar6 == 0) && (lpKeyName + -0x14 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)(lpKeyName + -0x14))(1); + } + InterlockedIncrement((LONG *)(pCVar17 + -0x10)); + lpKeyName = pCVar17; + } + FUN_00405000("Default"); + pcVar14 = InterlockedDecrement_exref; +LAB_004385a2: + local_30 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + (**(code **)(*piStack_24 + 0x4c))(&local_30); + WritePrivateProfileStringA(uStack_3c,lpKeyName,local_34,pCStack_38); + pCVar18 = local_34 + -0x14; + iVar7 = (*pcVar14)(local_34 + -0x10); + if ((iVar7 == 0) && (pCVar18 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)pCVar18)(1); + } + } + else { + pcVar14 = InterlockedDecrement_exref; + if ((int)uVar13 < *(int *)(pCVar17 + -4) + -2) { + piVar11 = (int *)FUN_00404f80(&iStack_20,uVar13 + 1,*(int *)(pCVar17 + -4) + -2); + if (lpKeyName != (undefined *)*piVar11) { + LVar6 = InterlockedDecrement((LONG *)(lpKeyName + -0x10)); + if ((LVar6 == 0) && (lpKeyName + -0x14 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)(lpKeyName + -0x14))(1); + } + lpKeyName = (LPCSTR)*piVar11; + InterlockedIncrement((LONG *)(lpKeyName + -0x10)); + } + puVar15 = (undefined4 *)(iStack_20 + -0x14); + LVar6 = InterlockedDecrement((LONG *)(iStack_20 + -0x10)); + if ((LVar6 == 0) && (puVar15 != (undefined4 *)0x0)) { + (**(code **)*puVar15)(1); + } + piVar11 = (int *)FUN_00404f80(&iStack_1c,0,uVar13 - 1); + if (puVar3 != (undefined *)*piVar11) { + LVar6 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(puVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar3 + -0x14))(1); + } + pCStack_38 = (LPCSTR)*piVar11; + InterlockedIncrement((LONG *)(pCStack_38 + -0x10)); + } + pcVar14 = InterlockedDecrement_exref; + puVar15 = (undefined4 *)(iStack_1c + -0x14); + LVar6 = InterlockedDecrement((LONG *)(iStack_1c + -0x10)); + if ((LVar6 == 0) && (puVar15 != (undefined4 *)0x0)) { + (**(code **)*puVar15)(1); + } + goto LAB_004385a2; + } + } + iVar7 = (*pcVar14)(pCStack_38 + -0x10); + if ((iVar7 == 0) && (pCStack_38 + -0x14 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)(pCStack_38 + -0x14))(1); + } + iVar7 = (*pcVar14)(lpKeyName + -0x10); + if ((iVar7 == 0) && (lpKeyName + -0x14 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)(lpKeyName + -0x14))(1); + } + iVar7 = (*pcVar14)(pCVar17 + -0x10); + } + if ((iVar7 == 0) && (pCVar17 + -0x14 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)(pCVar17 + -0x14))(1); + } + } + uStack_2c = uStack_2c + 1; + } while (uStack_2c < local_10); + } + if ((local_14 & 0x80000000) == 0x80000000) { + operator_delete__(local_18); + } + } +LAB_0043868f: + pCVar17 = local_34 + -0x14; + LVar6 = InterlockedDecrement((LONG *)(local_34 + -0x10)); + if ((LVar6 == 0) && (pCVar17 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)pCVar17)(1); + } + return uStack_3c._3_1_; +} + + + +// --- FUN_00438750 at 0x00438750 (size: 260) --- + +bool FUN_00438750(undefined4 param_1,int *param_2) + +{ + int iVar1; + char cVar2; + int iVar3; + int *piVar4; + undefined4 uVar5; + bool bVar6; + int *piStack_8; + int *local_4; + + if (DAT_008380c8 == 0) { + iVar3 = FUN_005df0f5(0x8100); + if (iVar3 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar2 = FUN_00433710(param_1,&local_4); + if ((((cVar2 == '\0') || (piVar4 = (int *)(**(code **)(*local_4 + 0x44))(), piVar4 == (int *)0x0)) + || (cVar2 = (**(code **)(*piVar4 + 0x48))(), cVar2 == '\0')) || (piVar4[4] != 4)) { + return false; + } + piStack_8 = (int *)0x0; + cVar2 = FUN_00437140(param_1,&piStack_8); + bVar6 = false; + if (cVar2 != '\0') { + iVar3 = (**(code **)(*piStack_8 + 0x44))(); + bVar6 = iVar3 != 0; + if ((bVar6) && (iVar3 != 0)) { + piStack_8 = *(int **)(iVar3 + 0x24); + piVar4 = (int *)0x0; + if (piStack_8 != (int *)0x0) { + do { + iVar1 = *(int *)(iVar3 + 0x20); + if ((uint)param_2[2] < (param_2[1] & 0x7fffffffU)) { +LAB_00438834: + *(undefined4 *)(*param_2 + param_2[2] * 4) = *(undefined4 *)(iVar1 + (int)piVar4 * 4); + param_2[2] = param_2[2] + 1; + } + else { + uVar5 = FUN_00453850((param_2[1] & 0x7fffffffU) + 1); + cVar2 = FUN_004180a0(uVar5); + if (cVar2 != '\0') goto LAB_00438834; + } + piVar4 = (int *)((int)piVar4 + 1); + } while (piVar4 < piStack_8); + } + } + } + return bVar6; +} + + + +// --- FUN_00438860 at 0x00438860 (size: 209) --- + +bool FUN_00438860(undefined4 param_1) + +{ + uint uVar1; + char cVar2; + int iVar3; + int *piVar4; + uint uVar5; + bool bVar6; + int *piStack_8; + int *local_4; + + if (DAT_008380c8 == 0) { + iVar3 = FUN_005df0f5(0x8100); + if (iVar3 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar2 = FUN_00433710(param_1,&local_4); + if (cVar2 != '\0') { + piVar4 = (int *)(**(code **)(*local_4 + 0x44))(); + if (((piVar4 != (int *)0x0) && (cVar2 = (**(code **)(*piVar4 + 0x48))(), cVar2 != '\0')) && + (piVar4[4] == 4)) { + piStack_8 = (int *)0x0; + cVar2 = FUN_00437140(param_1,&piStack_8); + bVar6 = false; + if (cVar2 != '\0') { + iVar3 = (**(code **)(*piStack_8 + 0x44))(); + bVar6 = iVar3 != 0; + if ((bVar6) && (iVar3 != 0)) { + uVar1 = *(uint *)(iVar3 + 0x1c); + uVar5 = 0; + if (uVar1 != 0) { + do { + FUN_0040c440(*(int *)(iVar3 + 0x18) + uVar5 * 4); + uVar5 = uVar5 + 1; + } while (uVar5 < uVar1); + bVar6 = true; + } + } + } + return bVar6; + } + } + return false; +} + + + +// --- FUN_00438940 at 0x00438940 (size: 1544) --- + +char FUN_00438940(void) + +{ + undefined *puVar1; + char cVar2; + char cVar3; + LPSTR pCVar4; + DWORD DVar5; + LONG LVar6; + undefined4 uVar7; + int iVar8; + LPCSTR pCVar9; + int *piVar10; + undefined4 *puVar11; + uint uVar12; + LPSTR pCVar13; + LPCSTR local_64; + undefined *local_60; + undefined *local_5c; + int local_58; + undefined *local_54; + uint local_50; + uint local_4c; + LPSTR local_48; + undefined *local_44; + undefined *local_40; + int local_3c; + uint local_38; + uint local_34; + int local_30; + uint local_2c; + uint local_28; + int local_24; + uint local_20; + uint local_1c; + undefined **local_18; + int *local_14; + undefined4 local_10; + uint local_c; + + local_64 = PTR_DAT_00818344; + DAT_00818afd = 0; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + cVar2 = FUN_00437fe0(&local_64); + if (cVar2 == '\0') { +LAB_00438e74: + pCVar9 = local_64 + -0x14; + LVar6 = InterlockedDecrement((LONG *)(local_64 + -0x10)); + if ((LVar6 == 0) && (pCVar9 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)pCVar9)(1); + } + return cVar2; + } + local_3c = 0; + local_38 = 0; + local_34 = 0; + pCVar4 = (LPSTR)thunk_FUN_005df0f5(0x4000); + pCVar13 = pCVar4; + for (iVar8 = 0x1000; iVar8 != 0; iVar8 = iVar8 + -1) { + pCVar13[0] = '\0'; + pCVar13[1] = '\0'; + pCVar13[2] = '\0'; + pCVar13[3] = '\0'; + pCVar13 = pCVar13 + 4; + } + DVar5 = GetPrivateProfileSectionNamesA(pCVar4,0x4000,local_64); + if (DVar5 == 0) { + operator_delete__(pCVar4); + if (((local_38 & 0x80000000) == 0x80000000) && (local_3c != 0)) { + FUN_004377f0(3); + } + } + else { + local_30 = 0; + local_2c = 0; + local_28 = 0; + cVar3 = FUN_0040caf0(pCVar4,DVar5,&local_30); + if (cVar3 != '\0') { + operator_delete__(pCVar4); + local_48 = (LPSTR)thunk_FUN_005df0f5(0x4000); + local_4c = 0; + if (local_28 != 0) { + do { + pCVar9 = *(LPCSTR *)(local_30 + local_4c * 4); + InterlockedIncrement((LONG *)(pCVar9 + -0x10)); + pCVar13 = local_48; + pCVar4 = local_48; + for (iVar8 = 0x1000; iVar8 != 0; iVar8 = iVar8 + -1) { + pCVar4[0] = '\0'; + pCVar4[1] = '\0'; + pCVar4[2] = '\0'; + pCVar4[3] = '\0'; + pCVar4 = pCVar4 + 4; + } + DVar5 = GetPrivateProfileSectionA(pCVar9,local_48,0x4000,local_64); + if (DVar5 != 0) { + local_24 = 0; + local_20 = 0; + local_1c = 0; + cVar3 = FUN_0040caf0(pCVar13,DVar5,&local_24); + if (cVar3 == '\0') { + operator_delete__(pCVar13); + if (((local_20 & 0x80000000) == 0x80000000) && (local_24 != 0)) { + FUN_00407920(3); + } + LVar6 = InterlockedDecrement((LONG *)(pCVar9 + -0x10)); + if ((LVar6 == 0) && (pCVar9 + -0x14 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)(pCVar9 + -0x14))(1); + } + if (((local_2c & 0x80000000) == 0x80000000) && (local_30 != 0)) { + FUN_00407920(3); + } + if (((local_38 & 0x80000000) == 0x80000000) && (local_3c != 0)) { + FUN_004377f0(3); + } + pCVar9 = local_64 + -0x14; + LVar6 = InterlockedDecrement((LONG *)(local_64 + -0x10)); + if ((LVar6 == 0) && (pCVar9 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)pCVar9)(1); + } + return '\0'; + } + local_50 = 0; + if (local_1c != 0) { + do { + local_58 = *(int *)(local_24 + local_50 * 4); + InterlockedIncrement((LONG *)(local_58 + -0x10)); + local_18 = &PTR_FUN_00795074; + local_14 = (int *)0x0; + local_10 = 0; + local_c = 0; + cVar3 = thunk_FUN_0040c2d0(&local_58,0x3d,&local_18); + if (cVar3 == '\0') { +LAB_00438d2c: + local_18 = &PTR_FUN_00795074; + FUN_00405210(); + puVar11 = (undefined4 *)(local_58 + -0x14); + LVar6 = InterlockedDecrement((LONG *)(local_58 + -0x10)); + if ((LVar6 == 0) && (puVar11 != (undefined4 *)0x0)) { + (**(code **)*puVar11)(1); + } + } + else { + local_5c = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + local_60 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + if (local_c == 2) { + FUN_00405120(&local_5c); + FUN_00405120(&local_60); +LAB_00438c05: + local_54 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + puVar1 = local_5c; + FUN_00402710(&local_54,"%s.%s",pCVar9,local_5c); + local_44 = local_54; + InterlockedIncrement((LONG *)(local_54 + -0x10)); + local_40 = local_60; + InterlockedIncrement((LONG *)(local_60 + -0x10)); + if (local_34 < (local_38 & 0x7fffffff)) { +LAB_00438c72: + FUN_00437890(&local_44); + local_34 = local_34 + 1; + } + else { + uVar7 = FUN_00453850((local_38 & 0x7fffffff) + 1); + cVar3 = FUN_00437ea0(uVar7); + if (cVar3 != '\0') goto LAB_00438c72; + } + puVar11 = (undefined4 *)(local_40 + -0x14); + LVar6 = InterlockedDecrement((LONG *)(local_40 + -0x10)); + if ((LVar6 == 0) && (puVar11 != (undefined4 *)0x0)) { + (**(code **)*puVar11)(1); + } + puVar11 = (undefined4 *)(local_44 + -0x14); + LVar6 = InterlockedDecrement((LONG *)(local_44 + -0x10)); + if ((LVar6 == 0) && (puVar11 != (undefined4 *)0x0)) { + (**(code **)*puVar11)(1); + } + puVar11 = (undefined4 *)(local_54 + -0x14); + LVar6 = InterlockedDecrement((LONG *)(local_54 + -0x10)); + if ((LVar6 == 0) && (puVar11 != (undefined4 *)0x0)) { + (**(code **)*puVar11)(1); + } + puVar11 = (undefined4 *)(local_60 + -0x14); + LVar6 = InterlockedDecrement((LONG *)(local_60 + -0x10)); + if ((LVar6 == 0) && (puVar11 != (undefined4 *)0x0)) { + (**(code **)*puVar11)(1); + } + puVar11 = (undefined4 *)(puVar1 + -0x14); + LVar6 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar6 == 0) && (puVar11 != (undefined4 *)0x0)) { + (**(code **)*puVar11)(1); + } + goto LAB_00438d2c; + } + if (2 < local_c) { + FUN_00405120(&local_5c); + for (piVar10 = local_14; piVar10 != (int *)0x0; piVar10 = (int *)piVar10[1]) { + iVar8 = *(int *)(*piVar10 + -4); + if (iVar8 != 1) { + FUN_00404ef0(*piVar10,iVar8 + -1); + } + } + goto LAB_00438c05; + } + if (local_c == 1) { + FUN_00405120(&local_5c); + FUN_00405000(&DAT_007938af); + goto LAB_00438c05; + } + FUN_004011b0(); + FUN_004011b0(); + local_18 = &PTR_FUN_00795074; + FUN_00405210(); + FUN_004011b0(); + } + local_50 = local_50 + 1; + } while (local_50 < local_1c); + } + if (((local_20 & 0x80000000) == 0x80000000) && (local_24 != 0)) { + FUN_00407920(3); + } + } + LVar6 = InterlockedDecrement((LONG *)(pCVar9 + -0x10)); + if ((LVar6 == 0) && (pCVar9 + -0x14 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)(pCVar9 + -0x14))(1); + } + local_4c = local_4c + 1; + } while (local_4c < local_28); + } + operator_delete__(local_48); + uVar12 = 0; + if (local_34 != 0) { + do { + iVar8 = local_3c + uVar12 * 8; + FUN_00436ec0(iVar8,iVar8 + 4); + uVar12 = uVar12 + 1; + } while (uVar12 < local_34); + } + if (((local_2c & 0x80000000) == 0x80000000) && (local_30 != 0)) { + FUN_00407920(3); + } + if (((local_38 & 0x80000000) == 0x80000000) && (local_3c != 0)) { + FUN_004377f0(3); + } + DAT_00818afd = 1; + goto LAB_00438e74; + } + operator_delete__(pCVar4); + if (((local_2c & 0x80000000) == 0x80000000) && (local_30 != 0)) { + FUN_00407920(3); + } + if (((local_38 & 0x80000000) == 0x80000000) && (local_3c != 0)) { + FUN_004377f0(3); + } + } + pCVar9 = local_64 + -0x14; + LVar6 = InterlockedDecrement((LONG *)(local_64 + -0x10)); + if ((LVar6 == 0) && (pCVar9 != (LPCSTR)0x0)) { + (*(code *)**(undefined4 **)pCVar9)(1); + } + return '\0'; +} + + + +// --- FUN_00438fe0 at 0x00438FE0 (size: 342) --- + +undefined1 FUN_00438fe0(int param_1,int *param_2) + +{ + undefined1 uVar1; + LONG LVar2; + undefined4 *puVar3; + int local_8; + int local_4; + + DAT_00818afc = (undefined1)param_1; + DAT_00818afd = 1; + FUN_00401340("Loads user preferences from disk"); + FUN_00401340("LoadPreferences"); + FUN_00436580(&LAB_00438f50,&local_8,&local_4); + puVar3 = (undefined4 *)(local_8 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + puVar3 = (undefined4 *)(local_4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + FUN_00401340("Saves user preferences to disk"); + FUN_00401340("SavePreferences"); + FUN_00436580(&LAB_004386c0,&local_4,&local_8); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + LVar2 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(local_8 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_8 + -0x14))(1); + } + param_1 = *param_2; + InterlockedIncrement((LONG *)(param_1 + -0x10)); + if (*(int *)(param_1 + -4) == 1) { + FUN_00437fe0(¶m_1); + } + uVar1 = FUN_00437510(¶m_1); + puVar3 = (undefined4 *)(param_1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_1 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + return uVar1; +} + + + +// --- FUN_00439140 at 0x00439140 (size: 43) --- + +void __fastcall FUN_00439140(undefined4 *param_1) + +{ + *param_1 = 0; + param_1[1] = 800; + param_1[2] = 600; + *(undefined1 *)(param_1 + 3) = 0; + param_1[4] = 0; + param_1[5] = 0x20; + *(undefined1 *)(param_1 + 6) = 0; + *(undefined1 *)((int)param_1 + 0x19) = 0; + *(undefined1 *)((int)param_1 + 0x1a) = 0; + return; +} + + + +// --- FUN_00439170 at 0x00439170 (size: 36) --- + +undefined4 * __thiscall FUN_00439170(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00799d14; + FUN_00440f40(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00439210 at 0x00439210 (size: 18) --- + +undefined4 * __fastcall FUN_00439210(undefined4 *param_1) + +{ + FUN_0040e790(); + *param_1 = &PTR_FUN_00799d18; + return param_1; +} + + + +// --- FUN_00439230 at 0x00439230 (size: 8) --- + +void FUN_00439230(void) + +{ + DAT_00838194 = 1; + return; +} + + + +// --- FUN_00439240 at 0x00439240 (size: 101) --- + +undefined4 +FUN_00439240(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4, + undefined1 *param_5) + +{ + undefined4 uVar1; + undefined4 local_1c; + undefined4 local_18; + undefined4 local_14; + undefined4 local_10; + LONG local_c; + + if ((DAT_00838196 != '\0') && (DAT_00837ff4 != (int *)0x0)) { + local_1c = param_1; + local_18 = param_2; + local_14 = param_3; + local_10 = param_4; + local_c = GetMessageTime(); + uVar1 = (**(code **)(*DAT_00837ff4 + 0x70))(&local_1c,param_5); + return uVar1; + } + *param_5 = 0; + return 0; +} + + + +// --- FUN_004392b0 at 0x004392B0 (size: 56) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_004392b0(void) + +{ + DWORD DVar1; + DWORD dwMilliseconds; + + dwMilliseconds = 0; + if (DAT_00838197 == '\0') { + DVar1 = timeGetTime(); + if (DVar1 - _DAT_00838314 < 99) { + dwMilliseconds = 99 - (DVar1 - _DAT_00838314); + } + } + Sleep(dwMilliseconds); + _DAT_00838314 = timeGetTime(); + return; +} + + + +// --- FUN_004392f0 at 0x004392F0 (size: 34) --- + +void FUN_004392f0(void) + +{ + if (DAT_00838197 == '\0') { + if (DAT_00837ff4 != (int *)0x0) { + (**(code **)(*DAT_00837ff4 + 0x74))(1); + } + DAT_00838197 = '\x01'; + } + return; +} + + + +// --- FUN_00439320 at 0x00439320 (size: 70) --- + +void FUN_00439320(void) + +{ + HCURSOR hCursor; + + if (DAT_00838197 != '\0') { + DAT_00838197 = '\0'; + if (DAT_00837ff4 != (int *)0x0) { + (**(code **)(*DAT_00837ff4 + 0x74))(0); + } + if ((DAT_00870340 == 0) || (*(char *)(DAT_00870340 + 0x10) == '\0')) { + hCursor = LoadCursorA((HINSTANCE)0x0,(LPCSTR)0x7f00); + SetCursor(hCursor); + } + } + return; +} + + + +// --- FUN_00439370 at 0x00439370 (size: 136) --- + +undefined4 FUN_00439370(int param_1) + +{ + uint uVar1; + + uVar1 = DAT_00818b64 & 0xffff; + if ((799 < DAT_00818b64 >> 0x10) && (599 < uVar1)) { + *(uint *)(param_1 + 4) = DAT_00818b64 >> 0x10; + *(uint *)(param_1 + 8) = uVar1; + *(undefined1 *)(param_1 + 0xc) = DAT_00818b68; + *(undefined4 *)(param_1 + 0x10) = DAT_00818b6c; + *(undefined1 *)(param_1 + 0x18) = DAT_00818b70; + *(undefined1 *)(param_1 + 0x19) = DAT_00818b71; + *(undefined1 *)(param_1 + 0x1a) = DAT_00818b72; + if (DAT_008381a0 != '\0') { + *(undefined4 *)(param_1 + 4) = DAT_00818b04; + *(undefined4 *)(param_1 + 8) = DAT_00818b08; + } + if (DAT_00818b02 == '\0') { + *(undefined1 *)(param_1 + 0xc) = 0; + } + return 1; + } + return 0; +} + + + +// --- FUN_00439400 at 0x00439400 (size: 82) --- + +undefined4 FUN_00439400(void) + +{ + HCURSOR hCursor; + + if (DAT_00838197 != '\0') { + DAT_00838197 = '\0'; + if (DAT_00837ff4 != (int *)0x0) { + (**(code **)(*DAT_00837ff4 + 0x74))(0); + } + if ((DAT_00870340 == 0) || (*(char *)(DAT_00870340 + 0x10) == '\0')) { + hCursor = LoadCursorA((HINSTANCE)0x0,(LPCSTR)0x7f00); + SetCursor(hCursor); + } + } + FUN_0043fdd0(); + FUN_0054d190(); + return 1; +} + + + +// --- FUN_00439460 at 0x00439460 (size: 298) --- + +int * FUN_00439460(void) + +{ + int *piVar1; + int *piVar2; + tagPOINT tStack_44; + tagRECT tStack_3c; + undefined **appuStack_2c [3]; + int iStack_20; + int iStack_1c; + int iStack_18; + int iStack_14; + + piVar1 = (int *)(**(code **)(*DAT_00870340 + 0x3c))(); + if (piVar1 == (int *)0x0) { + return (int *)0x0; + } + if ((char)DAT_00870340[4] == '\0') { + tStack_44.y = 0; + tStack_44.x = 0; + ClientToScreen(DAT_008381a4,&tStack_44); + GetClientRect(DAT_008381a4,&tStack_3c); + tStack_3c.top = tStack_3c.top + tStack_44.y; + tStack_3c.bottom = tStack_3c.bottom + tStack_44.y; + tStack_3c.left = tStack_3c.left + tStack_44.x; + tStack_3c.right = tStack_3c.right + tStack_44.x; + FUN_00441d00(piVar1,&tStack_3c); + piVar2 = (int *)tStack_44.x; + if (((iStack_18 - iStack_20 != 0) && (iStack_14 - iStack_1c != 0)) && + (piVar2 = (int *)(**(code **)(*DAT_00870340 + 0x10))(), piVar2 != (int *)0x0)) { + (**(code **)(*piVar2 + 0x58))(iStack_18 - iStack_20,iStack_14 - iStack_1c,piVar1[0x37],1); + FUN_00443290(appuStack_2c); + } + appuStack_2c[0] = &PTR_FUN_00799d14; + FUN_00440f40(); + (**(code **)(*piVar1 + 0x14))(); + return piVar2; + } + (**(code **)(*piVar1 + 0x10))(); + (**(code **)(*piVar1 + 0x14))(); + return piVar1; +} + + + +// --- FUN_00439590 at 0x00439590 (size: 62) --- + +undefined4 FUN_00439590(undefined4 *param_1,undefined4 *param_2,char param_3) + +{ + char *pcVar1; + + pcVar1 = "fatal"; + if (param_3 == '\0') { + pcVar1 = "non-fatal"; + } + FUN_0065aef0("%s: %s (%s)\n",*param_2,*param_1,pcVar1); + if (param_3 != '\0') { + DAT_00838194 = 1; + } + return 0; +} + + + +// --- FUN_004395d0 at 0x004395D0 (size: 79) --- + +undefined4 FUN_004395d0(HCURSOR param_1) + +{ + HICON hIcon; + + if ((param_1 == (HCURSOR)0x0) && + (param_1 = LoadCursorA((HINSTANCE)0x0,(LPCSTR)0x7f00), param_1 == (HCURSOR)0x0)) { + return 1; + } + hIcon = (HICON)GetClassLongA(DAT_008381a4,-0xc); + if (hIcon != param_1) { + DestroyIcon(hIcon); + } + SetClassLongA(DAT_008381a4,-0xc,(LONG)param_1); + SetCursor(param_1); + return 1; +} + + + +// --- FUN_00439620 at 0x00439620 (size: 32) --- + +void FUN_00439620(byte param_1) + +{ + if (DAT_00818b0c != param_1) { + ShowCursor((uint)param_1); + DAT_00818b0c = param_1; + } + return; +} + + + +// --- FUN_00439640 at 0x00439640 (size: 118) --- + +void __fastcall FUN_00439640(int *param_1) + +{ + uint uVar1; + int iVar2; + undefined4 *puVar3; + undefined4 local_10; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) != 0x80000000) { + if (*param_1 != 0) { + uVar1 = param_1[1] & 0x7fffffff; + if (-1 < (int)(uVar1 - 1)) { + iVar2 = (uVar1 - 1) * 0x10; + do { + puVar3 = (undefined4 *)(*param_1 + iVar2); + *puVar3 = local_10; + puVar3[1] = local_c; + puVar3[2] = local_8; + iVar2 = iVar2 + -0x10; + uVar1 = uVar1 - 1; + puVar3[3] = local_4; + } while (uVar1 != 0); + } + } + return; + } + operator_delete__((void *)*param_1); + *param_1 = 0; + param_1[1] = 0; + return; +} + + + +// --- FUN_004396c0 at 0x004396C0 (size: 80) --- + +void FUN_004396c0(undefined4 *param_1,undefined4 param_2,undefined4 param_3,uint param_4, + undefined4 param_5) + +{ + uint uVar1; + + uVar1 = param_1[-2]; + while (param_4 < uVar1) { + *param_1 = param_1[-4]; + param_1[1] = param_1[-3]; + param_1[2] = param_1[-2]; + param_1[3] = param_1[-1]; + uVar1 = param_1[-6]; + param_1 = param_1 + -4; + } + *param_1 = param_2; + param_1[1] = param_3; + param_1[2] = param_4; + param_1[3] = param_5; + return; +} + + + +// --- FUN_00439710 at 0x00439710 (size: 74) --- + +void FUN_00439710(int param_1,int param_2,int param_3,uint param_4) + +{ + uint uVar1; + int iVar2; + + if (param_2 <= param_3) { + *(uint *)(param_1 + param_2 * 4) = param_4; + return; + } + do { + iVar2 = (param_2 + -1) / 2; + uVar1 = *(uint *)(param_1 + iVar2 * 4); + if (param_4 <= uVar1) break; + *(uint *)(param_1 + param_2 * 4) = uVar1; + param_2 = iVar2; + } while (param_3 < iVar2); + *(uint *)(param_1 + param_2 * 4) = param_4; + return; +} + + + +// --- FUN_00439760 at 0x00439760 (size: 119) --- + +void FUN_00439760(int param_1,int param_2,int param_3,undefined4 param_4,undefined4 param_5, + uint param_6,undefined4 param_7) + +{ + int iVar1; + int iVar2; + undefined4 *puVar3; + undefined4 *puVar4; + + while (param_3 < param_2) { + iVar1 = (param_2 + -1) / 2; + iVar2 = iVar1 * 0x10; + puVar3 = (undefined4 *)(iVar2 + param_1); + if (param_6 <= *(uint *)(iVar2 + 8 + param_1)) break; + puVar4 = (undefined4 *)(param_2 * 0x10 + param_1); + *puVar4 = *puVar3; + puVar4[1] = puVar3[1]; + puVar4[2] = puVar3[2]; + puVar4[3] = puVar3[3]; + param_2 = iVar1; + } + puVar3 = (undefined4 *)(param_2 * 0x10 + param_1); + *puVar3 = param_4; + puVar3[1] = param_5; + puVar3[2] = param_6; + puVar3[3] = param_7; + return; +} + + + +// --- FUN_004397e0 at 0x004397E0 (size: 77) --- + +undefined4 * FUN_004397e0(int param_1,undefined4 *param_2,undefined4 *param_3) + +{ + int iVar1; + undefined4 *puVar2; + + iVar1 = (int)param_2 - param_1 >> 4; + if (iVar1 < 1) { + return param_3; + } + do { + puVar2 = param_3 + -4; + iVar1 = iVar1 + -1; + *puVar2 = param_2[-4]; + param_3[-3] = param_2[-3]; + param_3[-2] = param_2[-2]; + param_3[-1] = param_2[-1]; + param_3 = puVar2; + param_2 = param_2 + -4; + } while (iVar1 != 0); + return puVar2; +} + + + +// --- FUN_00439840 at 0x00439840 (size: 30) --- + +void * __thiscall FUN_00439840(void *param_1,byte param_2) + +{ + FUN_0040e6e0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00439d50 at 0x00439D50 (size: 243) --- + +void FUN_00439d50(undefined1 *param_1) + +{ + undefined4 *puVar1; + int iVar2; + undefined1 *puVar3; + HGLOBAL hMem; + LPVOID pvVar4; + undefined2 *puVar5; + LONG LVar6; + uint uVar7; + undefined1 *puVar8; + undefined2 *puVar9; + undefined1 *puVar10; + int iVar11; + bool bVar12; + + puVar3 = param_1; + bVar12 = DAT_0083819c != 2; + iVar2 = *(int *)(param_1 + -4); + if (bVar12) { + hMem = GlobalAlloc(0x42,iVar2 + 1); + pvVar4 = GlobalLock(hMem); + uVar7 = 0; + puVar10 = param_1; + if (0 < iVar2) { + do { + puVar8 = param_1 + *(uint *)(param_1 + -4) * 2 + -2; + if (uVar7 < *(uint *)(param_1 + -4)) { + puVar8 = puVar10; + } + *(undefined1 *)(uVar7 + (int)pvVar4) = *puVar8; + uVar7 = uVar7 + 1; + puVar10 = puVar10 + 2; + } while ((int)uVar7 < iVar2); + } + } + else { + hMem = GlobalAlloc(0x42,iVar2 * 2 + 2); + puVar5 = GlobalLock(hMem); + uVar7 = 0; + if (0 < iVar2) { + iVar11 = (int)param_1 - (int)puVar5; + do { + puVar9 = (undefined2 *)(param_1 + *(uint *)(param_1 + -4) * 2 + -2); + if (uVar7 < *(uint *)(param_1 + -4)) { + puVar9 = (undefined2 *)((int)puVar5 + iVar11); + } + *puVar5 = *puVar9; + uVar7 = uVar7 + 1; + puVar5 = puVar5 + 1; + } while ((int)uVar7 < iVar2); + } + } + param_1 = hMem; + GlobalUnlock(param_1); + OpenClipboard(DAT_008381a4); + EmptyClipboard(); + SetClipboardData((-(uint)bVar12 & 0xfffffff4) + 0xd,param_1); + CloseClipboard(); + puVar1 = (undefined4 *)(puVar3 + -0x14); + LVar6 = InterlockedDecrement((LONG *)(puVar3 + -0x10)); + if ((LVar6 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + return; +} + + + +// --- FUN_00439e50 at 0x00439E50 (size: 213) --- + +undefined1 FUN_00439e50(void) + +{ + char cVar1; + int iVar2; + tagMSG local_1c; + + DAT_00838198 = 1; + iVar2 = PeekMessageA(&local_1c,(HWND)0x0,0,0,1); + while ((iVar2 != 0 && (local_1c.message != 0x12))) { + cVar1 = FUN_006a1050(&local_1c); + if ((cVar1 == '\0') && (iVar2 = FUN_00557a90(local_1c.hwnd,0,&local_1c), iVar2 == 0)) { + TranslateMessage(&local_1c); + DispatchMessageA(&local_1c); + } + iVar2 = PeekMessageA(&local_1c,(HWND)0x0,0,0,1); + } + if (DAT_00838199 != '\0') { + if ((DAT_0086734c != 0) && (DAT_00838197 != '\0')) { + if ((DAT_00818b02 == '\0') || (DAT_00818b68 != '\0')) { + DAT_00818b68 = '\0'; + } + else { + DAT_00818b68 = '\x01'; + } + } + DAT_00838199 = '\0'; + } + DAT_00838198 = 0; + return DAT_00838194; +} + + + +// --- FUN_00439f30 at 0x00439F30 (size: 54) --- + +undefined4 FUN_00439f30(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + char cVar1; + undefined4 local_4; + + cVar1 = FUN_0043c4a0(param_1,param_2,param_3,&local_4); + if (cVar1 != '\0') { + FUN_004395d0(local_4); + return 1; + } + return 0; +} + + + +// --- FUN_00439f70 at 0x00439F70 (size: 106) --- + +undefined1 FUN_00439f70(char *param_1) + +{ + int *piVar1; + LONG LVar2; + undefined1 uVar3; + char *local_4; + + local_4 = (char *)0x0; + piVar1 = _errno(); + *piVar1 = 0; + strtoul(param_1,&local_4,0); + if (*local_4 == '\0') { + piVar1 = _errno(); + if (*piVar1 != 0x22) { + uVar3 = 1; + goto LAB_00439fb6; + } + } + uVar3 = 0; +LAB_00439fb6: + LVar2 = InterlockedDecrement((LONG *)(param_1 + -0x10)); + if ((LVar2 == 0) && (param_1 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(param_1 + -0x14))(1); + } + return uVar3; +} + + + +// --- FUN_00439fe0 at 0x00439FE0 (size: 59) --- + +void FUN_00439fe0(uint *param_1,uint *param_2) + +{ + uint uVar1; + uint uVar2; + uint *puVar3; + + for (; param_1 != param_2; param_1 = param_1 + 1) { + uVar1 = *param_1; + uVar2 = param_1[-1]; + puVar3 = param_1; + while (uVar1 < uVar2) { + *puVar3 = uVar2; + uVar2 = puVar3[-2]; + puVar3 = puVar3 + -1; + } + *puVar3 = uVar1; + } + return; +} + + + +// --- FUN_0043a020 at 0x0043A020 (size: 69) --- + +void FUN_0043a020(undefined4 *param_1,undefined4 *param_2,undefined4 param_3,undefined4 param_4) + +{ + for (; param_1 != param_2; param_1 = param_1 + 4) { + FUN_004396c0(param_1,*param_1,param_1[1],param_1[2],param_1[3],param_4); + } + return; +} + + + +// --- FUN_0043a070 at 0x0043A070 (size: 95) --- + +void FUN_0043a070(int param_1,int param_2,int param_3,undefined4 param_4,undefined4 param_5) + +{ + int iVar1; + int iVar2; + int iVar3; + + iVar3 = param_2; + while( true ) { + iVar1 = iVar3 * 2; + iVar2 = iVar1 + 2; + if (param_3 <= iVar2) break; + if (*(uint *)(param_1 + iVar2 * 4) < *(uint *)(param_1 + -4 + iVar2 * 4)) { + iVar2 = iVar1 + 1; + } + *(undefined4 *)(param_1 + iVar3 * 4) = *(undefined4 *)(param_1 + iVar2 * 4); + iVar3 = iVar2; + } + if (iVar2 == param_3) { + *(undefined4 *)(param_1 + iVar3 * 4) = *(undefined4 *)(param_1 + -4 + iVar2 * 4); + iVar3 = iVar1 + 1; + } + FUN_00439710(param_1,iVar3,param_2,param_4,param_5); + return; +} + + + +// --- FUN_0043a0d0 at 0x0043A0D0 (size: 187) --- + +void FUN_0043a0d0(int param_1,int param_2,int param_3,undefined4 param_4,undefined4 param_5, + undefined4 param_6,undefined4 param_7,undefined4 param_8) + +{ + int iVar1; + int iVar2; + undefined4 *puVar3; + int iVar4; + undefined4 *puVar5; + + iVar4 = param_2; + while( true ) { + iVar1 = iVar4 * 2; + iVar2 = iVar1 + 2; + if (param_3 <= iVar2) break; + if (*(uint *)(iVar2 * 0x10 + 8 + param_1) < *(uint *)(iVar2 * 0x10 + param_1 + -8)) { + iVar2 = iVar1 + 1; + } + puVar5 = (undefined4 *)(iVar2 * 0x10 + param_1); + puVar3 = (undefined4 *)(iVar4 * 0x10 + param_1); + *puVar3 = *puVar5; + puVar3[1] = puVar5[1]; + puVar3[2] = puVar5[2]; + puVar3[3] = puVar5[3]; + iVar4 = iVar2; + } + if (iVar2 == param_3) { + puVar3 = (undefined4 *)(iVar2 * 0x10 + -0x10 + param_1); + puVar5 = (undefined4 *)(iVar4 * 0x10 + param_1); + *puVar5 = *puVar3; + puVar5[1] = puVar3[1]; + puVar5[2] = puVar3[2]; + puVar5[3] = puVar3[3]; + iVar4 = iVar1 + 1; + } + FUN_00439760(param_1,iVar4,param_2,param_4,param_5,param_6,param_7,param_8); + return; +} + + + +// --- FUN_0043a190 at 0x0043A190 (size: 70) --- + +void FUN_0043a190(uint *param_1,uint *param_2,uint param_3) + +{ + uint uVar1; + uint *puVar2; + + while( true ) { + uVar1 = *param_1; + while (uVar1 < param_3) { + puVar2 = param_1 + 1; + param_1 = param_1 + 1; + uVar1 = *puVar2; + } + uVar1 = param_2[-1]; + puVar2 = param_2; + while (param_2 = puVar2 + -1, param_3 < uVar1) { + uVar1 = puVar2[-2]; + puVar2 = param_2; + } + if (param_2 <= param_1) break; + uVar1 = *param_1; + *param_1 = *param_2; + *param_2 = uVar1; + param_1 = param_1 + 1; + } + return; +} + + + +// --- FUN_0043a1e0 at 0x0043A1E0 (size: 143) --- + +void FUN_0043a1e0(undefined4 *param_1,undefined4 *param_2,undefined4 param_3,undefined4 param_4, + uint param_5) + +{ + uint *puVar1; + uint uVar2; + undefined4 uVar3; + undefined4 uVar4; + undefined4 uVar5; + undefined4 uVar6; + + while( true ) { + uVar2 = param_1[2]; + while (uVar2 < param_5) { + puVar1 = param_1 + 6; + param_1 = param_1 + 4; + uVar2 = *puVar1; + } + uVar2 = param_2[-2]; + while (param_2 = param_2 + -4, param_5 < uVar2) { + uVar2 = param_2[-2]; + } + if (param_2 <= param_1) break; + uVar3 = *param_1; + uVar4 = param_1[1]; + uVar5 = param_1[2]; + uVar6 = param_1[3]; + *param_1 = *param_2; + param_1[1] = param_2[1]; + param_1[2] = param_2[2]; + param_1[3] = param_2[3]; + *param_2 = uVar3; + param_2[1] = uVar4; + param_2[2] = uVar5; + param_2[3] = uVar6; + param_1 = param_1 + 4; + } + return; +} + + + +// --- FUN_0043a270 at 0x0043A270 (size: 83) --- + +void FUN_0043a270(int param_1,int param_2,undefined4 param_3) + +{ + int iVar1; + int iVar2; + int iVar3; + + iVar2 = param_2 - param_1 >> 2; + if (1 < iVar2) { + iVar3 = (iVar2 + -2) / 2; + FUN_0043a070(param_1,iVar3,iVar2,*(undefined4 *)(param_1 + iVar3 * 4),param_3); + while (iVar3 != 0) { + iVar1 = iVar3 * 4; + iVar3 = iVar3 + -1; + FUN_0043a070(param_1,iVar3,iVar2,*(undefined4 *)(param_1 + -4 + iVar1),param_3); + } + } + return; +} + + + +// --- FUN_0043a2d0 at 0x0043A2D0 (size: 154) --- + +void FUN_0043a2d0(int param_1,int param_2,undefined4 param_3) + +{ + undefined4 *puVar1; + int iVar2; + int iVar3; + + iVar3 = param_2 - param_1 >> 4; + if (1 < iVar3) { + iVar2 = (iVar3 + -2) / 2; + puVar1 = (undefined4 *)(iVar2 * 0x10 + param_1); + FUN_0043a0d0(param_1,iVar2,iVar3,*puVar1,puVar1[1],puVar1[2],puVar1[3],param_3); + while (iVar2 != 0) { + iVar2 = iVar2 + -1; + FUN_0043a0d0(param_1,iVar2,iVar3,puVar1[-4],puVar1[-3],puVar1[-2],puVar1[-1],param_3); + puVar1 = puVar1 + -4; + } + } + return; +} + + + +// --- FUN_0043a370 at 0x0043A370 (size: 416) --- + +void FUN_0043a370(void) + +{ + int *piVar1; + LONG LVar2; + undefined4 *puVar3; + int local_4; + + if (DAT_00838196 != '\0') { + FUN_00401340(&DAT_00799d90); + FUN_00436830(&local_4); + puVar3 = (undefined4 *)(local_4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + FUN_00401340(&DAT_00799d88); + FUN_00436830(&local_4); + puVar3 = (undefined4 *)(local_4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + FUN_00401340("UpdatePresentation"); + FUN_00436830(&local_4); + puVar3 = (undefined4 *)(local_4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + FUN_00401340("ForceDisplayResolution"); + FUN_00436830(&local_4); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + FUN_00439320(); + piVar1 = DAT_00837ff4; + DAT_00838195 = 0; + (**(code **)(*DAT_00837ff4 + 0xc))(); + (**(code **)*piVar1)(1); + DAT_00837ff4 = (int *)0x0; + FUN_00439400(); + if (DAT_008381a4 != (HWND)0x0) { + DestroyWindow(DAT_008381a4); + if (DAT_008381a8 == '\0') { + PostQuitMessage(0); + } + DAT_008381a4 = (HWND)0x0; + } + thunk_FUN_00436cf0(&DAT_008381c8); + thunk_FUN_00436cf0(&DAT_008381cc); + thunk_FUN_00436cf0(&DAT_008381d0); + thunk_FUN_00436cf0(&DAT_008381d4); + if (DAT_008381ac != (undefined4 *)0x0) { + (**(code **)*DAT_008381ac)(1); + } + DAT_008381ac = (undefined4 *)0x0; + SetThreadExecutionState(0x80000000); + DAT_00838196 = '\0'; + } + return; +} + + + +// --- FUN_0043a510 at 0x0043A510 (size: 619) --- + +char FUN_0043a510(void) + +{ + char cVar1; + int iVar2; + int iVar3; + int iVar4; + int iVar5; + int iVar6; + BOOL BVar7; + int iVar8; + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined4 extraout_ECX_01; + int iVar9; + int Y; + LONG *pLVar10; + int *piVar11; + LONG *pLVar12; + int *piVar13; + undefined4 uVar14; + undefined4 uVar15; + undefined4 uVar16; + undefined1 auStack_5c [8]; + int iStack_54; + int local_50; + int local_4c; + int iStack_48; + tagRECT tStack_44; + int aiStack_28 [3]; + LONG local_1c [3]; + char local_10; + + if (DAT_0086734c == 0) { + return '\0'; + } + pLVar10 = &tStack_44.bottom; + piVar13 = DAT_00870340; + for (iVar8 = 7; piVar13 = piVar13 + 1, iVar8 != 0; iVar8 = iVar8 + -1) { + *pLVar10 = *piVar13; + pLVar10 = pLVar10 + 1; + } + pLVar10 = &tStack_44.bottom; + pLVar12 = local_1c; + for (iVar8 = 7; iVar8 != 0; iVar8 = iVar8 + -1) { + *pLVar12 = *pLVar10; + pLVar10 = pLVar10 + 1; + pLVar12 = pLVar12 + 1; + } + local_50 = DAT_00870340[8]; + local_4c = DAT_00870340[9]; + cVar1 = FUN_00439370(local_1c); + if (cVar1 == '\0') { + return '\0'; + } + (*(code *)PTR_FUN_008373b0) + (DAT_008381a4,0xfffffff0,(-(uint)(local_10 != '\0') & 0x7f360000) + 0x12ca0000); + SetWindowPos(DAT_008381a4,(HWND)0xfffffffe,0,0,0,0,0x27); + cVar1 = FUN_0054e2c0(aiStack_28,auStack_5c); + piVar13 = aiStack_28; + piVar11 = DAT_00870340; + for (iVar8 = 7; piVar11 = piVar11 + 1, iVar8 != 0; iVar8 = iVar8 + -1) { + *piVar13 = *piVar11; + piVar13 = piVar13 + 1; + } + iVar9 = 0; + Y = 0; + iVar8 = aiStack_28[1]; + iVar3 = aiStack_28[2]; + if ((char)local_1c[0] != '\0') goto LAB_0043a6eb; + iVar2 = GetSystemMetrics(7); + iVar3 = GetSystemMetrics(8); + iVar4 = GetSystemMetrics(4); + iVar5 = GetSystemMetrics(0); + iVar6 = GetSystemMetrics(1); + iVar8 = aiStack_28[1] + iVar2 * 2; + iVar3 = aiStack_28[2] + iVar4 + iVar3 * 2; + if ((char)tStack_44.bottom == '\0') { + BVar7 = GetWindowRect(DAT_008381a4,&tStack_44); + if (BVar7 != 0) { + iVar9 = (tStack_44.right - iVar8) + tStack_44.left; + iVar9 = iVar9 - (iVar9 >> 0x1f); + iVar6 = (tStack_44.bottom - iVar3) + tStack_44.top; + goto LAB_0043a67d; + } + } + else { + iVar9 = (iVar5 - iVar8) - (iVar5 - iVar8 >> 0x1f); + iVar6 = iVar6 - iVar3; +LAB_0043a67d: + iVar9 = iVar9 >> 1; + Y = iVar6 / 2; + } + BVar7 = SystemParametersInfoA(0x30,0x10,&iStack_54,0); + if (BVar7 == 0) goto LAB_0043a6eb; + if (local_4c - iStack_54 < iVar8) { + iStack_54 = iStack_54 - iVar2; +LAB_0043a6ce: + iVar9 = iStack_54; + } + else { + if (local_4c < iVar8 + iVar9) { + iVar9 = (local_4c - iStack_54) - iVar8; + } + if (iVar9 < iStack_54) goto LAB_0043a6ce; + } + if (iVar3 <= iStack_48 - local_50) { + if (iStack_48 < iVar3 + Y) { + Y = (iStack_48 - local_50) - iVar3; + } + if (local_50 <= Y) goto LAB_0043a6eb; + } + Y = local_50; +LAB_0043a6eb: + SetWindowPos(DAT_008381a4,(HWND)(((char)local_1c[0] != '\0') - 2),iVar9,Y,iVar8,iVar3,0x100); + if (cVar1 != '\0') { + FUN_0045b4c0(0xe,0); + return cVar1; + } + uVar16 = extraout_ECX; + FUN_00402730(&DAT_00795320); + uVar15 = extraout_ECX_00; + FUN_00402730(&DAT_00795320); + uVar14 = extraout_ECX_01; + FUN_00402730(&DAT_00795320); + FUN_0043d090(0x80,uVar14,uVar15,uVar16); + /* WARNING: Subroutine does not return */ + exit(1); +} + + + +// --- FUN_0043a780 at 0x0043A780 (size: 351) --- + +char FUN_0043a780(int *param_1) + +{ + undefined *puVar1; + char cVar2; + int *piVar3; + LONG LVar4; + int iVar5; + undefined4 *puVar6; + undefined *local_c; + undefined *local_8; + int local_4; + + if (DAT_0086734c == 0) { + return '\0'; + } + piVar3 = (int *)FUN_00439460(); + if (piVar3 == (int *)0x0) { + return '\0'; + } + local_4 = DAT_00838188; + InterlockedIncrement((LONG *)(DAT_00838188 + -0x10)); + local_8 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + thunk_FUN_0040c780(&local_8,&local_4); + local_c = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + iVar5 = 0; + do { + FUN_00402710(&local_c,"%sScreenShot%05d.jpg",local_8,iVar5); + cVar2 = FUN_0040b320(&local_c,0); + if (cVar2 == '\0') break; + iVar5 = iVar5 + 1; + } while (iVar5 < 100000); + cVar2 = FUN_00443dc0(&local_c); + if ((cVar2 != '\0') && (puVar1 = (undefined *)*param_1, puVar1 != local_c)) { + LVar4 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + *param_1 = (int)local_c; + InterlockedIncrement((LONG *)(local_c + -0x10)); + } + (**(code **)(*piVar3 + 0x14))(); + puVar6 = (undefined4 *)(local_c + -0x14); + LVar4 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar4 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + puVar6 = (undefined4 *)(local_8 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar4 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + puVar6 = (undefined4 *)(local_4 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar4 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + return cVar2; +} + + + +// --- FUN_0043a8f0 at 0x0043A8F0 (size: 52) --- + +void FUN_0043a8f0(void) + +{ + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined4 uVar1; + undefined4 uVar2; + undefined4 extraout_var; + undefined4 uVar3; + undefined4 uVar4; + + uVar4 = 1; + FUN_00402730(&DAT_00795320); + uVar2 = extraout_ECX; + uVar3 = extraout_var; + FUN_00402730(&DAT_00795320); + uVar1 = extraout_ECX_00; + FUN_00402730(&DAT_00795320); + FUN_0043d090(0x7b,uVar1,uVar2,uVar3,uVar4); + return; +} + + + +// --- FUN_0043a930 at 0x0043A930 (size: 88) --- + +undefined4 __thiscall FUN_0043a930(int *param_1,undefined4 *param_2) + +{ + undefined4 uVar1; + undefined4 *puVar2; + + if ((param_1[1] & 0x7fffffffU) <= (uint)param_1[2]) { + uVar1 = FUN_00453850((param_1[1] & 0x7fffffffU) + 1); + uVar1 = FUN_0059df80(uVar1); + if ((char)uVar1 == '\0') { + return uVar1; + } + } + puVar2 = (undefined4 *)(param_1[2] * 0x10 + *param_1); + *puVar2 = *param_2; + puVar2[1] = param_2[1]; + puVar2[2] = param_2[2]; + puVar2[3] = param_2[3]; + param_1[2] = param_1[2] + 1; + return CONCAT31((int3)((uint)puVar2 >> 8),1); +} + + + +// --- FUN_0043a990 at 0x0043A990 (size: 209) --- + +void FUN_0043a990(char param_1,int param_2,int param_3) + +{ + char cVar1; + int iVar2; + undefined1 local_1c [4]; + int local_18; + int local_14; + + cVar1 = DAT_008381a0; + DAT_00818b04 = param_2; + DAT_00818b08 = param_3; + DAT_008381a0 = param_1; + if (DAT_0086734c != 0) { + if (DAT_00838196 != '\0') { + if (param_1 == '\0') { + if (cVar1 == '\0') { + return; + } + local_18 = 800; + local_14 = 600; + cVar1 = FUN_00439370(local_1c); + if (((cVar1 != '\0') && (iVar2 = FUN_0054fd20(), iVar2 == local_18)) && + (iVar2 = FUN_0054fd30(), iVar2 == local_14)) { + return; + } + } + else { + iVar2 = FUN_0054fd20(); + if ((iVar2 == DAT_00818b04) && (iVar2 = FUN_0054fd30(), iVar2 == DAT_00818b08)) { + return; + } + } + } + if ((DAT_0086734c != 0) && (DAT_00838196 != '\0')) { + FUN_0043a510(); + return; + } + } + return; +} + + + +// --- FUN_0043aa70 at 0x0043AA70 (size: 146) --- + +undefined4 FUN_0043aa70(int *param_1) + +{ + char cVar1; + undefined4 uVar2; + int iVar3; + + if (param_1[2] == 0) { + FUN_0043a990(0,DAT_00818b04,DAT_00818b08); + return 1; + } + if (1 < (uint)param_1[2]) { + iVar3 = *(int *)*param_1; + InterlockedIncrement((LONG *)(iVar3 + -0x10)); + cVar1 = FUN_00439f70(iVar3); + if (cVar1 != '\0') { + iVar3 = *(int *)(*param_1 + 4); + InterlockedIncrement((LONG *)(iVar3 + -0x10)); + cVar1 = FUN_00439f70(iVar3); + if (cVar1 != '\0') { + uVar2 = FUN_00404d70(); + uVar2 = FUN_00404d70(uVar2); + FUN_0043a990(1,uVar2); + return 1; + } + } + } + return 0; +} + + + +// --- FUN_0043ab10 at 0x0043AB10 (size: 52) --- + +void FUN_0043ab10(char param_1) + +{ + DAT_00818b02 = param_1; + if ((((DAT_0086734c != 0) && (DAT_00838196 != '\0')) && (*(char *)(DAT_00870340 + 0x10) != '\0')) + && (param_1 == '\0')) { + FUN_0043a510(); + return; + } + return; +} + + + +// --- FUN_0043ab50 at 0x0043AB50 (size: 250) --- + +undefined4 FUN_0043ab50(void) + +{ + int iVar1; + int iVar2; + HGLOBAL hMem; + SIZE_T SVar3; + LPVOID pvVar4; + undefined2 *puVar5; + undefined2 *puVar6; + int *unaff_EBX; + uint uVar7; + bool bVar8; + + bVar8 = DAT_0083819c != 2; + iVar1 = (-(uint)bVar8 & 0xfffffff4) + 0xd; + iVar2 = (*(code *)PTR_FUN_008373a8)(iVar1); + if (iVar2 == 0) { + return 0; + } + OpenClipboard(DAT_008381a4); + hMem = (HGLOBAL)(*(code *)PTR_FUN_008373a4)(iVar1); + SVar3 = GlobalSize(hMem); + if (bVar8) { + pvVar4 = GlobalLock(hMem); + if (pvVar4 != (LPVOID)0x0) { + puVar5 = (undefined2 *)thunk_FUN_005df0f5(SVar3 * 2); + if ((puVar5 != (undefined2 *)0x0) && (iVar1 = 0, 0 < (int)SVar3)) { + do { + puVar5[iVar1] = (short)*(char *)(iVar1 + (int)pvVar4); + iVar1 = iVar1 + 1; + } while (iVar1 < (int)SVar3); + } +LAB_0043ac1d: + GlobalUnlock(hMem); + CloseClipboard(); + FUN_00407e40(puVar5); + operator_delete__(puVar5); + return CONCAT31((int3)((uint)*unaff_EBX >> 8),*(int *)(*unaff_EBX + -4) != 1); + } + } + else { + uVar7 = SVar3 >> 1; + pvVar4 = GlobalLock(hMem); + if (pvVar4 != (LPVOID)0x0) { + puVar5 = (undefined2 *)thunk_FUN_005df0f5(uVar7 * 2); + if ((puVar5 != (undefined2 *)0x0) && (uVar7 != 0)) { + puVar6 = puVar5; + do { + *puVar6 = *(undefined2 *)(((int)pvVar4 - (int)puVar5) + (int)puVar6); + puVar6 = puVar6 + 1; + uVar7 = uVar7 - 1; + } while (uVar7 != 0); + } + goto LAB_0043ac1d; + } + } + return 0; +} + + + +// --- FUN_0043ac60 at 0x0043AC60 (size: 297) --- + +undefined4 FUN_0043ac60(undefined4 param_1,undefined4 param_2,char param_3) + +{ + char cVar1; + HDC hdc; + int iVar2; + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined4 extraout_ECX_01; + undefined4 uVar3; + undefined4 uVar4; + undefined4 uVar5; + undefined4 uVar6; + undefined4 local_24; + undefined1 local_20; + undefined1 uStack_1f; + undefined1 uStack_1e; + undefined4 local_1c; + undefined4 local_18; + undefined4 local_14; + undefined1 local_10; + undefined4 local_c; + undefined4 local_8; + undefined1 uStack_4; + undefined1 uStack_3; + undefined1 uStack_2; + + if (param_3 != '\0') { + hdc = CreateICA("Display",(LPCSTR)0x0,(LPCSTR)0x0,(DEVMODEA *)0x0); + iVar2 = GetDeviceCaps(hdc,0xc); + DeleteDC(hdc); + if (iVar2 == 0x10) { + FUN_0043a8f0(); + } + else if (iVar2 != 0x20) { + uVar6 = 0; + uVar5 = extraout_ECX; + FUN_00402730(&DAT_00795320); + uVar4 = extraout_ECX_00; + FUN_00402730(&DAT_00795320); + uVar3 = extraout_ECX_01; + FUN_00402730(&DAT_00795320); + FUN_0043d090(0x7d,uVar3,uVar4,uVar5,uVar6); + /* WARNING: Subroutine does not return */ + exit(1); + } + } + local_18 = param_1; + local_1c = 0; + local_c = 0; + local_8 = 0x20; + uStack_4 = 0; + uStack_3 = 0; + uStack_2 = 0; + local_24 = 0; + local_20 = 1; + uStack_1f = 0; + uStack_1e = 1; + local_14 = param_2; + if ((DAT_00818b02 == '\0') || (local_10 = 1, param_3 != '\0')) { + local_10 = 0; + } + cVar1 = FUN_00439370(&local_1c); + if (cVar1 != '\0') { + local_1c = DAT_008381a4; + local_24 = DAT_008381a4; + cVar1 = FUN_0054e1a0(&local_1c,&local_24); + if ((cVar1 != '\0') && (cVar1 = FUN_004402d0(), cVar1 != '\0')) { + FUN_0054e6a0(); + return 1; + } + } + return 0; +} + + + +// --- FUN_0043ad90 at 0x0043AD90 (size: 45) --- + +undefined4 FUN_0043ad90(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + char cVar1; + + DAT_00838195 = 0; + cVar1 = FUN_0043ac60(param_1,param_2,param_3); + if (cVar1 != '\0') { + DAT_00838195 = 1; + return 1; + } + return 0; +} + + + +// --- FUN_0043adc0 at 0x0043ADC0 (size: 113) --- + +void FUN_0043adc0(uint *param_1,uint *param_2) + +{ + size_t _Size; + uint uVar1; + uint uVar2; + uint *puVar3; + uint *puVar4; + + if ((param_1 != param_2) && (puVar4 = param_1 + 1, puVar4 != param_2)) { + do { + uVar1 = *puVar4; + if (uVar1 < *param_1) { + _Size = (int)puVar4 - (int)param_1; + if (0 < (int)_Size) { + memmove((void *)((int)puVar4 + (4 - _Size)),param_1,_Size); + } + *param_1 = uVar1; + } + else { + uVar2 = puVar4[-1]; + puVar3 = puVar4; + while (uVar1 < uVar2) { + *puVar3 = uVar2; + uVar2 = puVar3[-2]; + puVar3 = puVar3 + -1; + } + *puVar3 = uVar1; + } + puVar4 = puVar4 + 1; + } while (puVar4 != param_2); + } + return; +} + + + +// --- FUN_0043ae40 at 0x0043AE40 (size: 117) --- + +void FUN_0043ae40(undefined4 *param_1,int param_2,undefined4 param_3,undefined4 param_4,uint param_5 + ,undefined4 param_6,undefined4 param_7) + +{ + undefined4 *puVar1; + uint uVar2; + + uVar2 = param_5; + puVar1 = param_1; + if (param_5 < (uint)param_1[2]) { + FUN_004397e0(param_1,param_2,param_2 + 0x10,¶m_1,0); + *puVar1 = param_3; + puVar1[1] = param_4; + puVar1[2] = uVar2; + puVar1[3] = param_6; + return; + } + FUN_004396c0(param_2,param_3,param_4,param_5,param_6,param_7); + return; +} + + + +// --- FUN_0043aec0 at 0x0043AEC0 (size: 77) --- + +void FUN_0043aec0(undefined4 *param_1,int param_2,undefined4 param_3) + +{ + undefined4 uVar1; + uint uVar2; + + uVar2 = param_2 - (int)param_1; + while (4 < (int)(uVar2 & 0xfffffffc)) { + uVar1 = *(undefined4 *)((int)param_1 + (uVar2 - 4)); + *(undefined4 *)((int)param_1 + (uVar2 - 4)) = *param_1; + FUN_0043a070(param_1,0,(int)(uVar2 - 4) >> 2,uVar1,param_3); + uVar2 = uVar2 - 4; + } + return; +} + + + +// --- FUN_0043af10 at 0x0043AF10 (size: 147) --- + +void FUN_0043af10(undefined4 *param_1,int param_2,undefined4 param_3) + +{ + undefined4 *puVar1; + undefined4 uVar2; + undefined4 uVar3; + undefined4 uVar4; + undefined4 uVar5; + uint uVar6; + + uVar6 = param_2 - (int)param_1; + while (0x10 < (int)(uVar6 & 0xfffffff0)) { + puVar1 = (undefined4 *)((int)param_1 + (uVar6 - 0x10)); + uVar2 = *puVar1; + uVar3 = puVar1[1]; + uVar4 = puVar1[2]; + uVar5 = puVar1[3]; + *puVar1 = *param_1; + puVar1[1] = param_1[1]; + puVar1[2] = param_1[2]; + puVar1[3] = param_1[3]; + uVar6 = uVar6 - 0x10; + FUN_0043a0d0(param_1,0,(int)uVar6 >> 4,uVar2,uVar3,uVar4,uVar5,param_3); + } + return; +} + + + +// --- FUN_0043afb0 at 0x0043AFB0 (size: 81) --- + +void FUN_0043afb0(undefined4 *param_1,undefined4 *param_2,undefined4 param_3) + +{ + undefined4 *puVar1; + + puVar1 = param_1; + if (param_1 != param_2) { + while (puVar1 = puVar1 + 4, puVar1 != param_2) { + FUN_0043ae40(param_1,puVar1,*puVar1,puVar1[1],puVar1[2],puVar1[3],param_3); + } + } + return; +} + + + +// --- FUN_0043b010 at 0x0043B010 (size: 106) --- + +void FUN_0043b010(uint *param_1,uint *param_2,uint *param_3,undefined4 param_4,undefined4 param_5) + +{ + uint uVar1; + uint *puVar2; + + FUN_0043a270(param_1,param_2,param_5,0,0); + for (puVar2 = param_2; puVar2 < param_3; puVar2 = puVar2 + 1) { + uVar1 = *puVar2; + if (uVar1 < *param_1) { + *puVar2 = *param_1; + FUN_0043a070(param_1,0,(int)param_2 - (int)param_1 >> 2,uVar1,param_5); + } + } + FUN_0043aec0(param_1,param_2,param_5); + return; +} + + + +// --- FUN_0043b080 at 0x0043B080 (size: 185) --- + +void FUN_0043b080(undefined4 *param_1,undefined4 *param_2,undefined4 *param_3,undefined4 param_4, + undefined4 param_5) + +{ + undefined4 uVar1; + undefined4 uVar2; + undefined4 uVar3; + undefined4 uVar4; + undefined4 *puVar5; + + FUN_0043a2d0(param_1,param_2,param_5,0,0); + for (puVar5 = param_2; puVar5 < param_3; puVar5 = puVar5 + 4) { + if ((uint)puVar5[2] < (uint)param_1[2]) { + uVar1 = *puVar5; + uVar2 = puVar5[1]; + uVar3 = puVar5[2]; + uVar4 = puVar5[3]; + *puVar5 = *param_1; + puVar5[1] = param_1[1]; + puVar5[2] = param_1[2]; + puVar5[3] = param_1[3]; + FUN_0043a0d0(param_1,0,(int)param_2 - (int)param_1 >> 4,uVar1,uVar2,uVar3,uVar4,param_5); + } + } + FUN_0043af10(param_1,param_2,param_5); + return; +} + + + +// --- FUN_0043b140 at 0x0043B140 (size: 169) --- + +void FUN_0043b140(uint *param_1,int param_2,undefined4 param_3,int param_4,undefined4 param_5) + +{ + uint uVar1; + uint uVar2; + uint uVar3; + uint uVar4; + uint *puVar5; + int iVar6; + uint *puVar7; + + if (0x40 < (int)(param_2 - (int)param_1 & 0xfffffffcU)) { + while (param_4 != 0) { + uVar1 = *param_1; + iVar6 = (param_2 - (int)param_1 >> 2) - (param_2 - (int)param_1 >> 0x1f) >> 1; + uVar2 = param_1[iVar6]; + param_4 = param_4 + -1; + uVar3 = *(uint *)(param_2 + -4); + uVar4 = uVar2; + puVar5 = param_1 + iVar6; + puVar7 = param_1; + if (uVar1 < uVar2) { + uVar4 = uVar1; + puVar5 = param_1; + puVar7 = param_1 + iVar6; + uVar1 = uVar2; + } + if ((uVar3 <= uVar1) && (puVar7 = puVar5, uVar4 < uVar3)) { + puVar7 = (uint *)(param_2 + -4); + } + iVar6 = FUN_0043a190(param_1,param_2,*puVar7,param_5); + FUN_0043b140(iVar6,param_2,0,param_4,param_5); + param_2 = iVar6; + if ((int)(iVar6 - (int)param_1 & 0xfffffffcU) < 0x41) { + return; + } + } + FUN_0043b010(param_1,param_2,param_2,0,param_5); + } + return; +} + + + +// --- FUN_0043b1f0 at 0x0043B1F0 (size: 211) --- + +void FUN_0043b1f0(undefined4 *param_1,int param_2,undefined4 param_3,int param_4,undefined4 param_5) + +{ + uint uVar1; + uint uVar2; + uint uVar3; + undefined4 *puVar4; + int iVar5; + undefined4 *puVar6; + + if (0x100 < (int)(param_2 - (int)param_1 & 0xfffffff0U)) { + while (param_4 != 0) { + uVar1 = param_1[2]; + iVar5 = (param_2 - (int)param_1 >> 4) - (param_2 - (int)param_1 >> 0x1f) >> 1; + uVar2 = param_1[iVar5 * 4 + 2]; + param_4 = param_4 + -1; + uVar3 = uVar2; + puVar4 = param_1 + iVar5 * 4; + puVar6 = param_1; + if (uVar1 < uVar2) { + uVar3 = uVar1; + puVar4 = param_1; + puVar6 = param_1 + iVar5 * 4; + uVar1 = uVar2; + } + if ((*(uint *)(param_2 + -8) <= uVar1) && (puVar6 = puVar4, uVar3 < *(uint *)(param_2 + -8))) + { + puVar6 = (undefined4 *)(param_2 + -0x10); + } + iVar5 = FUN_0043a1e0(param_1,param_2,*puVar6,puVar6[1],puVar6[2],puVar6[3],param_5); + FUN_0043b1f0(iVar5,param_2,0,param_4,param_5); + param_2 = iVar5; + if ((int)(iVar5 - (int)param_1 & 0xfffffff0U) < 0x101) { + return; + } + } + FUN_0043b080(param_1,param_2,param_2,0,param_5); + } + return; +} + + + +// --- FUN_0043b2d0 at 0x0043B2D0 (size: 1929) --- + +undefined4 FUN_0043b2d0(void) + +{ + void *pvVar1; + void *pvVar2; + char cVar3; + char *pcVar4; + int iVar5; + undefined4 *puVar6; + LONG LVar7; + int iVar8; + char *pcVar9; + char *pcVar10; + int *piVar11; + int *piVar12; + uint uVar13; + int *piVar14; + char *local_7c; + undefined4 local_78; + int local_74 [2]; + int *local_6c; + undefined4 *local_68; + void *local_60; + uint local_5c; + int local_58; + uint local_54; + int *local_50; + uint local_4c; + char *local_48; + void *local_44; + uint local_40; + uint local_3c; + byte local_2c; + + iVar5 = DAT_0086734c; + if (DAT_0086734c == 0) { + return 0; + } + piVar11 = (int *)0x0; + pcVar10 = (char *)0x0; + piVar14 = (int *)(DAT_0086734c + 0xc); + local_50 = (int *)0x0; + local_4c = 0; + local_48 = (char *)0x0; + local_44 = (void *)0x0; + local_40 = 0; + local_3c = 0; + pcVar4 = *(char **)(DAT_0086734c + 0x14); + local_7c = (char *)0x0; + if (pcVar4 != (char *)0xffffffff) { + local_6c = (int *)0x0; + do { + piVar12 = local_6c; + if (local_7c < pcVar4) { + if ((799 < *(uint *)((int)local_6c + *piVar14)) && + (599 < *(uint *)((int)local_6c + *piVar14 + 4))) { + FUN_00535a80(); + FUN_0043d290(*(undefined4 *)((int)piVar12 + *piVar14 + 8)); + pcVar10 = local_48; + piVar11 = local_50; + if (0x1f < local_2c) { + iVar8 = *piVar14; + local_60 = *(void **)((int)piVar12 + iVar8); + local_5c = *(uint *)((int)piVar12 + iVar8 + 4); + local_74[0] = *(int *)((int)piVar12 + iVar8 + 0xc); + goto LAB_0043b399; + } + } + } + else { + local_60 = (void *)0x400; + local_5c = 0x300; + local_74[0] = 0; +LAB_0043b399: + local_58 = local_5c * (int)local_60; + local_54 = (int)local_60 << 0x10 | local_5c; + pcVar4 = (char *)0x0; + if (pcVar10 != (char *)0x0) { + do { + if (((void *)*piVar11 == local_60) && (piVar11[1] == local_5c)) { + if (pcVar4 != (char *)0xffffffff) goto LAB_0043b3e6; + break; + } + pcVar4 = pcVar4 + 1; + piVar11 = piVar11 + 4; + } while (pcVar4 < pcVar10); + } + FUN_0043a930(&local_60); +LAB_0043b3e6: + FUN_00455770(local_74); + pcVar10 = local_48; + piVar11 = local_50; + piVar12 = local_6c; + } + pcVar4 = *(char **)(iVar5 + 0x14); + local_7c = local_7c + 1; + local_6c = piVar12 + 4; + } while (local_7c < pcVar4 + 1); + } + piVar14 = piVar11 + (int)pcVar10 * 4; + if (piVar11 != piVar14) { + iVar5 = (int)piVar14 - (int)piVar11 >> 4; + iVar8 = 0; + if (iVar5 != 1) { + iVar8 = 0; + do { + iVar5 = iVar5 >> 1; + iVar8 = iVar8 + 1; + } while (iVar5 != 1); + } + FUN_0043b1f0(piVar11,piVar14,0,iVar8 * 2,local_6c); + piVar12 = local_6c; + if ((int)((int)piVar14 - (int)piVar11 & 0xfffffff0U) < 0x101) { + FUN_0043afb0(piVar11,piVar14,local_6c); + } + else { + FUN_0043afb0(piVar11,piVar11 + 0x40,local_6c); + FUN_0043a020(piVar11 + 0x40,piVar14,0,piVar12); + } + } + pvVar2 = local_44; + pvVar1 = (void *)((int)local_44 + local_3c * 4); + if (local_44 != pvVar1) { + uVar13 = (int)pvVar1 - (int)local_44; + iVar8 = 0; + for (iVar5 = (int)uVar13 >> 2; iVar5 != 1; iVar5 = iVar5 >> 1) { + iVar8 = iVar8 + 1; + } + FUN_0043b140(local_44,pvVar1,0,iVar8 * 2,local_6c); + piVar11 = local_6c; + if ((int)(uVar13 & 0xfffffffc) < 0x41) { + FUN_0043adc0(pvVar2,pvVar1,local_6c); + } + else { + FUN_0043adc0(pvVar2,(int)pvVar2 + 0x40,local_6c); + FUN_00439fe0((int)pvVar2 + 0x40,pvVar1,0,piVar11); + } + } + local_74[0] = 0; + local_74[1] = 0; + FUN_00435390(local_48); + puVar6 = (undefined4 *)thunk_FUN_005df0f5((int)local_48 * 4); + local_6c = (int *)0xffffffff; + local_7c = (char *)0x0; + local_68 = puVar6; + if (local_48 != (char *)0x0) { + iVar8 = 0; + iVar5 = local_74[0] - (int)puVar6; + do { + piVar11 = (int *)(iVar8 + (int)local_50); + FUN_00402710(iVar5 + (int)puVar6,"%ix%i",*(undefined4 *)(iVar8 + (int)local_50), + *(undefined4 *)(iVar8 + 4 + (int)local_50)); + *puVar6 = *(undefined4 *)(iVar8 + 0xc + (int)local_50); + if ((*piVar11 == 0x400) && (piVar11[1] == 0x300)) { + local_6c = (int *)piVar11[3]; + } + local_7c = local_7c + 1; + iVar8 = iVar8 + 0x10; + puVar6 = puVar6 + 1; + } while (local_7c < local_48); + } + uVar13 = 0; + local_7c = (char *)0x0; + local_78 = 0; + FUN_00435390(local_3c); + local_60 = (void *)thunk_FUN_005df0f5(local_3c * 4); + pcVar4 = local_7c; + if (local_3c != 0) { + iVar5 = (int)local_60 - (int)local_7c; + do { + iVar8 = *(int *)((int)local_44 + uVar13 * 4); + if (iVar8 == 0) { + FUN_00405000(&DAT_00794fb0); + } + else { + FUN_00402710(pcVar4 + uVar13 * 4,&DAT_00799e78,iVar8); + } + *(undefined4 *)(pcVar4 + uVar13 * 4 + iVar5) = *(undefined4 *)((int)local_44 + uVar13 * 4); + uVar13 = uVar13 + 1; + } while (uVar13 < local_3c); + } + DAT_00818b68 = 1; + DAT_00818b64 = local_6c; + DAT_00818b6c = 0; + pcVar10 = "Selects display resolution"; + do { + pcVar9 = pcVar10; + pcVar10 = pcVar9 + 1; + } while (*pcVar9 != '\0'); + FUN_00401280(pcVar9 + -0x799e5c); + pcVar9 = "Selects display resolution"; + pcVar10 = local_7c; + do { + cVar3 = *pcVar9; + pcVar9 = pcVar9 + 1; + *pcVar10 = cVar3; + pcVar10 = pcVar10 + 1; + } while (cVar3 != '\0'); + FUN_004369a0(&DAT_00818b64,4,&DAT_008381c8,&local_7c,0,local_48,local_74[0],local_68); + if (DAT_008380c8 == 0) { + iVar5 = FUN_005df0f5(0x8100); + if (iVar5 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar3 = FUN_00433710(&DAT_008381c8,&local_6c); + if ((cVar3 != '\0') && (iVar5 = (**(code **)(*local_6c + 0x44))(), iVar5 != 0)) { + *(undefined1 *)(iVar5 + 0x28) = 1; + } + pcVar10 = local_7c + -0x14; + LVar7 = InterlockedDecrement((LONG *)(local_7c + -0x10)); + if ((LVar7 == 0) && (pcVar10 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar10)(1); + } + pcVar10 = "Enables full screen mode"; + do { + pcVar9 = pcVar10; + pcVar10 = pcVar9 + 1; + } while (*pcVar9 != '\0'); + FUN_00401280(pcVar9 + -0x799e40); + pcVar9 = "Enables full screen mode"; + pcVar10 = local_7c; + do { + cVar3 = *pcVar9; + pcVar9 = pcVar9 + 1; + *pcVar10 = cVar3; + pcVar10 = pcVar10 + 1; + } while (cVar3 != '\0'); + FUN_004369a0(&DAT_00818b68,2,&DAT_008381cc,&local_7c,0,0,0,0); + if (DAT_008380c8 == 0) { + iVar5 = FUN_005df0f5(0x8100); + if (iVar5 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar3 = FUN_00433710(&DAT_008381cc,&local_6c); + if ((cVar3 != '\0') && (iVar5 = (**(code **)(*local_6c + 0x44))(), iVar5 != 0)) { + *(undefined1 *)(iVar5 + 0x28) = 1; + } + pcVar10 = local_7c + -0x14; + LVar7 = InterlockedDecrement((LONG *)(local_7c + -0x10)); + if ((LVar7 == 0) && (pcVar10 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar10)(1); + } + pcVar10 = "Selects full screen refresh rate."; + do { + pcVar9 = pcVar10; + pcVar10 = pcVar9 + 1; + } while (*pcVar9 != '\0'); + FUN_00401280(pcVar9 + -0x799e1c); + pvVar1 = local_60; + pcVar9 = "Selects full screen refresh rate."; + pcVar10 = local_7c; + do { + cVar3 = *pcVar9; + pcVar9 = pcVar9 + 1; + *pcVar10 = cVar3; + pcVar10 = pcVar10 + 1; + } while (cVar3 != '\0'); + FUN_004369a0(&DAT_00818b6c,4,&DAT_008381d0,&local_7c,0,local_3c,pcVar4,local_60); + if (DAT_008380c8 == 0) { + iVar5 = FUN_005df0f5(0x8100); + if (iVar5 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar3 = FUN_00433710(&DAT_008381d0,&local_6c); + if ((cVar3 != '\0') && (iVar5 = (**(code **)(*local_6c + 0x44))(), iVar5 != 0)) { + *(undefined1 *)(iVar5 + 0x28) = 1; + } + pcVar10 = local_7c + -0x14; + LVar7 = InterlockedDecrement((LONG *)(local_7c + -0x10)); + if ((LVar7 == 0) && (pcVar10 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar10)(1); + } + pcVar10 = + "Syncs frames with the display\'s vertical refresh rate (eliminates tearing but reduces performance)" + ; + do { + pcVar9 = pcVar10; + pcVar10 = pcVar9 + 1; + } while (*pcVar9 != '\0'); + FUN_00401280(pcVar9 + -0x799db8); + pcVar9 = + "Syncs frames with the display\'s vertical refresh rate (eliminates tearing but reduces performance)" + ; + pcVar10 = local_7c; + do { + cVar3 = *pcVar9; + pcVar9 = pcVar9 + 1; + *pcVar10 = cVar3; + pcVar10 = pcVar10 + 1; + } while (cVar3 != '\0'); + FUN_004369a0(&DAT_00818b71,2,&DAT_008381d4,&local_7c,0,0,0,0); + if (DAT_008380c8 == 0) { + iVar5 = FUN_005df0f5(0x8100); + if (iVar5 == 0) { + DAT_008380c8 = 0; + } + else { + DAT_008380c8 = FUN_00433d20(); + } + } + cVar3 = FUN_00433710(&DAT_008381d4,&local_6c); + if ((cVar3 != '\0') && (iVar5 = (**(code **)(*local_6c + 0x44))(), iVar5 != 0)) { + *(undefined1 *)(iVar5 + 0x28) = 1; + } + pcVar10 = local_7c + -0x14; + LVar7 = InterlockedDecrement((LONG *)(local_7c + -0x10)); + if ((LVar7 == 0) && (pcVar10 != (char *)0x0)) { + (*(code *)**(undefined4 **)pcVar10)(1); + } + operator_delete__(pvVar1); + if (pcVar4 != (char *)0x0) { + iVar5 = *(int *)(pcVar4 + -4); + pcVar10 = pcVar4 + iVar5 * 4; + if (-1 < iVar5 + -1) { + do { + piVar11 = (int *)(pcVar10 + -4); + pcVar10 = pcVar10 + -4; + puVar6 = (undefined4 *)(*piVar11 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(*piVar11 + -0x10)); + if ((LVar7 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + iVar5 = iVar5 + -1; + } while (iVar5 != 0); + } + operator_delete__(pcVar4 + -4); + } + operator_delete__(local_68); + if (local_74[0] != 0) { + iVar8 = *(int *)(local_74[0] + -4); + pvVar1 = (void *)(local_74[0] + -4); + iVar5 = local_74[0] + iVar8 * 4; + if (-1 < iVar8 + -1) { + do { + piVar11 = (int *)(iVar5 + -4); + iVar5 = iVar5 + -4; + puVar6 = (undefined4 *)(*piVar11 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(*piVar11 + -0x10)); + if ((LVar7 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + iVar8 = iVar8 + -1; + } while (iVar8 != 0); + } + operator_delete__(pvVar1); + } + if ((local_40 & 0x80000000) == 0x80000000) { + operator_delete__(local_44); + } + if ((local_4c & 0x80000000) == 0x80000000) { + operator_delete__(local_50); + } + return 1; +} + + + +// --- FUN_0043ba60 at 0x0043BA60 (size: 1417) --- + +undefined4 +FUN_0043ba60(undefined4 param_1,undefined4 *param_2,undefined4 param_3,char param_4,char param_5, + uint *param_6) + +{ + bool bVar1; + char cVar2; + ATOM AVar3; + HMENU pHVar4; + BOOL BVar5; + HMODULE hInstance; + DWORD DVar6; + int iVar7; + int iVar8; + int iVar9; + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined4 extraout_ECX_01; + undefined4 extraout_ECX_02; + undefined4 extraout_ECX_03; + undefined4 uVar10; + undefined4 extraout_ECX_04; + undefined4 extraout_ECX_05; + undefined4 extraout_ECX_06; + undefined4 extraout_ECX_07; + int nWidth; + int iVar11; + undefined4 unaff_retaddr; + undefined4 uVar12; + undefined4 uVar13; + undefined4 uVar14; + undefined4 uVar15; + uint local_f8; + int local_f4; + int local_f0; + int local_ec; + int local_e8; + int local_e4; + int local_e0; + HMODULE local_dc; + undefined4 local_d8; + int local_d4; + int local_d0; + char local_cc; + WNDCLASSA local_bc; + _OSVERSIONINFOA local_94; + + if (DAT_00838196 != '\0') { + return 0; + } + pHVar4 = GetMenu(DAT_008381a4); + if (pHVar4 == (HMENU)0x0) { + DAT_00818b01 = 0; + } + local_94.dwOSVersionInfoSize = 0x94; + BVar5 = GetVersionExA(&local_94); + uVar10 = extraout_ECX; + if (BVar5 == 0) { + uVar15 = 0; + FUN_00402730(&DAT_00795320); + uVar14 = extraout_ECX_06; + FUN_00402730(&DAT_00795320); + uVar13 = extraout_ECX_07; + FUN_00402730(&DAT_00795320); + uVar12 = 0x6b; + goto LAB_0043bfcd; + } + iVar11 = 0; + DAT_0083819c = local_94.dwPlatformId; + if (local_94.dwPlatformId == 0) { + uVar15 = 0; + FUN_00402730(&DAT_00795320); + uVar14 = extraout_ECX_00; + FUN_00402730(&DAT_00795320); + uVar13 = extraout_ECX_01; + FUN_00402730(&DAT_00795320); + uVar12 = 0x6a; + goto LAB_0043bfcd; + } + hInstance = GetModuleHandleA((LPCSTR)(-(uint)(*(int *)(*param_6 - 4) != 1) & *param_6)); + if (*(int *)(*param_6 - 4) != 1) { + DAT_008381a8 = 1; + } + if (DAT_0086734c != 0) { + return 0; + } + local_f0 = 1; + local_dc = hInstance; + cVar2 = FUN_0054d0c0(&local_f0); + if (cVar2 == '\0') { + return 0; + } + cVar2 = FUN_0043b2d0(); + if (cVar2 == '\0') { + return 0; + } + FUN_00439140(); + cVar2 = FUN_00439370(&local_d8); + if (cVar2 == '\0') { + return 0; + } + if ((DAT_00818b02 == '\0') || (bVar1 = false, local_cc == '\0')) { + bVar1 = true; + } + local_bc.lpfnWndProc = (WNDPROC)&LAB_00439860; + local_bc.cbClsExtra = 0; + local_bc.cbWndExtra = 0; + local_bc.style = 0; + local_bc.hInstance = hInstance; + local_bc.hIcon = LoadIconA(hInstance,(LPCSTR)0x65); + local_bc.hbrBackground = GetStockObject(4); + local_bc.lpszMenuName = (LPCSTR)*param_2; + local_bc.hCursor = (HCURSOR)0x0; + local_bc.lpszClassName = "Turbine Device Class"; + AVar3 = RegisterClassA(&local_bc); + if ((AVar3 != 0) || (DVar6 = GetLastError(), uVar10 = extraout_ECX_02, DVar6 == 0x582)) { + local_f8 = (-(uint)bVar1 & 0x80ca0000) + 0x82000000; + if (param_5 != '\0') { + local_f8 = local_f8 | 0x10000000; + } + nWidth = local_d4; + iVar7 = local_d0; + iVar8 = 0; + if (bVar1) { + iVar11 = GetSystemMetrics(7); + local_f0 = iVar11; + iVar7 = GetSystemMetrics(8); + iVar8 = GetSystemMetrics(4); + iVar9 = GetSystemMetrics(0); + nWidth = local_d4 + iVar11 * 2; + iVar7 = iVar8 + iVar7 * 2 + local_d0; + iVar11 = iVar9 / 2 - nWidth / 2; + iVar8 = GetSystemMetrics(1); + iVar8 = iVar8 / 2 - iVar7 / 2; + BVar5 = SystemParametersInfoA(0x30,0x10,&local_ec,0); + if (BVar5 != 0) { + local_f4 = local_e0 - local_e8; + if (local_e4 - local_ec < nWidth) { + iVar11 = local_ec - local_f0; + } + else { + if (local_e4 < nWidth + iVar11) { + iVar11 = (local_e4 - local_ec) - nWidth; + } + if (iVar11 < local_ec) { + iVar11 = local_ec; + } + } + if (iVar7 <= local_f4) { + if (local_e0 < iVar8 + iVar7) { + iVar8 = local_f4 - iVar7; + } + if (local_e8 <= iVar8) goto LAB_0043bd0b; + } + iVar8 = local_e8; + } + } +LAB_0043bd0b: + DAT_008381a4 = CreateWindowExA(0,"Turbine Device Class",(LPCSTR)*param_2,local_f8,iVar11,iVar8, + nWidth,iVar7,(HWND)0x0,(HMENU)0x0,local_dc,(LPVOID)0x0); + uVar10 = extraout_ECX_03; + if (DAT_008381a4 != (HWND)0x0) { + iVar11 = FUN_005df0f5(0x3f8); + if (iVar11 == 0) { + DAT_00837ff4 = (int *)0x0; + } + else { + DAT_00837ff4 = (int *)FUN_006895d0(); + } + cVar2 = (**(code **)(*DAT_00837ff4 + 4))(DAT_008381a4); + if (cVar2 != '\x01') { + return 0; + } + if (param_4 != '\0') { + ShowWindow(DAT_008381a4,1); + UpdateWindow(DAT_008381a4); + SetForegroundWindow(DAT_008381a4); + SetActiveWindow(DAT_008381a4); + SetWindowPos(DAT_008381a4,(HWND)(-1 - (uint)((char)unaff_retaddr != '\0')),0,0,0,0,0x153); + } + cVar2 = FUN_0043ad90(local_d8,local_d4,unaff_retaddr); + if (cVar2 == '\0') { + return 0; + } + iVar11 = FUN_005df0f5(8); + if (iVar11 == 0) { + DAT_008381ac = 0; + } + else { + DAT_008381ac = FUN_00439210(); + } + FUN_00401340("Exits the application"); + FUN_00401340(&DAT_00799d90); + FUN_00436580(&LAB_00439830,&local_f8,&stack0xffffff04); + FUN_004011b0(); + FUN_004011b0(); + FUN_00401340("Exits the application"); + FUN_00401340(&DAT_00799d88); + FUN_00436580(&LAB_00439830,&local_f8,&stack0xffffff04); + FUN_004011b0(); + FUN_004011b0(); + FUN_00401340("Restarts the rendering engine and applies new display settings"); + FUN_00401340("UpdatePresentation"); + FUN_00436580(FUN_0043a510,&local_f8,&stack0xffffff04); + FUN_004011b0(); + FUN_004011b0(); + FUN_00401340("ForceDisplayResolution [ ]"); + FUN_00401340( + "Forces the display resolution to the specified width and height. Pass no parameters to restore normal resolution." + ); + FUN_00401340("ForceDisplayResolution"); + FUN_004366d0(FUN_0043aa70,&local_f8,&stack0xffffff04,&local_f4); + FUN_004011b0(); + FUN_004011b0(); + FUN_004011b0(); + SetThreadExecutionState(0x80000001); + DAT_00838196 = 1; + return 1; + } + } + uVar15 = 0; + FUN_00402730(&DAT_00795320); + uVar14 = extraout_ECX_04; + FUN_00402730(&DAT_00795320); + uVar13 = extraout_ECX_05; + FUN_00402730(&DAT_00795320); + uVar12 = 0x7f; +LAB_0043bfcd: + FUN_0043d090(uVar12,uVar13,uVar14,uVar10,uVar15); + DAT_00838194 = 1; + return 0; +} + + + +// --- FUN_0043bff0 at 0x0043BFF0 (size: 460) --- + +HBITMAP FUN_0043bff0(int param_1,int param_2,HBITMAP param_3) + +{ + int iVar1; + int iVar2; + uint uVar3; + uint uVar4; + HDC hdc; + HDC hdc_00; + HDC hdc_01; + HBITMAP ho; + uint uVar5; + uint *puVar6; + uint uVar7; + uint *local_40; + HBITMAP local_3c; + HGDIOBJ local_38; + HGDIOBJ local_34; + HDC local_30; + BITMAPINFO local_2c; + + local_2c.bmiHeader.biWidth = param_3[1].unused; + local_2c.bmiHeader.biHeight = param_3[2].unused; + local_2c.bmiHeader.biSizeImage = local_2c.bmiHeader.biHeight * local_2c.bmiHeader.biWidth * 4; + local_2c.bmiHeader.biSize = 0x28; + local_2c.bmiHeader.biPlanes = 1; + local_2c.bmiHeader.biBitCount = 0x20; + local_2c.bmiHeader.biCompression = 0; + local_2c.bmiHeader.biXPelsPerMeter = 0; + local_2c.bmiHeader.biYPelsPerMeter = 0; + local_2c.bmiHeader.biClrUsed = 0; + local_2c.bmiHeader.biClrImportant = 0; + local_40 = (uint *)0x0; + local_3c = CreateDIBSection((HDC)0x0,&local_2c,0,&local_40,(HANDLE)0x0,0); + if (local_3c == (HBITMAP)0x0) { + return (HBITMAP)0x0; + } + uVar4 = *(uint *)(param_3 + 2); + uVar7 = 0; + puVar6 = local_40; + if (uVar4 != 0) { + do { + iVar1 = param_3->unused; + iVar2 = param_3[3].unused; + uVar5 = 0; + if (param_3[1].unused != 0) { + do { + uVar3 = *(uint *)(iVar1 + (((uVar4 - uVar7) + -1) * iVar2 & 0xfffffffc) + uVar5 * 4); + if ((uVar3 & 0xff000000) < 0x40000000) { + *puVar6 = 0; + } + else { + *puVar6 = uVar3; + } + puVar6 = puVar6 + 1; + uVar5 = uVar5 + 1; + } while (uVar5 < *(uint *)(param_3 + 1)); + } + uVar4 = *(uint *)(param_3 + 2); + uVar7 = uVar7 + 1; + } while (uVar7 < uVar4); + } + hdc = GetDC((HWND)0x0); + local_30 = hdc; + hdc_00 = CreateCompatibleDC(hdc); + hdc_01 = CreateCompatibleDC(hdc); + ho = CreateCompatibleBitmap(hdc,param_1,param_2); + if ((hdc_00 == (HDC)0x0) || (hdc_01 == (HDC)0x0)) { + if (ho != (HBITMAP)0x0) { + DeleteObject(ho); + param_3 = (HBITMAP)0x0; + ho = param_3; + } + } + else if (ho != (HBITMAP)0x0) { + local_34 = SelectObject(hdc_01,local_3c); + local_38 = SelectObject(hdc_00,ho); + PatBlt(hdc_00,0,0,param_1,param_2,0x42); + BitBlt(hdc_00,0,0,param_3[1].unused,param_3[2].unused,hdc_01,0,0,0xcc0020); + SelectObject(hdc_00,local_38); + SelectObject(hdc_01,local_34); + hdc = local_30; + } + param_3 = ho; + if (hdc != (HDC)0x0) { + ReleaseDC((HWND)0x0,hdc); + } + if (hdc_01 != (HDC)0x0) { + DeleteDC(hdc_01); + } + if (hdc_00 != (HDC)0x0) { + DeleteDC(hdc_00); + } + DeleteObject(local_3c); + return param_3; +} + + + +// --- FUN_0043c1c0 at 0x0043C1C0 (size: 602) --- + +HBITMAP FUN_0043c1c0(uint param_1,uint param_2,int *param_3,char param_4) + +{ + int iVar1; + int iVar2; + byte *lpBits; + uint uVar3; + HBITMAP pHVar4; + byte bVar5; + uint uVar6; + uint uVar7; + byte bVar8; + uint uVar9; + int iVar10; + uint uVar11; + byte *pbVar12; + uint local_c; + uint local_8; + + local_c = param_2; + if (param_4 != '\0') { + local_c = param_2 * 2; + } + uVar9 = (param_1 >> 3) * local_c; + bVar8 = 0xff; + if ((uVar9 == 0) || ((param_1 & 7) != 0)) { + return (HBITMAP)0x0; + } + lpBits = (byte *)thunk_FUN_005df0f5(uVar9); + pbVar12 = lpBits; + for (uVar6 = uVar9 >> 2; uVar6 != 0; uVar6 = uVar6 - 1) { + pbVar12[0] = 0xff; + pbVar12[1] = 0xff; + pbVar12[2] = 0xff; + pbVar12[3] = 0xff; + pbVar12 = pbVar12 + 4; + } + for (uVar6 = uVar9 & 3; uVar6 != 0; uVar6 = uVar6 - 1) { + *pbVar12 = 0xff; + pbVar12 = pbVar12 + 1; + } + uVar6 = param_1; + if ((uint)param_3[1] < param_1) { + uVar6 = param_3[1]; + } + if ((uint)param_3[2] < param_2) { + param_2 = param_3[2]; + } + local_8 = 0; + pbVar12 = lpBits; + if (param_2 != 0) { + do { + iVar1 = param_3[3]; + iVar2 = *param_3; + iVar10 = 0; + uVar3 = 0; + if (uVar6 == 0) { +LAB_0043c2af: + iVar10 = 8 - iVar10; + do { + bVar8 = bVar8 << 1 | 1; + iVar10 = iVar10 + -1; + } while (iVar10 != 0); + } + else { + do { + if (iVar10 == 8) { + *pbVar12 = bVar8; + pbVar12 = pbVar12 + 1; + bVar8 = 0xff; + iVar10 = 0; + } + iVar10 = iVar10 + 1; + bVar8 = bVar8 << 1 | + (*(uint *)(iVar2 + (iVar1 * local_8 & 0xfffffffc) + uVar3 * 4) & 0xff000000) < + 0x40000000; + uVar3 = uVar3 + 1; + } while (uVar3 < uVar6); + if (iVar10 < 8) goto LAB_0043c2af; + } + *pbVar12 = bVar8; + pbVar12 = pbVar12 + 1; + if (uVar6 < param_1) { + pbVar12 = pbVar12 + (param_1 - uVar6 >> 3); + } + local_8 = local_8 + 1; + } while (local_8 < param_2); + } + if (param_4 != '\0') { + pbVar12 = lpBits + (int)uVar9 / 2; + _param_4 = 0; + if (param_2 != 0) { + do { + iVar1 = param_3[3]; + iVar2 = *param_3; + iVar10 = 0; + uVar9 = 0; + if (uVar6 == 0) { +LAB_0043c3a3: + iVar10 = 8 - iVar10; + do { + bVar8 = bVar8 << 1 | 1; + iVar10 = iVar10 + -1; + } while (iVar10 != 0); + } + else { + do { + if (iVar10 == 8) { + *pbVar12 = bVar8; + pbVar12 = pbVar12 + 1; + bVar8 = 0xff; + iVar10 = 0; + } + uVar3 = *(uint *)(iVar2 + (iVar1 * _param_4 & 0xfffffffc) + uVar9 * 4); + iVar10 = iVar10 + 1; + if ((uVar3 & 0xff000000) < 0x40000000) { +LAB_0043c391: + bVar5 = 0; + } + else { + uVar11 = uVar3 >> 8 & 0xff; + uVar7 = uVar3 >> 0x10 & 0xff; + if (uVar7 <= uVar11) { + uVar7 = uVar11; + } + if (uVar7 <= (uVar3 & 0xff)) { + uVar7 = uVar3 & 0xff; + } + if (uVar7 < 0x41) goto LAB_0043c391; + bVar5 = 1; + } + bVar8 = bVar8 << 1 | bVar5; + uVar9 = uVar9 + 1; + } while (uVar9 < uVar6); + if (iVar10 < 8) goto LAB_0043c3a3; + } + *pbVar12 = bVar8; + pbVar12 = pbVar12 + 1; + if (uVar6 < param_1) { + pbVar12 = pbVar12 + (param_1 - uVar6 >> 3); + } + _param_4 = _param_4 + 1; + } while (_param_4 < param_2); + } + } + pHVar4 = CreateBitmap(param_1,local_c,1,1,lpBits); + operator_delete__(lpBits); + return pHVar4; +} + + + +// --- FUN_0043c420 at 0x0043C420 (size: 125) --- + +HICON FUN_0043c420(undefined4 param_1,DWORD param_2,DWORD param_3,undefined4 param_4) + +{ + HBITMAP ho; + HICON pHVar1; + HBITMAP ho_00; + ICONINFO local_14; + + pHVar1 = (HICON)0x0; + ho_00 = (HBITMAP)0x0; + if ((char)param_4 == '\0') { + ho_00 = (HBITMAP)FUN_0043bff0(0x20,0x20,param_1); + } + ho = (HBITMAP)FUN_0043c1c0(0x20,0x20,param_1,param_4); + if (ho != (HBITMAP)0x0) { + local_14.fIcon = 0; + local_14.xHotspot = param_2; + local_14.yHotspot = param_3; + local_14.hbmMask = ho; + local_14.hbmColor = ho_00; + pHVar1 = CreateIconIndirect(&local_14); + } + DeleteObject(ho_00); + DeleteObject(ho); + return pHVar1; +} + + + +// --- FUN_0043c4a0 at 0x0043C4A0 (size: 365) --- + +bool FUN_0043c4a0(undefined4 param_1,undefined4 param_2,int param_3,undefined4 *param_4) + +{ + char cVar1; + int *piVar2; + undefined4 uVar3; + bool bVar4; + undefined1 auStack_4c [4]; + int iStack_48; + int iStack_44; + undefined4 uStack_40; + undefined **ppuStack_3c; + undefined4 uStack_c; + undefined4 uStack_8; + undefined4 uStack_4; + + *param_4 = 0; + bVar4 = false; + if (((*(uint *)(param_3 + 0xa0) < 0x21) && (*(uint *)(param_3 + 0xa4) < 0x21)) && + (*(int *)(param_3 + 0x114) == 0)) { + piVar2 = (int *)(**(code **)(*DAT_00870340 + 0x10))(); + cVar1 = (**(code **)(*piVar2 + 0x58))(0x20,0x20,0x15,1); + if (cVar1 != '\0') { + FUN_00443040(&DAT_00838328); + FUN_00441d40(piVar2,0,0,*(int *)(param_3 + 0xa0) + -1,*(int *)(param_3 + 0xa4) + -1); + FUN_00443290(param_3 + 0xac); + cVar1 = (**(code **)(*piVar2 + 0x60))(&stack0xffffffa4,2,&uStack_4,&stack0x00000000); + bVar4 = cVar1 != '\0'; + if (bVar4) { + iStack_48 = piVar2[0x28]; + iStack_44 = piVar2[0x29]; + uStack_40 = uStack_4; + uVar3 = FUN_0043c420(auStack_4c,uStack_c,uStack_8,DAT_00870340[0xc9] == 0); + *param_4 = uVar3; + (**(code **)(*piVar2 + 100))(); + } + ppuStack_3c = &PTR_FUN_00799d14; + FUN_00440f40(); + } + (**(code **)(*piVar2 + 0x14))(); + return bVar4; + } + return false; +} + + + +// --- FUN_0043c610 at 0x0043C610 (size: 44) --- + +void __fastcall FUN_0043c610(undefined4 *param_1) + +{ + int *piVar1; + + *param_1 = &PTR_FUN_00801670; + piVar1 = (int *)FUN_0043c680(); + if (piVar1 != (int *)0x0) { + (**(code **)(*piVar1 + 0xc))(param_1); + } + if (DAT_00842adc != 0) { + FUN_00508980(param_1); + } + return; +} + + + +// --- FUN_0043c640 at 0x0043C640 (size: 24) --- + +undefined4 * __fastcall FUN_0043c640(undefined4 *param_1) + +{ + FUN_0043c6c0(); + *param_1 = &PTR_FUN_00799fc4; + DAT_00838374 = param_1; + return param_1; +} + + + +// --- FUN_0043c660 at 0x0043C660 (size: 21) --- + +void __fastcall FUN_0043c660(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_00799fc4; + DAT_00838374 = 0; + FUN_0043c850(); + return; +} + + + +// --- FUN_0043c680 at 0x0043C680 (size: 6) --- + +undefined4 FUN_0043c680(void) + +{ + return DAT_00838374; +} + + + +// --- FUN_0043c690 at 0x0043C690 (size: 46) --- + +undefined4 * __thiscall FUN_0043c690(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00799fc4; + DAT_00838374 = 0; + FUN_0043c850(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0043c6c0 at 0x0043C6C0 (size: 16) --- + +void __fastcall FUN_0043c6c0(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_00799fd8; + param_1[1] = 0; + return; +} + + + +// --- FUN_0043c6d0 at 0x0043C6D0 (size: 44) --- + +void __fastcall FUN_0043c6d0(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_00799ff0; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + return; +} + + + +// --- FUN_0043c700 at 0x0043C700 (size: 64) --- + +undefined4 * __thiscall FUN_0043c700(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00799ff0; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0043c740 at 0x0043C740 (size: 127) --- + +void __fastcall FUN_0043c740(int param_1) + +{ + int iVar1; + int *piVar2; + int iVar3; + undefined1 local_c [12]; + + if (*(int *)(param_1 + 4) != 0) { + piVar2 = (int *)FUN_0052dcf0(local_c); + iVar3 = piVar2[2]; + iVar1 = *piVar2; + piVar2 = (int *)piVar2[1]; + while (iVar3 != 0) { + do { + if (*(undefined4 **)(iVar3 + 8) != (undefined4 *)0x0) { + (**(code **)**(undefined4 **)(iVar3 + 8))(1); + } + iVar3 = *(int *)(iVar3 + 4); + } while (iVar3 != 0); + do { + piVar2 = piVar2 + 1; + if (piVar2 == (int *)(*(int *)(iVar1 + 0x60) + *(int *)(iVar1 + 0x68) * 4)) + goto LAB_0043c7a3; + iVar3 = *piVar2; + } while (iVar3 == 0); + } +LAB_0043c7a3: + if (*(undefined4 **)(param_1 + 4) != (undefined4 *)0x0) { + (**(code **)**(undefined4 **)(param_1 + 4))(1); + } + *(undefined4 *)(param_1 + 4) = 0; + } + return; +} + + + +// --- FUN_0043c800 at 0x0043C800 (size: 66) --- + +uint __thiscall FUN_0043c800(int param_1,undefined4 *param_2) + +{ + undefined4 *puVar1; + uint in_EAX; + int iVar2; + + puVar1 = *(undefined4 **)(param_1 + 4); + if (puVar1 == (undefined4 *)0x0) { + return in_EAX & 0xffffff00; + } + iVar2 = puVar1[1]; + *(int *)(param_1 + 4) = iVar2; + if (iVar2 == 0) { + *(undefined4 *)(param_1 + 8) = 0; + } + else { + *(undefined4 *)(iVar2 + 8) = 0; + } + *param_2 = *puVar1; + operator_delete(puVar1); + iVar2 = *(int *)(param_1 + 0xc) + -1; + *(int *)(param_1 + 0xc) = iVar2; + return CONCAT31((int3)((uint)iVar2 >> 8),1); +} + + + +// --- FUN_0043c850 at 0x0043C850 (size: 11) --- + +void __fastcall FUN_0043c850(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_00799fd8; + FUN_0043c740(); + return; +} + + + +// --- FUN_0043c950 at 0x0043C950 (size: 36) --- + +undefined4 * __thiscall FUN_0043c950(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00799fd8; + FUN_0043c740(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0043c980 at 0x0043C980 (size: 143) --- + +undefined4 * __thiscall FUN_0043c980(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_00799ff0; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_0043cb20 at 0x0043CB20 (size: 50) --- + +undefined4 * __thiscall FUN_0043cb20(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_00799ff4; + FUN_005870f0(); + FUN_0043c6d0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0043cb60 at 0x0043CB60 (size: 340) --- + +/* WARNING: Function: __chkstk replaced with injection: alloca_probe */ + +undefined4 * __thiscall FUN_0043cb60(undefined4 *param_1,undefined4 *param_2,ushort param_3) + +{ + int iVar1; + LONG LVar2; + undefined4 *puVar3; + undefined *local_300c; + CHAR local_3008 [4072]; + undefined1 auStack_2020 [24]; + undefined2 local_2008; + undefined4 local_2006 [2046]; + undefined4 uStack_c; + + uStack_c = 0x43cb70; + if ((HINSTANCE)*param_1 == (HINSTANCE)0x0) { + local_300c = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + FUN_004027b0(&local_300c,L"",param_3); + *param_2 = local_300c; + InterlockedIncrement((LONG *)(local_300c + -0x10)); + puVar3 = (undefined4 *)(local_300c + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_300c + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + } + else { + iVar1 = LoadStringA((HINSTANCE)*param_1,(uint)param_3,local_3008,0x1000); + if (iVar1 != 0) { + local_2008 = 0; + puVar3 = local_2006; + for (iVar1 = 0x7ff; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = 0; + puVar3 = puVar3 + 1; + } + *(undefined2 *)puVar3 = 0; + (*(code *)PTR_FUN_00837394)(0,1,local_3008,0xffffffff,&local_2008,0x1000); + FUN_00402730(auStack_2020); + return param_2; + } + local_300c = PTR_DAT_00818340; + InterlockedIncrement((LONG *)(PTR_DAT_00818340 + -0x10)); + FUN_004027b0(&local_300c,L"",(uint)param_3); + *param_2 = local_300c; + InterlockedIncrement((LONG *)(local_300c + -0x10)); + puVar3 = (undefined4 *)(local_300c + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_300c + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + return param_2; + } + } + return param_2; +} + + + +// --- FUN_0043ccc0 at 0x0043CCC0 (size: 440) --- + +int * FUN_0043ccc0(int *param_1,undefined4 param_2,int param_3,int param_4,int param_5) + +{ + size_t sVar1; + LONG LVar2; + wchar_t *pwVar3; + undefined4 *puVar4; + int local_8; + wchar_t *local_4; + + FUN_0043cb60(&local_8,param_2); + sVar1 = wcslen(L"%1"); + FUN_004022d0(sVar1); + wcscpy(local_4,L"%1"); + FUN_0040d870(&local_4,¶m_3); + pwVar3 = local_4 + -10; + LVar2 = InterlockedDecrement((LONG *)(local_4 + -8)); + if ((LVar2 == 0) && (pwVar3 != (wchar_t *)0x0)) { + (*(code *)**(undefined4 **)pwVar3)(1); + } + sVar1 = wcslen(L"%2"); + FUN_004022d0(sVar1); + wcscpy(local_4,L"%2"); + FUN_0040d870(&local_4,¶m_4); + pwVar3 = local_4 + -10; + LVar2 = InterlockedDecrement((LONG *)(local_4 + -8)); + if ((LVar2 == 0) && (pwVar3 != (wchar_t *)0x0)) { + (*(code *)**(undefined4 **)pwVar3)(1); + } + sVar1 = wcslen(L"%3"); + FUN_004022d0(sVar1); + wcscpy(local_4,L"%3"); + FUN_0040d870(&local_4,¶m_5); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -8)); + if ((LVar2 == 0) && (local_4 + -10 != (wchar_t *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -10))(1); + } + *param_1 = local_8; + InterlockedIncrement((LONG *)(local_8 + -0x10)); + LVar2 = InterlockedDecrement((LONG *)(local_8 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(local_8 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_8 + -0x14))(1); + } + puVar4 = (undefined4 *)(param_3 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + puVar4 = (undefined4 *)(param_4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_4 + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + puVar4 = (undefined4 *)(param_5 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_5 + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + return param_1; +} + + + +// --- FUN_0043ce80 at 0x0043CE80 (size: 519) --- + +void FUN_0043ce80(int param_1,int param_2) + +{ + size_t sVar1; + LONG LVar2; + undefined4 uVar3; + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined4 extraout_ECX_01; + undefined4 extraout_ECX_02; + undefined4 extraout_ECX_03; + undefined4 extraout_ECX_04; + undefined4 unaff_EBX; + undefined4 *puVar4; + int unaff_EDI; + undefined8 uVar5; + undefined4 uVar6; + undefined4 uVar7; + wchar_t *local_1c; + int local_18; + int local_14; + undefined8 local_10; + undefined4 local_4; + + uVar5 = FUN_0040e560(); + local_4 = (undefined4)((ulonglong)uVar5 >> 0x20); + local_10 = FUN_0040e620(); + sVar1 = wcslen(L"ERROR"); + FUN_004022d0(sVar1); + wcscpy(local_1c,L"ERROR"); + uVar3 = 0x50000; + if (param_2 == 0) { + uVar7 = 0x50000; + FUN_00402730(&DAT_00795320); + uVar6 = extraout_ECX_03; + FUN_00402730(&DAT_00795320); + uVar3 = extraout_ECX_04; + FUN_00402730(&DAT_00795320); + uVar3 = FUN_0043ccc0(&local_14,0xb,uVar3,uVar6,uVar7); + FUN_00402070(uVar3); + puVar4 = (undefined4 *)(local_14 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_14 + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + uVar3 = 0x50010; + } + else if (param_2 == 1) { + uVar7 = 0x50000; + FUN_00402730(&DAT_00795320); + uVar6 = extraout_ECX_01; + FUN_00402730(&DAT_00795320); + uVar3 = extraout_ECX_02; + FUN_00402730(&DAT_00795320); + uVar3 = FUN_0043ccc0(&local_18,0xc,uVar3,uVar6,uVar7); + FUN_00402070(uVar3); + LVar2 = InterlockedDecrement((LONG *)(local_18 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(local_18 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_18 + -0x14))(1); + } + uVar3 = 0x50030; + } + else if (param_2 == 2) { + uVar7 = 0x50000; + FUN_00402730(&DAT_00795320); + uVar6 = extraout_ECX; + FUN_00402730(&DAT_00795320); + uVar3 = extraout_ECX_00; + FUN_00402730(&DAT_00795320); + uVar3 = FUN_0043ccc0(¶m_2,0xd,uVar3,uVar6,uVar7); + FUN_00402070(uVar3); + puVar4 = (undefined4 *)(param_2 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar2 == 0) && (puVar4 != (undefined4 *)0x0)) { + (**(code **)*puVar4)(1); + } + uVar3 = 0x50040; + } + (*(code *)PTR_FUN_008373ac)(0,param_1,local_1c,uVar3); + FUN_0040e690((int)uVar5,local_14); + FUN_0040e5d0(unaff_EBX,local_1c); + LVar2 = InterlockedDecrement((LONG *)(unaff_EDI + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(unaff_EDI + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(unaff_EDI + -0x14))(1); + } + LVar2 = InterlockedDecrement((LONG *)(param_1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(param_1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(param_1 + -0x14))(1); + } + return; +} + + + +// --- FUN_0043d090 at 0x0043D090 (size: 180) --- + +void FUN_0043d090(undefined4 param_1,int param_2,int param_3,int param_4) + +{ + LONG LVar1; + int iVar2; + int iVar3; + int iVar4; + undefined4 uStack_18; + + iVar4 = param_4; + InterlockedIncrement((LONG *)(param_4 + -0x10)); + iVar3 = param_3; + InterlockedIncrement((LONG *)(param_3 + -0x10)); + iVar2 = param_2; + InterlockedIncrement((LONG *)(param_2 + -0x10)); + FUN_0043ccc0(&uStack_18,param_1,iVar2,iVar3,iVar4); + FUN_0043ce80(); + uStack_18 = 0x43d102; + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(param_2 + -0x14) != (undefined4 *)0x0)) { + uStack_18 = 0x43d112; + (*(code *)**(undefined4 **)(param_2 + -0x14))(); + } + uStack_18 = 0x43d118; + LVar1 = InterlockedDecrement((LONG *)(param_3 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(param_3 + -0x14) != (undefined4 *)0x0)) { + uStack_18 = 0x43d128; + (*(code *)**(undefined4 **)(param_3 + -0x14))(); + } + uStack_18 = 0x43d12e; + LVar1 = InterlockedDecrement((LONG *)(param_4 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(param_4 + -0x14) != (undefined4 *)0x0)) { + uStack_18 = 0x43d13f; + (*(code *)**(undefined4 **)(param_4 + -0x14))(); + } + return; +} + + + +// --- FUN_0043d150 at 0x0043D150 (size: 314) --- + +void __fastcall FUN_0043d150(int param_1) + +{ + uint uVar1; + uint uVar2; + uint uVar3; + uint uVar4; + byte bVar5; + byte bVar6; + byte bVar7; + byte bVar8; + char cVar9; + int iVar10; + byte bVar11; + + uVar1 = *(uint *)(param_1 + 0x10); + bVar5 = 0; + do { + if ((uVar1 >> (bVar5 & 0x1f) & 1) != 0) goto LAB_0043d174; + bVar5 = bVar5 + 1; + } while (bVar5 < 0x20); + bVar5 = 0; +LAB_0043d174: + uVar2 = *(uint *)(param_1 + 0x14); + *(byte *)(param_1 + 0x24) = bVar5; + bVar6 = 0; + do { + if ((uVar2 >> (bVar6 & 0x1f) & 1) != 0) goto LAB_0043d196; + bVar6 = bVar6 + 1; + } while (bVar6 < 0x20); + bVar6 = 0; +LAB_0043d196: + uVar3 = *(uint *)(param_1 + 0x18); + *(byte *)(param_1 + 0x25) = bVar6; + bVar7 = 0; + do { + if ((uVar3 >> (bVar7 & 0x1f) & 1) != 0) goto LAB_0043d1b8; + bVar7 = bVar7 + 1; + } while (bVar7 < 0x20); + bVar7 = 0; +LAB_0043d1b8: + uVar4 = *(uint *)(param_1 + 0x1c); + *(byte *)(param_1 + 0x26) = bVar7; + bVar8 = 0; + do { + if ((uVar4 >> (bVar8 & 0x1f) & 1) != 0) goto LAB_0043d1d6; + bVar8 = bVar8 + 1; + } while (bVar8 < 0x20); + bVar8 = 0; +LAB_0043d1d6: + cVar9 = '\0'; + *(byte *)(param_1 + 0x27) = bVar8; + bVar11 = 0; + iVar10 = 0x20; + do { + cVar9 = cVar9 + ((byte)(uVar1 >> (bVar11 & 0x1f)) & 1); + bVar11 = bVar11 + 1; + iVar10 = iVar10 + -1; + } while (iVar10 != 0); + *(char *)(param_1 + 0x20) = cVar9; + cVar9 = '\0'; + bVar11 = 0; + iVar10 = 0x20; + do { + cVar9 = cVar9 + ((byte)(uVar2 >> (bVar11 & 0x1f)) & 1); + bVar11 = bVar11 + 1; + iVar10 = iVar10 + -1; + } while (iVar10 != 0); + *(char *)(param_1 + 0x21) = cVar9; + cVar9 = '\0'; + bVar11 = 0; + iVar10 = 0x20; + do { + cVar9 = cVar9 + ((byte)(uVar3 >> (bVar11 & 0x1f)) & 1); + bVar11 = bVar11 + 1; + iVar10 = iVar10 + -1; + } while (iVar10 != 0); + *(char *)(param_1 + 0x22) = cVar9; + cVar9 = '\0'; + bVar11 = 0; + iVar10 = 0x20; + do { + cVar9 = cVar9 + ((byte)(uVar4 >> (bVar11 & 0x1f)) & 1); + bVar11 = bVar11 + 1; + iVar10 = iVar10 + -1; + } while (iVar10 != 0); + *(char *)(param_1 + 0x23) = cVar9; + *(uint *)(param_1 + 0x28) = uVar1 >> (bVar5 & 0x1f); + *(uint *)(param_1 + 0x2c) = uVar2 >> (bVar6 & 0x1f); + *(uint *)(param_1 + 0x30) = uVar3 >> (bVar7 & 0x1f); + *(uint *)(param_1 + 0x34) = uVar4 >> (bVar8 & 0x1f); + return; +} + + + +// --- FUN_0043d290 at 0x0043D290 (size: 1050) --- + +undefined4 __thiscall FUN_0043d290(int *param_1,int param_2) + +{ + *param_1 = param_2; + param_1[1] = 0; + param_1[2] = 0; + *(undefined1 *)(param_1 + 3) = 0; + param_1[7] = 0; + param_1[6] = 0; + param_1[5] = 0; + param_1[4] = 0; + *(undefined1 *)((int)param_1 + 0x27) = 0; + *(undefined1 *)((int)param_1 + 0x26) = 0; + *(undefined1 *)((int)param_1 + 0x25) = 0; + *(undefined1 *)(param_1 + 9) = 0; + if (0x29 < param_2) { + if (param_2 < 0xf2) { + if (param_2 != 0xf1) { + switch(param_2) { + case 0x3c: + param_1[1] = 9; + *(undefined1 *)(param_1 + 3) = 0x10; + param_1[4] = 0xff00; + param_1[5] = 0xff; + param_1[6] = 0; + FUN_0043d150(); + return 1; + default: + return 0; + case 0x46: + case 0x50: + param_1[1] = 2; + *(undefined1 *)(param_1 + 3) = 0x10; + param_1[7] = 0xffff; + FUN_0043d150(); + return 1; + case 0x47: + param_1[1] = 2; + *(undefined1 *)(param_1 + 3) = 0x20; + param_1[7] = -1; + FUN_0043d150(); + return 1; + case 0x49: + param_1[1] = 2; + *(undefined1 *)(param_1 + 3) = 0x10; + param_1[7] = 0xfffe; + FUN_0043d150(); + return 1; + case 0x4b: + case 0x4d: + case 0x4f: + param_1[1] = 2; + *(undefined1 *)(param_1 + 3) = 0x20; + param_1[7] = -0x100; + FUN_0043d150(); + return 1; + case 0x65: + param_1[1] = 0x40; + *(undefined1 *)(param_1 + 3) = 0x10; + FUN_0043d150(); + return 1; + case 0xf0: + param_1[1] = 3; + *(undefined1 *)(param_1 + 3) = 0x20; + param_1[4] = -0x1000000; + param_1[5] = 0xff0000; + param_1[6] = 0xff00; + param_1[7] = 0xff; + FUN_0043d150(); + return 1; + } + } + param_1[1] = 3; + *(undefined1 *)(param_1 + 3) = 0x20; + param_1[4] = 0xff; + param_1[5] = 0xff00; + param_1[6] = 0xff0000; + param_1[7] = -0x1000000; + FUN_0043d150(); + return 1; + } + if (0x31545844 < param_2) { + if (param_2 < 0x34545845) { + if (param_2 == 0x34545844) { + param_1[2] = 0x34545844; + } + else if (param_2 == 0x32545844) { + param_1[2] = 0x32545844; + } + else { + if (param_2 != 0x33545844) { + return 0; + } + param_1[2] = 0x33545844; + } + } + else { + if (param_2 != 0x35545844) { + return 0; + } + param_1[2] = 0x35545844; + } + param_1[1] = 4; + *(undefined1 *)(param_1 + 3) = 8; + FUN_0043d150(); + return 1; + } + if (param_2 == 0x31545844) { + param_1[1] = 4; + param_1[2] = 0x31545844; + *(undefined1 *)(param_1 + 3) = 4; + FUN_0043d150(); + return 1; + } + if (0xf4 < param_2) { + if (param_2 != 500) { + return 0; + } + param_1[1] = 0x11; + FUN_0043d150(); + return 1; + } + if (param_2 == 0xf4) goto switchD_0043d2de_caseD_8; + if (param_2 == 0xf2) { + param_1[1] = 1; + *(undefined1 *)(param_1 + 3) = 0x18; + param_1[4] = 0xff; + param_1[5] = 0xff00; + param_1[6] = 0xff0000; + FUN_0043d150(); + return 1; + } + if (param_2 != 0xf3) { + return 0; + } +switchD_0043d2de_caseD_0: + *(undefined1 *)(param_1 + 3) = 0x18; +LAB_0043d5b5: + param_1[1] = 1; +LAB_0043d5b8: + param_1[4] = 0xff0000; + param_1[5] = 0xff00; + param_1[6] = 0xff; + FUN_0043d150(); + return 1; + } + if (param_2 == 0x29) { + param_1[1] = 0x40; + *(undefined1 *)(param_1 + 3) = 8; + FUN_0043d150(); + return 1; + } + switch(param_2 + -0x14) { + case 0: + goto switchD_0043d2de_caseD_0; + case 1: + param_1[1] = 3; + *(undefined1 *)(param_1 + 3) = 0x20; + param_1[7] = -0x1000000; + goto LAB_0043d5b8; + case 2: + *(undefined1 *)(param_1 + 3) = 0x20; + goto LAB_0043d5b5; + case 3: + param_1[1] = 1; + param_1[4] = 0xf800; + param_1[5] = 0x7e0; + *(undefined1 *)(param_1 + 3) = 0x10; + param_1[6] = 0x1f; + FUN_0043d150(); + return 1; + case 4: + param_1[1] = 1; + break; + case 5: + param_1[1] = 3; + param_1[7] = 0x8000; + break; + case 6: + param_1[1] = 3; + param_1[7] = 0xf000; + goto LAB_0043d376; + default: + return 0; + case 8: +switchD_0043d2de_caseD_8: + param_1[1] = 2; + param_1[7] = 0xff; + *(undefined1 *)(param_1 + 3) = 8; + FUN_0043d150(); + return 1; + case 10: + param_1[1] = 1; +LAB_0043d376: + *(undefined1 *)(param_1 + 3) = 0x10; + param_1[4] = 0xf00; + param_1[5] = 0xf0; + param_1[6] = 0xf; + FUN_0043d150(); + return 1; + case 0xb: + param_1[1] = 3; + *(undefined1 *)(param_1 + 3) = 0x20; + param_1[7] = -0x40000000; + param_1[6] = 0x3ff00000; + param_1[5] = 0xffc00; + param_1[4] = 0x3ff; + FUN_0043d150(); + return 1; + case 0xc: + param_1[1] = 3; + param_1[7] = -0x1000000; + goto LAB_0043d3db; + case 0xd: + param_1[1] = 1; +LAB_0043d3db: + *(undefined1 *)(param_1 + 3) = 0x20; + param_1[6] = 0xff0000; + param_1[5] = 0xff00; + param_1[4] = 0xff; + FUN_0043d150(); + return 1; + case 0xf: + param_1[1] = 3; + *(undefined1 *)(param_1 + 3) = 0x20; + param_1[7] = -0x40000000; + param_1[4] = 0x3ff00000; + param_1[5] = 0xffc00; + param_1[6] = 0x3ff; + FUN_0043d150(); + return 1; + } + param_1[4] = 0x7c00; + param_1[5] = 0x3e0; + *(undefined1 *)(param_1 + 3) = 0x10; + param_1[6] = 0x1f; + FUN_0043d150(); + return 1; +} + + + +// --- FUN_0043d7d0 at 0x0043D7D0 (size: 19) --- + +undefined4 __thiscall FUN_0043d7d0(undefined4 param_1,undefined4 param_2) + +{ + FUN_0043d290(param_2); + return param_1; +} + + + +// --- FUN_0043d7f0 at 0x0043D7F0 (size: 40) --- + +undefined4 FUN_0043d7f0(int param_1,int param_2) + +{ + if ((((-1 < param_1) && (-1 < param_2)) && (param_1 < 0x7f8)) && (param_2 < 0x7f8)) { + return 1; + } + return 0; +} + + + +// --- FUN_0043d820 at 0x0043D820 (size: 75) --- + +undefined4 FUN_0043d820(uint param_1,uint *param_2,uint *param_3) + +{ + uint uVar1; + + if (param_1 != 0) { + *param_2 = param_1 >> 0x15 & 0x7f8; + uVar1 = (param_1 >> 0x10 & 0xff) * 8; + *param_3 = uVar1; + if (((-1 < (int)*param_2) && ((int)*param_2 < 0x7f8)) && (uVar1 < 0x7f8)) { + return 1; + } + } + return 0; +} + + + +// --- FUN_0043d870 at 0x0043D870 (size: 30) --- + +undefined4 FUN_0043d870(float param_1,float param_2,float param_3) + +{ + if (ABS(param_1 - param_2) < param_3 != (ABS(param_1 - param_2) == param_3)) { + return 1; + } + return 0; +} + + + +// --- FUN_0043d890 at 0x0043D890 (size: 31) --- + +void __thiscall FUN_0043d890(float *param_1,float param_2) + +{ + *param_1 = param_2 * *param_1; + param_1[1] = param_2 * param_1[1]; + param_1[2] = param_2 * param_1[2]; + return; +} + + + +// --- FUN_0043d8b0 at 0x0043D8B0 (size: 37) --- + +void __thiscall FUN_0043d8b0(float *param_1,float *param_2,float *param_3) + +{ + float fVar1; + float fVar2; + float fVar3; + float fVar4; + + fVar1 = param_3[1]; + fVar2 = param_1[1]; + fVar3 = param_3[2]; + fVar4 = param_1[2]; + *param_2 = *param_3 + *param_1; + param_2[1] = fVar1 + fVar2; + param_2[2] = fVar3 + fVar4; + return; +} + + + +// --- FUN_0043d8e0 at 0x0043D8E0 (size: 37) --- + +void __thiscall FUN_0043d8e0(float *param_1,float *param_2,float *param_3) + +{ + float fVar1; + float fVar2; + float fVar3; + float fVar4; + + fVar1 = param_1[1]; + fVar2 = param_3[1]; + fVar3 = param_1[2]; + fVar4 = param_3[2]; + *param_2 = *param_1 - *param_3; + param_2[1] = fVar1 - fVar2; + param_2[2] = fVar3 - fVar4; + return; +} + + + +// --- FUN_0043d910 at 0x0043D910 (size: 37) --- + +void __thiscall FUN_0043d910(float *param_1,float *param_2,float param_3) + +{ + float fVar1; + float fVar2; + + fVar1 = param_1[1]; + fVar2 = param_1[2]; + *param_2 = param_3 * *param_1; + param_2[1] = param_3 * fVar1; + param_2[2] = param_3 * fVar2; + return; +} + + + +// --- FUN_0043d940 at 0x0043D940 (size: 128) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __thiscall FUN_0043d940(float *param_1,float *param_2,float *param_3) + +{ + float fVar1; + + fVar1 = _DAT_007938b0 / + (param_1[7] * param_2[1] + param_1[0xb] * param_2[2] + param_1[3] * *param_2 + + param_1[0xf]); + *param_3 = (*param_2 * *param_1 + param_1[4] * param_2[1] + param_1[8] * param_2[2] + param_1[0xc] + ) * fVar1; + param_3[1] = (param_1[5] * param_2[1] + param_1[9] * param_2[2] + param_1[1] * *param_2 + + param_1[0xd]) * fVar1; + param_3[2] = (param_1[6] * param_2[1] + param_1[10] * param_2[2] + param_1[2] * *param_2 + + param_1[0xe]) * fVar1; + return; +} + + + +// --- FUN_0043d9c0 at 0x0043D9C0 (size: 530) --- + +void __thiscall FUN_0043d9c0(float *param_1,float *param_2,float *param_3) + +{ + *param_1 = param_2[3] * param_3[0xc] + + param_2[1] * param_3[4] + param_3[8] * param_2[2] + *param_2 * *param_3; + param_1[1] = param_3[0xd] * param_2[3] + + param_2[1] * param_3[5] + *param_2 * param_3[1] + param_3[9] * param_2[2]; + param_1[2] = param_3[0xe] * param_2[3] + + param_2[1] * param_3[6] + param_3[10] * param_2[2] + *param_2 * param_3[2]; + param_1[3] = param_3[0xb] * param_2[2] + + param_3[3] * *param_2 + param_2[3] * param_3[0xf] + param_2[1] * param_3[7]; + param_1[4] = param_2[4] * *param_3 + + param_2[7] * param_3[0xc] + param_3[8] * param_2[6] + param_2[5] * param_3[4]; + param_1[5] = param_3[0xd] * param_2[7] + + param_3[9] * param_2[6] + param_3[5] * param_2[5] + param_2[4] * param_3[1]; + param_1[6] = param_2[4] * param_3[2] + + param_3[0xe] * param_2[7] + param_3[10] * param_2[6] + param_2[5] * param_3[6]; + param_1[7] = param_2[5] * param_3[7] + + param_2[6] * param_3[0xb] + param_2[7] * param_3[0xf] + param_2[4] * param_3[3]; + param_1[8] = param_2[8] * *param_3 + + param_2[0xb] * param_3[0xc] + param_3[8] * param_2[10] + param_2[9] * param_3[4]; + param_1[9] = param_3[9] * param_2[10] + + param_3[0xd] * param_2[0xb] + param_3[5] * param_2[9] + param_2[8] * param_3[1]; + param_1[10] = param_2[8] * param_3[2] + + param_3[10] * param_2[10] + param_3[0xe] * param_2[0xb] + param_2[9] * param_3[6]; + param_1[0xb] = param_2[9] * param_3[7] + + param_2[10] * param_3[0xb] + param_2[0xb] * param_3[0xf] + param_2[8] * param_3[3]; + param_1[0xc] = param_2[0xc] * *param_3 + + param_2[0xf] * param_3[0xc] + param_3[8] * param_2[0xe] + param_2[0xd] * param_3[4] + ; + param_1[0xd] = param_3[9] * param_2[0xe] + + param_3[0xd] * param_2[0xf] + param_3[5] * param_2[0xd] + param_2[0xc] * param_3[1] + ; + param_1[0xe] = param_2[0xc] * param_3[2] + + param_3[10] * param_2[0xe] + + param_3[0xe] * param_2[0xf] + param_2[0xd] * param_3[6]; + param_1[0xf] = param_2[0xd] * param_3[7] + + param_2[0xe] * param_3[0xb] + + param_2[0xf] * param_3[0xf] + param_2[0xc] * param_3[3]; + return; +} + + + +// --- FUN_0043dbe0 at 0x0043DBE0 (size: 80) --- + +uint FUN_0043dbe0(void) + +{ + int iVar1; + uint uVar2; + uint uVar3; + uint uVar4; + + iVar1 = FUN_005df4c4(); + uVar2 = FUN_005df4c4(); + uVar3 = FUN_005df4c4(); + uVar4 = FUN_005df4c4(); + return uVar4 | ((iVar1 << 8 | uVar2) << 8 | uVar3) << 8; +} + + + +// --- FUN_0043dc30 at 0x0043DC30 (size: 24) --- + +float * FUN_0043dc30(float *param_1,float *param_2) + +{ + if (*param_1 <= *param_2) { + param_2 = param_1; + } + return param_2; +} + + + +// --- FUN_0043dc50 at 0x0043DC50 (size: 32) --- + +void __thiscall FUN_0043dc50(int param_1,undefined4 *param_2) + +{ + *(undefined4 *)(param_1 + 0x7c) = *param_2; + *(undefined4 *)(param_1 + 0x80) = param_2[1]; + *(undefined4 *)(param_1 + 0x84) = param_2[2]; + *(undefined4 *)(param_1 + 0x88) = param_2[3]; + return; +} + + + +// --- FUN_0043dc70 at 0x0043DC70 (size: 94) --- + +void FUN_0043dc70(void) + +{ + undefined4 local_10; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + if ((char)DAT_00870340[0x2b] == '\0') { + DAT_00818c08 = DAT_00818c08 + 1; + local_10 = 0; + local_c = 0; + local_8 = 0; + local_4 = 0x3f800000; + (**(code **)(*DAT_00870340 + 0x2c))(7,&local_10,0x3f800000); + (**(code **)(*DAT_00870340 + 0x20))(); + } + return; +} + + + +// --- FUN_0043dcd0 at 0x0043DCD0 (size: 88) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_0043dcd0(int param_1,int param_2,float *param_3,float *param_4) + +{ + float fVar1; + float fVar2; + float fVar3; + + fVar1 = _DAT_007938b0 / (float)*(int *)(DAT_00870340 + 0x94); + fVar3 = _DAT_007938b0 / (float)*(int *)(DAT_00870340 + 0x98); + fVar2 = (float)param_1 * fVar1; + *param_3 = (fVar2 + fVar2) - _DAT_007938b0; + fVar2 = (float)param_2 * fVar3; + *param_4 = -((fVar2 + fVar2) - _DAT_007938b0); + *param_3 = *param_3 - fVar1; + *param_4 = *param_4 - fVar3; + return; +} + + + +// --- FUN_0043dd30 at 0x0043DD30 (size: 2315) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 FUN_0043dd30(void) + +{ + char cVar1; + uint uVar2; + undefined4 *puVar3; + undefined4 unaff_ESI; + int *unaff_EDI; + float10 fVar4; + float10 fVar5; + int *local_54; + float local_50 [20]; + + if ((_DAT_00838750 & 1) == 0) { + _DAT_00838750 = _DAT_00838750 | 1; + _DAT_00838748 = 0x769cf0e0; + _DAT_0083874c = 0x3fe41b2f; + } + fVar4 = (float10)_DAT_00795610; + uVar2 = 0; + do { + uVar2 = uVar2 + 1; + fVar5 = (float10)fcos(fVar4); + local_50[uVar2 * 2 + -2] = (float)fVar5; + fVar5 = (float10)fsin(fVar4); + local_50[uVar2 * 2 + -1] = (float)fVar5; + fVar4 = fVar4 + (float10)(double)CONCAT44(_DAT_0083874c,_DAT_00838748); + } while (uVar2 < 10); + cVar1 = FUN_00446600(0,0,4,0xffffffff,0x6c,2,1,1,&local_54); + if (cVar1 != '\0') { + puVar3 = (undefined4 *)(**(code **)(*local_54 + 0xc))(0,0x6c); + puVar3[1] = local_54; + *puVar3 = unaff_ESI; + puVar3[2] = 0x3f000000; + puVar3[3] = local_50[0]; + puVar3[4] = local_50[1]; + puVar3[5] = 0x3f000000; + puVar3[6] = local_50[2]; + puVar3[7] = local_50[3]; + puVar3[8] = 0x3f000000; + puVar3[9] = unaff_ESI; + puVar3[10] = local_54; + puVar3[0xb] = 0x3f000000; + puVar3[0xc] = local_50[2]; + puVar3[0xd] = local_50[3]; + puVar3[0xe] = 0x3f000000; + puVar3[0xf] = local_50[4]; + puVar3[0x10] = local_50[5]; + puVar3[0x11] = 0x3f000000; + puVar3[0x12] = unaff_ESI; + puVar3[0x13] = local_54; + puVar3[0x14] = 0x3f000000; + puVar3[0x15] = local_50[4]; + puVar3[0x16] = local_50[5]; + puVar3[0x17] = 0x3f000000; + puVar3[0x18] = local_50[6]; + puVar3[0x19] = local_50[7]; + puVar3[0x1a] = 0x3f000000; + puVar3[0x1b] = unaff_ESI; + puVar3[0x1c] = local_54; + puVar3[0x1d] = 0x3f000000; + puVar3[0x1e] = local_50[6]; + puVar3[0x1f] = local_50[7]; + puVar3[0x20] = 0x3f000000; + puVar3[0x21] = local_50[8]; + puVar3[0x22] = local_50[9]; + puVar3[0x23] = 0x3f000000; + puVar3[0x24] = unaff_ESI; + puVar3[0x26] = 0x3f000000; + puVar3[0x25] = local_54; + puVar3[0x29] = 0x3f000000; + puVar3[0x27] = local_50[8]; + puVar3[0x28] = local_50[9]; + puVar3[0x2a] = local_50[10]; + puVar3[0x2c] = 0x3f000000; + puVar3[0x2b] = local_50[0xb]; + puVar3[0x2d] = unaff_ESI; + puVar3[0x2e] = local_54; + puVar3[0x2f] = 0x3f000000; + puVar3[0x30] = local_50[10]; + puVar3[0x31] = local_50[0xb]; + puVar3[0x32] = 0x3f000000; + puVar3[0x33] = local_50[0xc]; + puVar3[0x34] = local_50[0xd]; + puVar3[0x35] = 0x3f000000; + puVar3[0x36] = unaff_ESI; + puVar3[0x37] = local_54; + puVar3[0x38] = 0x3f000000; + puVar3[0x39] = local_50[0xc]; + puVar3[0x3a] = local_50[0xd]; + puVar3[0x3b] = 0x3f000000; + puVar3[0x3c] = local_50[0xe]; + puVar3[0x3d] = local_50[0xf]; + puVar3[0x3e] = 0x3f000000; + puVar3[0x3f] = unaff_ESI; + puVar3[0x40] = local_54; + puVar3[0x41] = 0x3f000000; + puVar3[0x42] = local_50[0xe]; + puVar3[0x43] = local_50[0xf]; + puVar3[0x44] = 0x3f000000; + puVar3[0x45] = local_50[0x10]; + puVar3[0x46] = local_50[0x11]; + puVar3[0x47] = 0x3f000000; + puVar3[0x48] = local_50[2]; + puVar3[0x49] = local_50[3]; + puVar3[0x4a] = 0xbf000000; + puVar3[0x4b] = local_50[0]; + puVar3[0x4c] = local_50[1]; + puVar3[0x4d] = 0xbf000000; + puVar3[0x50] = 0xbf000000; + puVar3[0x4e] = unaff_ESI; + puVar3[0x4f] = local_54; + puVar3[0x51] = local_50[4]; + puVar3[0x53] = 0xbf000000; + puVar3[0x52] = local_50[5]; + puVar3[0x54] = local_50[2]; + puVar3[0x55] = local_50[3]; + puVar3[0x56] = 0xbf000000; + puVar3[0x57] = unaff_ESI; + puVar3[0x58] = local_54; + puVar3[0x59] = 0xbf000000; + puVar3[0x5a] = local_50[6]; + puVar3[0x5b] = local_50[7]; + puVar3[0x5c] = 0xbf000000; + puVar3[0x5d] = local_50[4]; + puVar3[0x5e] = local_50[5]; + puVar3[0x5f] = 0xbf000000; + puVar3[0x60] = unaff_ESI; + puVar3[0x61] = local_54; + puVar3[0x62] = 0xbf000000; + puVar3[99] = local_50[8]; + puVar3[100] = local_50[9]; + puVar3[0x65] = 0xbf000000; + puVar3[0x66] = local_50[6]; + puVar3[0x67] = local_50[7]; + puVar3[0x68] = 0xbf000000; + puVar3[0x69] = unaff_ESI; + puVar3[0x6a] = local_54; + puVar3[0x6b] = 0xbf000000; + puVar3[0x6c] = local_50[10]; + puVar3[0x6d] = local_50[0xb]; + puVar3[0x6e] = 0xbf000000; + puVar3[0x6f] = local_50[8]; + puVar3[0x70] = local_50[9]; + puVar3[0x71] = 0xbf000000; + puVar3[0x72] = unaff_ESI; + puVar3[0x73] = local_54; + puVar3[0x74] = 0xbf000000; + puVar3[0x75] = local_50[0xc]; + puVar3[0x77] = 0xbf000000; + puVar3[0x76] = local_50[0xd]; + puVar3[0x7a] = 0xbf000000; + puVar3[0x78] = local_50[10]; + puVar3[0x79] = local_50[0xb]; + puVar3[0x7b] = unaff_ESI; + puVar3[0x7d] = 0xbf000000; + puVar3[0x7c] = local_54; + puVar3[0x7e] = local_50[0xe]; + puVar3[0x80] = 0xbf000000; + puVar3[0x7f] = local_50[0xf]; + puVar3[0x81] = local_50[0xc]; + puVar3[0x82] = local_50[0xd]; + puVar3[0x83] = 0xbf000000; + puVar3[0x84] = unaff_ESI; + puVar3[0x85] = local_54; + puVar3[0x86] = 0xbf000000; + puVar3[0x87] = local_50[0x10]; + puVar3[0x88] = local_50[0x11]; + puVar3[0x89] = 0xbf000000; + puVar3[0x8a] = local_50[0xe]; + puVar3[0x8b] = local_50[0xf]; + puVar3[0x8c] = 0xbf000000; + puVar3[0x8d] = unaff_ESI; + puVar3[0x8e] = local_54; + puVar3[0x8f] = 0xbf000000; + puVar3[0x90] = unaff_ESI; + puVar3[0x91] = local_54; + puVar3[0x92] = 0xbf000000; + puVar3[0x93] = local_50[0]; + puVar3[0x94] = local_50[1]; + puVar3[0x95] = 0x3f000000; + puVar3[0x96] = unaff_ESI; + puVar3[0x97] = local_54; + puVar3[0x98] = 0x3f000000; + puVar3[0x99] = unaff_ESI; + puVar3[0x9a] = local_54; + puVar3[0x9b] = 0xbf000000; + puVar3[0x9c] = local_50[0]; + puVar3[0x9d] = local_50[1]; + puVar3[0x9e] = 0xbf000000; + puVar3[0xa1] = 0x3f000000; + puVar3[0x9f] = local_50[0]; + puVar3[0xa0] = local_50[1]; + puVar3[0xa2] = local_50[0]; + puVar3[0xa4] = 0xbf000000; + puVar3[0xa3] = local_50[1]; + puVar3[0xa5] = local_50[2]; + puVar3[0xa7] = 0x3f000000; + puVar3[0xa6] = local_50[3]; + puVar3[0xa8] = local_50[0]; + puVar3[0xa9] = local_50[1]; + puVar3[0xaa] = 0x3f000000; + puVar3[0xab] = local_50[0]; + puVar3[0xac] = local_50[1]; + puVar3[0xad] = 0xbf000000; + puVar3[0xae] = local_50[2]; + puVar3[0xaf] = local_50[3]; + puVar3[0xb0] = 0xbf000000; + puVar3[0xb1] = local_50[2]; + puVar3[0xb2] = local_50[3]; + puVar3[0xb3] = 0x3f000000; + puVar3[0xb4] = local_50[2]; + puVar3[0xb5] = local_50[3]; + puVar3[0xb6] = 0xbf000000; + puVar3[0xb7] = local_50[4]; + puVar3[0xb8] = local_50[5]; + puVar3[0xb9] = 0x3f000000; + puVar3[0xba] = local_50[2]; + puVar3[0xbb] = local_50[3]; + puVar3[0xbc] = 0x3f000000; + puVar3[0xbd] = local_50[2]; + puVar3[0xbe] = local_50[3]; + puVar3[0xbf] = 0xbf000000; + puVar3[0xc0] = local_50[4]; + puVar3[0xc1] = local_50[5]; + puVar3[0xc2] = 0xbf000000; + puVar3[0xc3] = local_50[4]; + puVar3[0xc4] = local_50[5]; + puVar3[0xc5] = 0x3f000000; + puVar3[0xc6] = local_50[4]; + puVar3[200] = 0xbf000000; + puVar3[199] = local_50[5]; + puVar3[0xcb] = 0x3f000000; + puVar3[0xc9] = local_50[6]; + puVar3[0xca] = local_50[7]; + puVar3[0xcc] = local_50[4]; + puVar3[0xce] = 0x3f000000; + puVar3[0xcd] = local_50[5]; + puVar3[0xcf] = local_50[4]; + puVar3[0xd1] = 0xbf000000; + puVar3[0xd0] = local_50[5]; + puVar3[0xd2] = local_50[6]; + puVar3[0xd3] = local_50[7]; + puVar3[0xd4] = 0xbf000000; + puVar3[0xd5] = local_50[6]; + puVar3[0xd6] = local_50[7]; + puVar3[0xd7] = 0x3f000000; + puVar3[0xd8] = local_50[6]; + puVar3[0xd9] = local_50[7]; + puVar3[0xda] = 0xbf000000; + puVar3[0xdb] = local_50[8]; + puVar3[0xdc] = local_50[9]; + puVar3[0xdd] = 0x3f000000; + puVar3[0xde] = local_50[6]; + puVar3[0xdf] = local_50[7]; + puVar3[0xe0] = 0x3f000000; + puVar3[0xe1] = local_50[6]; + puVar3[0xe2] = local_50[7]; + puVar3[0xe3] = 0xbf000000; + puVar3[0xe4] = local_50[8]; + puVar3[0xe5] = local_50[9]; + puVar3[0xe6] = 0xbf000000; + puVar3[0xe7] = local_50[8]; + puVar3[0xe8] = local_50[9]; + puVar3[0xe9] = 0x3f000000; + puVar3[0xea] = local_50[8]; + puVar3[0xeb] = local_50[9]; + puVar3[0xec] = 0xbf000000; + puVar3[0xed] = local_50[10]; + puVar3[0xee] = local_50[0xb]; + puVar3[0xef] = 0x3f000000; + puVar3[0xf2] = 0x3f000000; + puVar3[0xf0] = local_50[8]; + puVar3[0xf1] = local_50[9]; + puVar3[0xf3] = local_50[8]; + puVar3[0xf5] = 0xbf000000; + puVar3[0xf4] = local_50[9]; + puVar3[0xf6] = local_50[10]; + puVar3[0xf8] = 0xbf000000; + puVar3[0xf7] = local_50[0xb]; + puVar3[0xf9] = local_50[10]; + puVar3[0xfa] = local_50[0xb]; + puVar3[0xfb] = 0x3f000000; + puVar3[0xfc] = local_50[10]; + puVar3[0xfd] = local_50[0xb]; + puVar3[0xfe] = 0xbf000000; + puVar3[0xff] = local_50[0xc]; + puVar3[0x100] = local_50[0xd]; + puVar3[0x101] = 0x3f000000; + puVar3[0x102] = local_50[10]; + puVar3[0x103] = local_50[0xb]; + puVar3[0x104] = 0x3f000000; + puVar3[0x105] = local_50[10]; + puVar3[0x106] = local_50[0xb]; + puVar3[0x107] = 0xbf000000; + puVar3[0x108] = local_50[0xc]; + puVar3[0x109] = local_50[0xd]; + puVar3[0x10a] = 0xbf000000; + puVar3[0x10b] = local_50[0xc]; + puVar3[0x10c] = local_50[0xd]; + puVar3[0x10d] = 0x3f000000; + puVar3[0x10e] = local_50[0xc]; + puVar3[0x10f] = local_50[0xd]; + puVar3[0x110] = 0xbf000000; + puVar3[0x111] = local_50[0xe]; + puVar3[0x112] = local_50[0xf]; + puVar3[0x113] = 0x3f000000; + puVar3[0x114] = local_50[0xc]; + puVar3[0x115] = local_50[0xd]; + puVar3[0x116] = 0x3f000000; + puVar3[0x117] = local_50[0xc]; + puVar3[0x119] = 0xbf000000; + puVar3[0x118] = local_50[0xd]; + puVar3[0x11c] = 0xbf000000; + puVar3[0x11a] = local_50[0xe]; + puVar3[0x11b] = local_50[0xf]; + puVar3[0x11d] = local_50[0xe]; + puVar3[0x11f] = 0x3f000000; + puVar3[0x11e] = local_50[0xf]; + puVar3[0x120] = local_50[0xe]; + puVar3[0x122] = 0xbf000000; + puVar3[0x121] = local_50[0xf]; + puVar3[0x123] = local_50[0x10]; + puVar3[0x124] = local_50[0x11]; + puVar3[0x125] = 0x3f000000; + puVar3[0x126] = local_50[0xe]; + puVar3[0x127] = local_50[0xf]; + puVar3[0x128] = 0x3f000000; + puVar3[0x129] = local_50[0xe]; + puVar3[0x12a] = local_50[0xf]; + puVar3[299] = 0xbf000000; + puVar3[300] = local_50[0x10]; + puVar3[0x12d] = local_50[0x11]; + puVar3[0x12e] = 0xbf000000; + puVar3[0x12f] = local_50[0x10]; + puVar3[0x130] = local_50[0x11]; + puVar3[0x131] = 0x3f000000; + puVar3[0x132] = local_50[0x10]; + puVar3[0x133] = local_50[0x11]; + puVar3[0x134] = 0xbf000000; + puVar3[0x135] = unaff_ESI; + puVar3[0x136] = local_54; + puVar3[0x137] = 0x3f000000; + puVar3[0x138] = local_50[0x10]; + puVar3[0x139] = local_50[0x11]; + puVar3[0x13a] = 0x3f000000; + puVar3[0x13b] = local_50[0x10]; + puVar3[0x13c] = local_50[0x11]; + puVar3[0x13d] = 0xbf000000; + puVar3[0x13e] = unaff_ESI; + puVar3[0x13f] = local_54; + puVar3[0x140] = 0xbf000000; + puVar3[0x141] = unaff_ESI; + puVar3[0x142] = local_54; + puVar3[0x143] = 0x3f000000; + (**(code **)(*unaff_EDI + 0x10))(0,0); + FUN_00446590(); + return 1; + } + return 0; +} + + + +// --- FUN_0043e640 at 0x0043E640 (size: 71) --- + +void FUN_0043e640(void) + +{ + int iVar1; + int iVar2; + undefined4 *puVar3; + undefined4 *puVar4; + + iVar1 = DAT_00870340; + puVar3 = (undefined4 *)(DAT_00870340 + 200); + puVar4 = &DAT_008386f8; + for (iVar2 = 0x10; iVar2 != 0; iVar2 = iVar2 + -1) { + *puVar4 = *puVar3; + puVar3 = puVar3 + 1; + puVar4 = puVar4 + 1; + } + puVar3 = (undefined4 *)(iVar1 + 0x108); + puVar4 = &DAT_00838678; + for (iVar2 = 0x10; iVar2 != 0; iVar2 = iVar2 + -1) { + *puVar4 = *puVar3; + puVar3 = puVar3 + 1; + puVar4 = puVar4 + 1; + } + puVar3 = (undefined4 *)(iVar1 + 0x148); + puVar4 = &DAT_008386b8; + for (iVar2 = 0x10; iVar2 != 0; iVar2 = iVar2 + -1) { + *puVar4 = *puVar3; + puVar3 = puVar3 + 1; + puVar4 = puVar4 + 1; + } + DAT_00838471 = 1; + return; +} + + + +// --- FUN_0043e690 at 0x0043E690 (size: 10) --- + +void FUN_0043e690(void) + +{ + FUN_0054f4a0(); + FUN_0054e460(); + return; +} + + + +// --- thunk_FUN_0043dc70 at 0x0043E6A0 (size: 5) --- + +void thunk_FUN_0043dc70(void) + +{ + undefined4 uStack_10; + undefined4 uStack_c; + undefined4 uStack_8; + undefined4 uStack_4; + + if ((char)DAT_00870340[0x2b] == '\0') { + DAT_00818c08 = DAT_00818c08 + 1; + uStack_10 = 0; + uStack_c = 0; + uStack_8 = 0; + uStack_4 = 0x3f800000; + (**(code **)(*DAT_00870340 + 0x2c))(7,&uStack_10,0x3f800000); + (**(code **)(*DAT_00870340 + 0x20))(); + } + return; +} + + + +// --- FUN_0043e6b0 at 0x0043E6B0 (size: 167) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_0043e6b0(void) + +{ + float fVar1; + uint uVar2; + uint uVar3; + undefined4 *puVar4; + float10 fVar5; + + fVar5 = (float10)FUN_0040fad0(); + fVar1 = (float)_DAT_00795610; + uVar2 = 0; + do { + uVar3 = uVar2 + 0x28; + fVar1 = fVar1 + *(float *)((int)&DAT_008383b8 + uVar2) + *(float *)((int)&DAT_008383bc + uVar2) + + *(float *)((int)&DAT_008383c0 + uVar2) + *(float *)((int)&DAT_008383c4 + uVar2) + + *(float *)((int)&DAT_008383c8 + uVar2) + *(float *)((int)&DAT_008383cc + uVar2) + + *(float *)((int)&DAT_008383d0 + uVar2) + *(float *)((int)&DAT_008383d4 + uVar2) + + *(float *)((int)&DAT_008383d8 + uVar2) + *(float *)((int)&DAT_008383dc + uVar2); + uVar2 = uVar3; + } while (uVar3 < 0x50); + DAT_00838418 = 0.0; + if (_DAT_0079a19c < fVar1) { + DAT_00838418 = (float)_DAT_0079a1a8 / fVar1; + } + puVar4 = &DAT_00838404; + do { + *puVar4 = puVar4[-1]; + puVar4 = puVar4 + -1; + } while (&DAT_008383b8 < puVar4); + DAT_008383b8 = (float)(fVar5 - (float10)_DAT_00838410); + _DAT_00838410 = (double)fVar5; + return; +} + + + +// --- FUN_0043e760 at 0x0043E760 (size: 98) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_0043e760(void) + +{ + undefined4 uVar1; + undefined4 uVar2; + char cVar3; + + uVar2 = DAT_008379b4; + uVar1 = DAT_008379b0; + if (_DAT_0079a1b0 < (double)CONCAT44(DAT_008379b4,DAT_008379b0) - _DAT_00838428) { + cVar3 = FUN_005a1570(); + if (cVar3 != '\0') { + FUN_00446dc0(0,0x405e0000); + } + _DAT_00838428 = uVar1; + _DAT_0083842c = uVar2; + } + return; +} + + + +// --- FUN_0043e7d0 at 0x0043E7D0 (size: 174) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_0043e7d0(float *param_1,uint param_2,uint param_3) + +{ + float fVar1; + int iVar2; + uint uVar3; + uint uVar4; + + if (param_2 >> 0x10 != param_3 >> 0x10) { + if (param_2 == 0) { + uVar3 = 0; + iVar2 = 0; + } + else { + uVar3 = param_2 >> 0x15 & 0x7f8; + iVar2 = (param_2 >> 0x10 & 0xff) << 3; + } + uVar4 = param_2; + if (param_3 != 0) { + param_2 = param_3 >> 0x15 & 0x7f8; + uVar4 = (param_3 >> 0x10 & 0xff) << 3; + } + fVar1 = (float)(int)(param_2 - uVar3) * _DAT_0079a128; + param_1[2] = 0.0; + *param_1 = fVar1; + param_1[1] = (float)(int)(uVar4 - iVar2) * _DAT_0079a128; + return; + } + *param_1 = _DAT_00838474; + param_1[1] = DAT_00838478; + param_1[2] = DAT_0083847c; + return; +} + + + +// --- FUN_0043e880 at 0x0043E880 (size: 59) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __fastcall FUN_0043e880(float *param_1) + +{ + float fVar1; + + fVar1 = _DAT_007938b0 / + SQRT(param_1[2] * param_1[2] + param_1[1] * param_1[1] + *param_1 * *param_1); + *param_1 = fVar1 * *param_1; + param_1[1] = fVar1 * param_1[1]; + param_1[2] = fVar1 * param_1[2]; + return; +} + + + +// --- FUN_0043e8c0 at 0x0043E8C0 (size: 31) --- + +int __thiscall FUN_0043e8c0(int param_1,int param_2) + +{ + *(undefined4 *)(param_1 + 4) = *(undefined4 *)(param_2 + 4); + FUN_00425f10(param_2 + 8); + return param_1; +} + + + +// --- FUN_0043e8e0 at 0x0043E8E0 (size: 28) --- + +void FUN_0043e8e0(int param_1) + +{ + DAT_00818c7c = *(undefined4 *)(param_1 + 4); + FUN_00425f10(param_1 + 8); + return; +} + + + +// --- FUN_0043e900 at 0x0043E900 (size: 135) --- + +void FUN_0043e900(int param_1) + +{ + undefined4 uVar1; + undefined4 uVar2; + undefined4 uVar3; + undefined4 uVar4; + + uVar2 = *(undefined4 *)(param_1 + 0x10); + uVar1 = *(undefined4 *)(param_1 + 4); + uVar3 = *(undefined4 *)(param_1 + 0x14); + *(undefined4 *)(param_1 + 4) = *(undefined4 *)(param_1 + 8); + uVar4 = *(undefined4 *)(param_1 + 0x18); + *(undefined4 *)(param_1 + 8) = uVar1; + uVar1 = *(undefined4 *)(param_1 + 0x34); + *(undefined4 *)(param_1 + 0x10) = *(undefined4 *)(param_1 + 0x20); + *(undefined4 *)(param_1 + 0x14) = *(undefined4 *)(param_1 + 0x28); + *(undefined4 *)(param_1 + 0x18) = *(undefined4 *)(param_1 + 0x24); + *(undefined4 *)(param_1 + 0x20) = uVar2; + *(undefined4 *)(param_1 + 0x24) = uVar4; + *(undefined4 *)(param_1 + 0x28) = uVar3; + *(undefined4 *)(param_1 + 0x34) = *(undefined4 *)(param_1 + 0x38); + *(undefined4 *)(param_1 + 0x38) = uVar1; + return; +} + + + +// --- FUN_0043e990 at 0x0043E990 (size: 135) --- + +void FUN_0043e990(int param_1) + +{ + undefined4 uVar1; + undefined4 uVar2; + undefined4 uVar3; + undefined4 uVar4; + + uVar2 = *(undefined4 *)(param_1 + 4); + uVar1 = *(undefined4 *)(param_1 + 0x10); + uVar3 = *(undefined4 *)(param_1 + 0x14); + *(undefined4 *)(param_1 + 0x10) = *(undefined4 *)(param_1 + 0x20); + uVar4 = *(undefined4 *)(param_1 + 0x24); + *(undefined4 *)(param_1 + 0x20) = uVar1; + uVar1 = *(undefined4 *)(param_1 + 0x34); + *(undefined4 *)(param_1 + 4) = *(undefined4 *)(param_1 + 8); + *(undefined4 *)(param_1 + 0x14) = *(undefined4 *)(param_1 + 0x28); + *(undefined4 *)(param_1 + 0x24) = *(undefined4 *)(param_1 + 0x18); + *(undefined4 *)(param_1 + 8) = uVar2; + *(undefined4 *)(param_1 + 0x18) = uVar4; + *(undefined4 *)(param_1 + 0x28) = uVar3; + *(undefined4 *)(param_1 + 0x34) = *(undefined4 *)(param_1 + 0x38); + *(undefined4 *)(param_1 + 0x38) = uVar1; + return; +} + + + +// --- FUN_0043ea20 at 0x0043EA20 (size: 197) --- + +void FUN_0043ea20(undefined1 param_1) + +{ + int iVar1; + undefined4 *puVar2; + undefined4 *unaff_ESI; + undefined4 *unaff_retaddr; + + puVar2 = (undefined4 *)(**(code **)(*DAT_0083845c + 0xc))(0,2); + *puVar2 = *unaff_ESI; + puVar2[1] = unaff_ESI[1]; + puVar2[2] = unaff_ESI[2]; + puVar2[5] = *unaff_retaddr; + puVar2[6] = unaff_retaddr[1]; + puVar2[7] = unaff_retaddr[2]; + (**(code **)(*DAT_0083845c + 0x10))(0,0); + iVar1 = **(int **)(DAT_00838454 + 0x78); + FUN_00448200(0); + *(undefined4 *)(**(int **)(iVar1 + 0x1c) + 0x28) = 3; + *(undefined4 *)(**(int **)(iVar1 + 0x1c) + 0x34) = 3; + *(undefined4 *)(iVar1 + 0x34) = 5; + *(undefined4 *)(iVar1 + 0x38) = 6; + *(undefined1 *)(iVar1 + 0x44) = param_1; + *(undefined4 **)(iVar1 + 0x40) = unaff_retaddr; + *(undefined4 *)(iVar1 + 0x48) = 1; + FUN_00447be0(2,0,1,DAT_00838454,DAT_00838454,0,unaff_ESI,&DAT_00818d18,0,0); + return; +} + + + +// --- FUN_0043eaf0 at 0x0043EAF0 (size: 306) --- + +void FUN_0043eaf0(undefined4 *param_1,undefined4 *param_2,undefined4 *param_3,undefined4 *param_4, + int param_5,undefined1 param_6,undefined4 param_7,undefined4 param_8, + undefined4 param_9,char param_10) + +{ + int iVar1; + undefined4 *puVar2; + undefined4 *unaff_ESI; + undefined4 *unaff_retaddr; + + puVar2 = (undefined4 *)(**(code **)(*DAT_0083845c + 0xc))(0,3); + *puVar2 = *unaff_ESI; + puVar2[1] = unaff_ESI[1]; + puVar2[2] = unaff_ESI[2]; + puVar2[5] = *unaff_retaddr; + puVar2[6] = unaff_retaddr[1]; + puVar2[7] = unaff_retaddr[2]; + puVar2[10] = *param_1; + puVar2[0xb] = param_1[1]; + puVar2[0xc] = param_1[2]; + if (param_5 != 0) { + puVar2[3] = *param_2; + puVar2[4] = param_2[1]; + puVar2[8] = *param_3; + puVar2[9] = param_3[1]; + puVar2[0xd] = *param_4; + puVar2[0xe] = param_4[1]; + } + (**(code **)(*DAT_0083845c + 0x10))(0,0); + iVar1 = **(int **)(DAT_00838454 + 0x78); + FUN_00448200(param_5); + *(uint *)(**(int **)(iVar1 + 0x1c) + 0x28) = (param_5 != 0) + 3; + *(uint *)(**(int **)(iVar1 + 0x1c) + 0x34) = (param_10 != '\0') + 3; + *(undefined4 *)(iVar1 + 0x34) = param_8; + *(undefined4 *)(iVar1 + 0x38) = param_9; + *(undefined1 *)(iVar1 + 0x44) = param_6; + *(undefined4 *)(iVar1 + 0x48) = param_7; + *(uint *)(iVar1 + 0x40) = (uint)((char)param_5 == '\0') * 4 + 4; + FUN_00447be0(4,0,1,DAT_00838454,DAT_00838454,0,param_4,&DAT_00818d18,0,0); + return; +} + + + +// --- FUN_0043ec30 at 0x0043EC30 (size: 92) --- + +void FUN_0043ec30(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4, + undefined4 param_5,undefined4 param_6,undefined4 param_7,undefined4 param_8, + undefined4 param_9) + +{ + undefined4 local_8; + undefined4 local_4; + + local_4 = 0; + local_8 = 0; + FUN_0043eaf0(param_1,param_2,param_3,&local_8,&local_8,&local_8,0,param_4,param_5,param_6,param_7, + param_8,param_9,0); + return; +} + + + +// --- FUN_0043ec90 at 0x0043EC90 (size: 117) --- + +void FUN_0043ec90(int param_1,int param_2,undefined4 param_3,undefined4 param_4,undefined4 param_5, + undefined4 param_6,undefined4 param_7,undefined4 param_8) + +{ + int iVar1; + undefined4 local_10; + undefined4 local_c; + + if (1 < param_2 + -1) { + local_c = 0; + local_10 = 0; + param_2 = param_2 + -2; + iVar1 = param_1 + 0xc; + do { + FUN_0043eaf0(param_1,iVar1,iVar1 + 0xc,&local_10,&local_10,&local_10,0,param_3,param_4,param_5 + ,param_6,param_7,param_8,0); + param_2 = param_2 + -1; + iVar1 = iVar1 + 0xc; + } while (param_2 != 0); + } + return; +} + + + +// --- FUN_0043ed80 at 0x0043ED80 (size: 2117) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 FUN_0043ed80(void) + +{ + float fVar1; + float fVar2; + float fVar3; + float fVar4; + float fVar5; + float fVar6; + float fVar7; + float fVar8; + char cVar9; + undefined4 *puVar10; + float *pfVar11; + undefined4 *puVar12; + float *pfVar13; + uint uVar14; + int iVar15; + undefined4 *puVar16; + undefined4 *local_90; + int *local_84; + int local_80; + int *local_7c; + uint local_78; + float local_74; + float local_70; + float local_6c; + float local_68; + float local_64; + float local_60; + undefined4 *local_5c; + int local_58; + float local_54; + float local_50; + float local_4c; + float local_48; + float local_3c; + float local_30; + float local_1c; + float local_10; + float local_4; + + if ((DAT_008388c0 & 1) == 0) { + DAT_008388c0 = DAT_008388c0 | 1; + DAT_008388b4 = 0x3f800000; + DAT_008388b8 = 0; + DAT_008388bc = 0; + } + if ((DAT_008388c0 & 2) == 0) { + DAT_008388c0 = DAT_008388c0 | 2; + DAT_008388a8 = 0xbf800000; + DAT_008388ac = 0; + DAT_008388b0 = 0; + } + if ((DAT_008388c0 & 4) == 0) { + DAT_008388c0 = DAT_008388c0 | 4; + DAT_0083889c = 0; + DAT_008388a0 = 0x3f800000; + DAT_008388a4 = 0; + } + if ((DAT_008388c0 & 8) == 0) { + DAT_008388c0 = DAT_008388c0 | 8; + DAT_00838890 = 0; + DAT_00838894 = 0xbf800000; + DAT_00838898 = 0; + } + if ((DAT_008388c0 & 0x10) == 0) { + DAT_008388c0 = DAT_008388c0 | 0x10; + DAT_00838884 = 0; + DAT_00838888 = 0; + DAT_0083888c = 0x3f800000; + } + if ((DAT_008388c0 & 0x20) == 0) { + DAT_008388c0 = DAT_008388c0 | 0x20; + DAT_00838878 = 0; + DAT_0083887c = 0; + DAT_00838880 = 0xbf800000; + } + if ((DAT_008388c0 & 0x40) == 0) { + DAT_008388c0 = DAT_008388c0 | 0x40; + DAT_00838758 = DAT_0083889c; + DAT_0083875c = DAT_008388a0; + DAT_00838760 = DAT_008388a4; + DAT_00838764 = DAT_00838884; + DAT_00838768 = DAT_00838888; + DAT_0083876c = DAT_0083888c; + DAT_00838770 = DAT_008388b4; + DAT_00838774 = DAT_008388b8; + DAT_00838778 = DAT_008388bc; + DAT_0083877c = DAT_008388a8; + DAT_00838780 = DAT_008388ac; + DAT_00838784 = DAT_008388b0; + _DAT_00838788 = DAT_00838884; + _DAT_0083878c = DAT_00838888; + _DAT_00838790 = DAT_0083888c; + DAT_00838794 = DAT_0083889c; + DAT_00838798 = DAT_008388a0; + DAT_0083879c = DAT_008388a4; + _DAT_008387a0 = DAT_00838890; + _DAT_008387a4 = DAT_00838894; + _DAT_008387a8 = DAT_00838898; + _DAT_008387ac = DAT_00838884; + _DAT_008387b0 = DAT_00838888; + _DAT_008387b4 = DAT_0083888c; + _DAT_008387b8 = DAT_008388a8; + _DAT_008387bc = DAT_008388ac; + _DAT_008387c0 = DAT_008388b0; + _DAT_008387c4 = DAT_008388b4; + _DAT_008387c8 = DAT_008388b8; + _DAT_008387cc = DAT_008388bc; + _DAT_008387d0 = DAT_00838884; + _DAT_008387d4 = DAT_00838888; + _DAT_008387d8 = DAT_0083888c; + _DAT_008387dc = DAT_00838890; + _DAT_008387e0 = DAT_00838894; + _DAT_008387e4 = DAT_00838898; + _DAT_008387e8 = DAT_00838878; + _DAT_008387ec = DAT_0083887c; + _DAT_008387f0 = DAT_00838880; + _DAT_008387f4 = DAT_0083889c; + _DAT_008387f8 = DAT_008388a0; + _DAT_008387fc = DAT_008388a4; + _DAT_00838800 = DAT_008388b4; + _DAT_00838804 = DAT_008388b8; + _DAT_00838808 = DAT_008388bc; + _DAT_0083880c = DAT_00838878; + _DAT_00838810 = DAT_0083887c; + _DAT_00838814 = DAT_00838880; + _DAT_00838818 = DAT_008388a8; + _DAT_0083881c = DAT_008388ac; + _DAT_00838820 = DAT_008388b0; + _DAT_00838824 = DAT_0083889c; + _DAT_00838828 = DAT_008388a0; + _DAT_0083882c = DAT_008388a4; + _DAT_00838830 = DAT_00838878; + _DAT_00838834 = DAT_0083887c; + _DAT_00838838 = DAT_00838880; + _DAT_0083883c = DAT_00838890; + _DAT_00838840 = DAT_00838894; + _DAT_00838844 = DAT_00838898; + _DAT_00838848 = DAT_008388a8; + _DAT_0083884c = DAT_008388ac; + _DAT_00838850 = DAT_008388b0; + _DAT_00838854 = DAT_00838878; + _DAT_00838858 = DAT_0083887c; + _DAT_0083885c = DAT_00838880; + _DAT_00838860 = DAT_008388b4; + _DAT_00838864 = DAT_008388b8; + _DAT_00838868 = DAT_008388bc; + _DAT_0083886c = DAT_00838890; + _DAT_00838870 = DAT_00838894; + _DAT_00838874 = DAT_00838898; + } + local_90 = &DAT_00838758; + local_78 = 1; + local_80 = 8; + do { + uVar14 = local_78; + local_58 = local_80 * 4; + puVar10 = (undefined4 *)thunk_FUN_005df0f5(local_80 * 0x90); + iVar15 = local_80 * 4; + if (local_80 != 0) { + pfVar11 = (float *)(local_90 + 4); + pfVar13 = (float *)(puVar10 + 0x21); + do { + local_1c = pfVar11[4] + pfVar11[-2]; + local_68 = (pfVar11[2] + pfVar11[-4]) * _DAT_007938b8; + local_64 = (pfVar11[3] + pfVar11[-3]) * _DAT_007938b8; + local_60 = local_1c * _DAT_007938b8; + fVar1 = _DAT_007938b0 / + SQRT(local_68 * local_68 + local_64 * local_64 + local_60 * local_60); + fVar2 = local_68 * fVar1; + fVar3 = local_64 * fVar1; + fVar1 = local_60 * fVar1; + local_10 = pfVar11[1] + pfVar11[-2]; + local_74 = (pfVar11[-1] + pfVar11[-4]) * _DAT_007938b8; + local_70 = (pfVar11[-3] + *pfVar11) * _DAT_007938b8; + local_6c = local_10 * _DAT_007938b8; + fVar4 = _DAT_007938b0 / + SQRT(local_70 * local_70 + local_6c * local_6c + local_74 * local_74); + fVar5 = local_74 * fVar4; + fVar6 = local_70 * fVar4; + local_84 = (int *)(local_6c * fVar4); + local_4 = pfVar11[4] + pfVar11[1]; + local_54 = (pfVar11[2] + pfVar11[-1]) * _DAT_007938b8; + local_50 = (pfVar11[3] + *pfVar11) * _DAT_007938b8; + local_4c = local_4 * _DAT_007938b8; + pfVar13[-0x21] = pfVar11[-4]; + pfVar13[-0x20] = pfVar11[-3]; + pfVar13[-0x1f] = pfVar11[-2]; + pfVar13[-0x1e] = fVar5; + pfVar13[-0x1d] = fVar6; + pfVar13[-0x1c] = (float)local_84; + fVar4 = _DAT_007938b0 / + SQRT(local_50 * local_50 + local_4c * local_4c + local_54 * local_54); + fVar7 = local_54 * fVar4; + fVar8 = local_50 * fVar4; + fVar4 = local_4c * fVar4; + pfVar13[-0x1b] = fVar2; + pfVar13[-0x1a] = fVar3; + pfVar13[-0x19] = fVar1; + pfVar13[-0x18] = fVar5; + pfVar13[-0x17] = fVar6; + pfVar13[-0x16] = (float)local_84; + pfVar13[-0x15] = pfVar11[-1]; + pfVar13[-0x14] = *pfVar11; + pfVar13[-0x13] = pfVar11[1]; + pfVar13[-0x12] = fVar7; + pfVar13[-0x11] = fVar8; + pfVar13[-0x10] = fVar4; + pfVar13[-0xf] = fVar2; + pfVar13[-0xe] = fVar3; + pfVar13[-0xd] = fVar1; + pfVar13[-0xc] = fVar5; + pfVar13[-0xb] = fVar6; + pfVar13[-10] = (float)local_84; + pfVar13[-9] = fVar7; + pfVar13[-8] = fVar8; + pfVar13[-7] = fVar4; + pfVar13[-6] = fVar2; + pfVar13[-5] = fVar3; + pfVar13[-4] = fVar1; + pfVar13[-3] = fVar7; + pfVar13[-2] = fVar8; + pfVar13[-1] = fVar4; + *pfVar13 = pfVar11[2]; + pfVar13[1] = pfVar11[3]; + pfVar13[2] = pfVar11[4]; + pfVar11 = pfVar11 + 9; + pfVar13 = pfVar13 + 0x24; + local_80 = local_80 + -1; + uVar14 = local_78; + iVar15 = local_58; + local_48 = local_68; + local_3c = local_74; + local_30 = local_54; + } while (local_80 != 0); + } + local_5c = puVar10; + if (1 < uVar14) { + operator_delete__(local_90); + } + local_78 = uVar14 + 1; + local_80 = iVar15; + local_90 = puVar10; + } while (local_78 < 3); + cVar9 = FUN_00446600(0,0,4,0xffffffff,iVar15 * 3,2,1,1,&local_7c); + if (cVar9 == '\0') { + return 0; + } + puVar12 = (undefined4 *)(**(code **)(*local_7c + 0xc))(0,iVar15 * 3); + puVar16 = puVar10; + for (uVar14 = iVar15 * 9 & 0x3fffffff; uVar14 != 0; uVar14 = uVar14 - 1) { + *puVar12 = *puVar16; + puVar16 = puVar16 + 1; + puVar12 = puVar12 + 1; + } + for (iVar15 = 0; iVar15 != 0; iVar15 = iVar15 + -1) { + *(undefined1 *)puVar12 = *(undefined1 *)puVar16; + puVar16 = (undefined4 *)((int)puVar16 + 1); + puVar12 = (undefined4 *)((int)puVar12 + 1); + } + (**(code **)(*local_84 + 0x10))(0,0); + operator_delete__(puVar10); + FUN_00446590(); + return 1; +} + + + +// --- FUN_0043f5d0 at 0x0043F5D0 (size: 297) --- + +void FUN_0043f5d0(void) + +{ + int iVar1; + undefined4 *puVar2; + undefined4 *puVar3; + undefined4 local_80 [32]; + + local_80[3] = 0; + local_80[2] = 0; + local_80[1] = 0; + local_80[7] = 0; + local_80[6] = 0; + local_80[4] = 0; + local_80[0xb] = 0; + local_80[9] = 0; + local_80[8] = 0; + local_80[0xe] = 0; + local_80[0xd] = 0; + local_80[0xc] = 0; + local_80[0xf] = 0x3f800000; + local_80[10] = 0x3f800000; + local_80[5] = 0x3f800000; + local_80[0] = 0x3f800000; + puVar2 = local_80; + puVar3 = &DAT_008385b8; + for (iVar1 = 0x10; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + puVar2 = local_80; + puVar3 = local_80 + 0x10; + for (iVar1 = 0x10; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + FUN_0043e900(local_80 + 0x10); + FUN_005a4820(local_80 + 0x10); + puVar2 = local_80; + puVar3 = &DAT_008385f8; + for (iVar1 = 0x10; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + puVar2 = local_80; + puVar3 = local_80 + 0x10; + for (iVar1 = 0x10; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + FUN_0043e990(local_80 + 0x10); + FUN_005a4860(local_80 + 0x10); + puVar2 = local_80; + puVar3 = &DAT_00838638; + for (iVar1 = 0x10; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + FUN_005a4890(&DAT_00838638); + return; +} + + + +// --- FUN_0043f700 at 0x0043F700 (size: 175) --- + +void FUN_0043f700(void) + +{ + int iVar1; + undefined4 *puVar2; + undefined4 *puVar3; + undefined4 local_40 [16]; + + puVar2 = &DAT_008386f8; + puVar3 = &DAT_008385b8; + for (iVar1 = 0x10; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + DAT_00838471 = 0; + puVar2 = &DAT_008386f8; + puVar3 = local_40; + for (iVar1 = 0x10; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + FUN_0043e900(local_40); + FUN_005a4820(local_40); + puVar2 = &DAT_00838678; + puVar3 = &DAT_008385f8; + for (iVar1 = 0x10; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + puVar2 = &DAT_00838678; + puVar3 = local_40; + for (iVar1 = 0x10; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + FUN_0043e990(local_40); + FUN_005a4860(local_40); + puVar2 = &DAT_008386b8; + puVar3 = &DAT_00838638; + for (iVar1 = 0x10; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + FUN_005a4890(&DAT_00838638); + return; +} + + + +// --- FUN_0043f7b0 at 0x0043F7B0 (size: 60) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 FUN_0043f7b0(void) + +{ + FUN_0043e760(); + if (DAT_00838468 != 0) { + FUN_00691060(); + } + if (DAT_0083846c != 0) { + FUN_005da8a0(); + } + _DAT_008388c8 = DAT_008379b0; + _DAT_008388cc = DAT_008379b4; + return 1; +} + + + +// --- FUN_0043f7f0 at 0x0043F7F0 (size: 1148) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_0043f7f0(void) + +{ + undefined4 uVar1; + int iVar2; + uint uVar3; + uint uVar4; + undefined4 *puVar5; + LONG LVar6; + uint uVar7; + uint uVar8; + float fVar9; + float fVar10; + float local_8c [4]; + undefined4 local_7c; + undefined4 local_78; + undefined4 local_74; + undefined4 local_70; + undefined4 local_6c; + float local_68; + float local_64; + undefined4 local_60; + undefined4 local_5c; + undefined4 local_58; + undefined4 local_54; + undefined4 local_50; + undefined4 local_4c; + undefined4 local_48; + undefined4 local_44; + undefined4 local_40; + undefined4 local_3c; + undefined4 local_38; + undefined4 local_34; + float local_30 [3]; + float local_24; + undefined4 local_20; + float local_1c; + float local_18; + undefined4 local_14; + float local_10; + float local_c; + undefined4 local_8; + float local_4; + + if (DAT_00838420 != '\0') { + FUN_005a4390(3); + FUN_0043f5d0(); + local_18 = _DAT_007938b0 / (float)*(int *)(DAT_00870340 + 0x94); + local_30[1] = 0.0; + local_20 = 0; + local_14 = 0; + local_8 = 0; + local_78 = 0; + local_74 = 0x3d75c28f; + local_70 = 0x3dcccccd; + local_6c = 0x3f19999a; + local_64 = _DAT_007938b0 / (float)*(int *)(DAT_00870340 + 0x98); + local_68 = (local_18 * DAT_00796344 - _DAT_007938b0) - local_18; + local_8c[0] = -(DAT_00796344 * local_64 - _DAT_007938b0) - local_64; + local_18 = (local_18 * _DAT_0079a1e4 - _DAT_007938b0) - local_18; + fVar9 = (float)(*(int *)(DAT_00870340 + 0x810) + 3) * local_64; + local_1c = -((fVar9 + fVar9) - _DAT_007938b0) - local_64; + local_30[0] = local_68; + local_30[2] = local_8c[0]; + local_24 = local_68; + local_10 = local_1c; + local_c = local_18; + local_4 = local_8c[0]; + FUN_0043ec90(local_30,4,&local_78,0,0,2,5,6); + FUN_005a26a0(); + uVar8 = 8; + fVar9 = local_8c[0]; + fVar10 = local_8c[0]; + do { + switch(uVar8) { + case 0: + fVar9 = 0.0; + fVar10 = 0.0; + uVar1 = 0xff000000; + break; + case 1: + fVar9 = 2.8026e-45; + fVar10 = 2.8026e-45; + uVar1 = 0xff000000; + break; + case 2: + fVar9 = 0.0; + fVar10 = 2.8026e-45; + uVar1 = 0xff000000; + break; + case 3: + fVar9 = 2.8026e-45; + fVar10 = 0.0; + uVar1 = 0xff000000; + break; + case 4: + fVar9 = 1.4013e-45; + fVar10 = 0.0; + uVar1 = 0xff000000; + break; + case 5: + fVar9 = 0.0; + fVar10 = 1.4013e-45; + uVar1 = 0xff000000; + break; + case 6: + fVar9 = 2.8026e-45; + fVar10 = 1.4013e-45; + uVar1 = 0xff000000; + break; + case 7: + fVar9 = 1.4013e-45; + fVar10 = 2.8026e-45; + uVar1 = 0xff000000; + break; + case 8: + fVar9 = 1.4013e-45; + fVar10 = 1.4013e-45; + default: + uVar1 = 0xffaacce0; + } + FUN_005a13a0(fVar9,fVar10,&DAT_0079a1dc,uVar1); + iVar2 = FUN_005df4c4(); + if (iVar2 < 10) { + local_50 = 0x3f800000; + local_4c = 0x3e4ccccd; + local_48 = 0x3e4ccccd; + local_44 = 0x3f800000; + local_8c[1] = 1.0; + local_8c[3] = 0.2; + local_8c[2] = 0.2; + } + else if (iVar2 < 0x14) { + local_60 = 0x3f666666; + local_5c = 0x3f000000; + local_58 = 0x3e4ccccd; + local_54 = 0x3f800000; + local_8c[1] = 0.9; + local_8c[3] = 0.2; + local_8c[2] = 0.5; + } + else if (iVar2 < 0x1e) { + local_40 = 0x3f666666; + local_3c = 0x3f666666; + local_38 = 0x3e4ccccd; + local_34 = 0x3f800000; + local_8c[1] = 0.9; + local_8c[3] = 0.2; + local_8c[2] = 0.9; + } + else { + local_78 = 0x3f59999a; + local_74 = 0x3f59999a; + local_70 = 0x3f733333; + local_6c = 0x3f800000; + local_8c[1] = 0.85; + local_8c[3] = 0.95; + local_8c[2] = 0.85; + } + local_7c = 0x3f800000; + sprintf(&DAT_008388d0,"%i",iVar2); + if (uVar8 < 8) { + uVar7 = 0xff000000; + } + else { + iVar2 = FUN_005df4c4(); + uVar3 = FUN_005df4c4(); + uVar4 = FUN_005df4c4(); + uVar7 = FUN_005df4c4(); + uVar7 = ((iVar2 << 8 | uVar3) << 8 | uVar4) << 8 | uVar7; + } + FUN_005a13a0((int)fVar9 + 0x22,fVar10,&DAT_008388d0,uVar7); + if (DAT_00818c7c == 0) { + sprintf(&DAT_008388d0,"Camera pos: "); + } + else { + puVar5 = (undefined4 *)FUN_005aa9b0(local_8c); + sprintf(&DAT_008388d0,"Camera pos: %s",*puVar5); + puVar5 = (undefined4 *)((int)local_8c[0] + -0x14); + LVar6 = InterlockedDecrement((LONG *)((int)local_8c[0] + -0x10)); + if ((LVar6 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + } + FUN_005a13a0((int)fVar9 + 0x78,fVar10,&DAT_008388d0, + (-(uint)(uVar8 < 8) & 0xff553320) - 0x553320); + uVar8 = uVar8 + 1; + } while (uVar8 < 9); + FUN_005a1390(); + FUN_005a4390(3 - (uint)(*(char *)(DAT_00870340 + 0xc4) != '\0')); + } + return; +} + + + +// --- FUN_0043fcb0 at 0x0043FCB0 (size: 27) --- + +void FUN_0043fcb0(void) + +{ + FUN_0043ea20(); + return; +} + + + +// --- FUN_0043fcd0 at 0x0043FCD0 (size: 243) --- + +void FUN_0043fcd0(void) + +{ + int iVar1; + int iVar2; + int iVar3; + undefined4 uVar4; + char unaff_BL; + undefined4 unaff_EDI; + int iVar5; + undefined4 uVar6; + + if ((char)DAT_00870340[0x2b] != '\0') { + iVar1 = DAT_00870340[0x24]; + iVar2 = DAT_00870340[0x23]; + iVar3 = *DAT_00870340; + uVar6 = 0; + uVar4 = FUN_0054fd30(0); + uVar4 = FUN_0054fd20(uVar4); + iVar5 = 0; + (**(code **)(iVar3 + 0x40))(0,0,uVar4); + if ((unaff_BL != '\0') && (DAT_00818c0c != '\0')) { + FUN_004488a0(); + FUN_00557840(); + } + if (DAT_0083846c != 0) { + FUN_005da8f0(); + } + if (DAT_00838468 != 0) { + FUN_00692470(); + } + FUN_0043f7f0(); + (**(code **)(*DAT_00870340 + 0x40))(iVar2,iVar1,unaff_EDI,uVar6,0); + DAT_00870340[0x2a] = iVar5; + (**(code **)(*DAT_00870340 + 0x24))(); + (**(code **)(*DAT_00870340 + 0x28))(); + FUN_0043e6b0(); + return; + } + return; +} + + + +// --- FUN_0043fdd0 at 0x0043FDD0 (size: 457) --- + +void FUN_0043fdd0(void) + +{ + int iVar1; + LONG LVar2; + undefined4 *puVar3; + int local_4; + + if (DAT_00838470 != '\0') { + FUN_00401340("SceneTool.ScreenshotWidthScale"); + FUN_00436cf0(&local_4); + puVar3 = (undefined4 *)(local_4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + FUN_00401340("SceneTool.ScreenshotHeightScale"); + FUN_00436cf0(&local_4); + puVar3 = (undefined4 *)(local_4 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + FUN_00401340("SceneTool.RenderUIObjects"); + FUN_00436cf0(&local_4); + LVar2 = InterlockedDecrement((LONG *)(local_4 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(local_4 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_4 + -0x14))(1); + } + FUN_0054e370(FUN_004154a0); + puVar3 = DAT_0083846c; + if (DAT_0083846c != (undefined4 *)0x0) { + iVar1 = DAT_0083846c[1]; + DAT_0083846c[1] = iVar1 + -1; + if (iVar1 + -1 == 0) { + (**(code **)*puVar3)(1); + } + DAT_0083846c = (undefined4 *)0x0; + } + puVar3 = DAT_00838468; + if (DAT_00838468 != (undefined4 *)0x0) { + iVar1 = DAT_00838468[1]; + DAT_00838468[1] = iVar1 + -1; + if (iVar1 + -1 == 0) { + (**(code **)*puVar3)(1); + } + DAT_00838468 = (undefined4 *)0x0; + } + puVar3 = DAT_0083845c; + if (DAT_0083845c != (undefined4 *)0x0) { + iVar1 = DAT_0083845c[1]; + DAT_0083845c[1] = iVar1 + -1; + if (iVar1 + -1 == 0) { + (**(code **)*puVar3)(1); + } + DAT_0083845c = (undefined4 *)0x0; + } + if (DAT_00838460 != (int *)0x0) { + (**(code **)(*DAT_00838460 + 0x14))(); + DAT_00838460 = (int *)0x0; + } + if (DAT_00838464 != (int *)0x0) { + (**(code **)(*DAT_00838464 + 0x14))(); + DAT_00838464 = (int *)0x0; + } + if (DAT_00838450 != (int *)0x0) { + (**(code **)(*DAT_00838450 + 0x14))(); + DAT_00838450 = (int *)0x0; + } + if (DAT_00838454 != (int *)0x0) { + (**(code **)(*DAT_00838454 + 0x14))(); + DAT_00838454 = (int *)0x0; + } + if (DAT_00838458 != (int *)0x0) { + (**(code **)(*DAT_00838458 + 0x14))(); + DAT_00838458 = (int *)0x0; + } + if (DAT_00838430 != (int *)0x0) { + (**(code **)(*DAT_00838430 + 0x14))(); + DAT_00838430 = (int *)0x0; + } + DAT_00838470 = '\0'; + } + return; +} + + + +// --- FUN_0043ffa0 at 0x0043FFA0 (size: 21) --- + +void FUN_0043ffa0(undefined4 param_1) + +{ + FUN_0044a770(&stack0x00000008,param_1); + return; +} + + + +// --- FUN_0043ffc0 at 0x0043FFC0 (size: 21) --- + +void FUN_0043ffc0(undefined4 param_1) + +{ + FUN_0044a770(&stack0x00000008,param_1); + return; +} + + + +// --- FUN_0043ffe0 at 0x0043FFE0 (size: 749) --- + +undefined4 FUN_0043ffe0(void) + +{ + int iVar1; + int iVar2; + int iStack_4; + + if (DAT_00838450 != (int *)0x0) { + (**(code **)(*DAT_00838450 + 0x14))(); + DAT_00838450 = (int *)0x0; + } + if (DAT_00838454 != (int *)0x0) { + (**(code **)(*DAT_00838454 + 0x14))(); + DAT_00838454 = (int *)0x0; + } + if (DAT_00838458 != (int *)0x0) { + (**(code **)(*DAT_00838458 + 0x14))(); + DAT_00838458 = (int *)0x0; + } + iVar1 = FUN_005df0f5(0x4e0); + if (iVar1 == 0) { + DAT_00838450 = (int *)0x0; + } + else { + DAT_00838450 = (int *)FUN_004497e0(); + if (DAT_00838450 != (int *)0x0) { + iVar1 = FUN_005df0f5(0xd8); + if (iVar1 != 0) { + iVar1 = FUN_0044aa40(); + if (iVar1 != 0) { + iVar2 = FUN_005df0f5(0x48); + if (iVar2 != 0) { + iStack_4 = FUN_00448350(); + if (iStack_4 != 0) { + *(undefined4 *)(iStack_4 + 0x28) = 3; + *(undefined4 *)(iStack_4 + 0x2c) = 2; + *(undefined4 *)(iStack_4 + 0x30) = 3; + *(undefined4 *)(iStack_4 + 0x34) = 3; + *(undefined4 *)(iStack_4 + 0x38) = 2; + *(undefined4 *)(iStack_4 + 0x3c) = 3; + FUN_0044a770(&iStack_4,0); + *(undefined4 *)(iVar1 + 0x34) = 5; + *(undefined4 *)(iVar1 + 0x38) = 6; + iStack_4 = iVar1; + FUN_0044a770(&iStack_4,0); + FUN_004494e0(); + iVar1 = FUN_005df0f5(0x4e0); + if (iVar1 == 0) { + DAT_00838454 = (int *)0x0; + return 0; + } + DAT_00838454 = (int *)FUN_004497e0(); + if (DAT_00838454 != (int *)0x0) { + iVar1 = FUN_005df0f5(0xd8); + if (iVar1 != 0) { + iVar1 = FUN_0044aa40(); + if (iVar1 != 0) { + iVar2 = FUN_005df0f5(0x48); + if (iVar2 != 0) { + iVar2 = FUN_00448350(); + if (iVar2 != 0) { + iStack_4 = iVar2; + FUN_0044a770(&iStack_4,0); + iStack_4 = iVar1; + FUN_0044a770(&iStack_4,0); + *(undefined4 *)(iVar1 + 0x34) = 5; + *(undefined4 *)(iVar1 + 0x38) = 6; + FUN_0043dc50(&DAT_00818d08); + *(undefined4 *)(iVar2 + 0x28) = 3; + *(undefined4 *)(iVar2 + 0x2c) = 2; + *(undefined4 *)(iVar2 + 0x30) = 3; + *(undefined4 *)(iVar2 + 0x34) = 3; + *(undefined4 *)(iVar2 + 0x38) = 2; + *(undefined4 *)(iVar2 + 0x3c) = 3; + FUN_004494e0(); + iVar1 = FUN_005df0f5(0x4e0); + if (iVar1 == 0) { + DAT_00838458 = (int *)0x0; + return 0; + } + DAT_00838458 = (int *)FUN_004497e0(); + if (DAT_00838458 != (int *)0x0) { + iVar1 = FUN_005df0f5(0xd8); + if (iVar1 != 0) { + iVar1 = FUN_0044aa40(); + if (iVar1 != 0) { + iVar2 = FUN_005df0f5(0x48); + if (iVar2 != 0) { + iVar2 = FUN_00448350(); + if (iVar2 != 0) { + iStack_4 = iVar2; + FUN_0044a770(&iStack_4,0); + iStack_4 = iVar1; + FUN_0044a770(&iStack_4,0); + *(undefined4 *)(iVar1 + 0x34) = 5; + *(undefined4 *)(iVar1 + 0x38) = 6; + FUN_0043dc50(&DAT_00818d08); + *(undefined4 *)(iVar2 + 0x28) = 3; + *(undefined4 *)(iVar2 + 0x2c) = 2; + *(undefined4 *)(iVar2 + 0x30) = 3; + *(undefined4 *)(iVar2 + 0x34) = 3; + *(undefined4 *)(iVar2 + 0x38) = 2; + *(undefined4 *)(iVar2 + 0x3c) = 3; + FUN_004494e0(); + return 1; + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + } + return 0; +} + + + diff --git a/docs/research/decompiled/chunk_00440000.c b/docs/research/decompiled/chunk_00440000.c new file mode 100644 index 0000000..bd4a60d --- /dev/null +++ b/docs/research/decompiled/chunk_00440000.c @@ -0,0 +1,13485 @@ +// Decompiled from acclient.exe — chunk 0x00440000 +// Ghidra 12.0.4 + pyghidra headless + +// --- FUN_004402d0 at 0x004402D0 (size: 1310) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +uint FUN_004402d0(void) + +{ + int *piVar1; + undefined4 uVar2; + int iVar3; + undefined4 *puVar4; + undefined4 uStack_64; + undefined4 uStack_60; + undefined4 *puStack_5c; + undefined4 local_40; + undefined4 local_3c; + undefined4 local_38; + undefined4 local_34; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + puVar4 = &DAT_008383b8; + for (iVar3 = 0x14; iVar3 != 0; iVar3 = iVar3 + -1) { + *puVar4 = 0; + puVar4 = puVar4 + 1; + } + DAT_00838450 = 0; + DAT_00838454 = 0; + DAT_00838458 = 0; + DAT_0083845c = (int *)0x0; + DAT_00838418 = 0; + _DAT_008385c4 = 0; + _DAT_008385c0 = 0; + DAT_008385bc = 0; + _DAT_008385d4 = 0; + _DAT_008385d0 = 0; + _DAT_008385c8 = 0; + _DAT_008385e4 = 0; + _DAT_008385dc = 0; + _DAT_008385d8 = 0; + _DAT_008385f0 = 0; + _DAT_008385ec = 0; + _DAT_008385e8 = 0; + _DAT_008385f4 = 0x3f800000; + _DAT_008385e0 = 0x3f800000; + _DAT_008385cc = 0x3f800000; + DAT_008385b8 = 0x3f800000; + _DAT_00838604 = 0; + _DAT_00838600 = 0; + DAT_008385fc = 0; + _DAT_00838614 = 0; + _DAT_00838610 = 0; + _DAT_00838608 = 0; + _DAT_00838624 = 0; + _DAT_0083861c = 0; + _DAT_00838618 = 0; + _DAT_00838630 = 0; + _DAT_0083862c = 0; + _DAT_00838628 = 0; + _DAT_00838634 = 0x3f800000; + _DAT_00838620 = 0x3f800000; + _DAT_0083860c = 0x3f800000; + DAT_008385f8 = 0x3f800000; + _DAT_00838644 = 0; + _DAT_00838640 = 0; + DAT_0083863c = 0; + _DAT_00838654 = 0; + _DAT_00838650 = 0; + _DAT_00838648 = 0; + _DAT_00838664 = 0; + _DAT_0083865c = 0; + _DAT_00838658 = 0; + _DAT_00838670 = 0; + _DAT_0083866c = 0; + _DAT_00838668 = 0; + _DAT_00838674 = 0x3f800000; + _DAT_00838660 = 0x3f800000; + _DAT_0083864c = 0x3f800000; + DAT_00838638 = 0x3f800000; + local_40 = 0x3f800000; + local_3c = 0; + local_38 = 0; + local_34 = 0; + local_c = 0; + local_8 = 0; + local_4 = 0; + puStack_5c = (undefined4 *)0x440463; + FUN_00535b30(); + puStack_5c = &local_40; + _DAT_00818cc4 = 0; + uStack_60 = 0x44047b; + FUN_00425f10(); + puStack_5c = (undefined4 *)0x440480; + piVar1 = (int *)FUN_0043ffe0(); + if ((char)piVar1 != '\0') { + puStack_5c = (undefined4 *)0xb0; + DAT_00838470 = 1; + uStack_60 = 0x440499; + iVar3 = FUN_005df0f5(); + if (iVar3 == 0) { + DAT_00838460 = 0; + } + else { + puStack_5c = (undefined4 *)0x4404a7; + DAT_00838460 = FUN_004451c0(); + } + uStack_60 = 0x4404b6; + puStack_5c = (undefined4 *)DAT_00838460; + piVar1 = (int *)FUN_0043dd30(); + if ((char)piVar1 != '\0') { + puStack_5c = (undefined4 *)0xb0; + uStack_60 = 0x4404cb; + iVar3 = FUN_005df0f5(); + if (iVar3 == 0) { + DAT_00838464 = 0; + } + else { + puStack_5c = (undefined4 *)0x4404d9; + DAT_00838464 = FUN_004451c0(); + } + uStack_60 = 0x4404e8; + puStack_5c = (undefined4 *)DAT_00838464; + piVar1 = (int *)FUN_0043ed80(); + if ((char)piVar1 != '\0') { + puStack_5c = (undefined4 *)0x4404fe; + DAT_0083845c = (int *)(**(code **)(*DAT_00870340 + 0x1c))(); + piVar1 = (int *)0x0; + if (DAT_0083845c != (int *)0x0) { + puStack_5c = (undefined4 *)0xffffffff; + uStack_60 = 0; + uStack_64 = 0; + piVar1 = (int *)(**(code **)(*DAT_0083845c + 4))(3,0x102); + if ((char)piVar1 != '\0') { + piVar1 = (int *)FUN_00691dc0(&uStack_60,&DAT_00838468); + if (-1 < *piVar1) { + piVar1 = (int *)FUN_005de320(&uStack_60,&DAT_0083846c); + if (-1 < *piVar1) { + FUN_0054fc10(FUN_004154a0); + FUN_0043f5d0(); + uVar2 = FUN_00424d10(); + FUN_0043e8e0(uVar2); + DAT_00818c10 = 1; + DAT_00818c14 = 1; + _DAT_00838438 = 0; + _DAT_0083843c = 0; + _DAT_00818c18 = 9; + _DAT_00818c1c = 9; + FUN_00401340( + "Number of horizontal screen shot subdivision frames to capture (for high resolution images)" + ); + FUN_00401340("SceneTool.ScreenShotWidthScale"); + FUN_004369a0(&DAT_00818c10,4,&uStack_64,&uStack_60,0,0,0,0); + FUN_004011b0(); + FUN_004011b0(); + FUN_00401340( + "Number of vertical screen shot subdivision frames to capture (for high resolution images)" + ); + FUN_00401340("SceneTool.ScreenShotHeightScale"); + FUN_004369a0(&DAT_00818c14,4,&uStack_60,&uStack_64,0,0,0,0); + FUN_004011b0(); + FUN_004011b0(); + FUN_00401340( + "Zero-based index of first horizontal screen shot subdivision frame with the \'width\' range to capture" + ); + FUN_00401340("SceneTool.ScreenShotMinX"); + FUN_004369a0(&DAT_00838438,4,&uStack_60,&uStack_64,0,0,0,0); + FUN_004011b0(); + FUN_004011b0(); + FUN_00401340( + "Zero-based index of first vertical screen shot subdivision frame with the \'height\' range to capture" + ); + FUN_00401340("SceneTool.ScreenShotMinY"); + FUN_004369a0(&DAT_0083843c,4,&uStack_60,&uStack_64,0,0,0,0); + FUN_004011b0(); + FUN_004011b0(); + FUN_00401340( + "Zero-based index of last horizontal screen shot subdivision frame with the \'width\' range to capture" + ); + FUN_00401340("SceneTool.ScreenShotMaxX"); + FUN_004369a0(&DAT_00818c18,4,&uStack_60,&uStack_64,0,0,0,0); + FUN_004011b0(); + FUN_004011b0(); + FUN_00401340( + "Zero-based index of last vertical screen shot subdivision frame with the \'height\' range to capture" + ); + FUN_00401340("SceneTool.ScreenShotMaxY"); + FUN_004369a0(&DAT_00818c1c,4,&uStack_60,&uStack_64,0,0,0,0); + FUN_004011b0(); + FUN_004011b0(); + FUN_00401340("Toggles drawing of UI objects"); + FUN_00401340("SceneTool.RenderUIObjects"); + FUN_004369a0(&DAT_00818c0c,2,&uStack_60,&uStack_64,0,0,0,0); + FUN_004011b0(); + FUN_004011b0(); + if (10 < DAT_00818c10) { + DAT_00818c10 = 10; + } + if (10 < DAT_00818c14) { + DAT_00818c14 = 10; + } + return 1; + } + } + } + } + } + } + } + return (uint)piVar1 & 0xffffff00; +} + + + +// --- FUN_004407f0 at 0x004407F0 (size: 42) --- + +void __fastcall FUN_004407f0(undefined4 *param_1) + +{ + param_1[1] = 1; + *param_1 = &PTR_FUN_0079a5b0; + param_1[2] = 0; + param_1[3] = 0; + param_1[4] = 0; + param_1[5] = 0; + *(undefined1 *)(param_1 + 6) = 0; + param_1[7] = 0; + param_1[8] = 0; + *(undefined1 *)(param_1 + 9) = 0; + return; +} + + + +// --- FUN_00440820 at 0x00440820 (size: 288) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 __fastcall FUN_00440820(int param_1) + +{ + int *piVar1; + float fVar2; + float fVar3; + float fVar4; + float fVar5; + char cVar6; + int *piVar7; + undefined4 *puVar8; + int iVar9; + + puVar8 = *(undefined4 **)(param_1 + 0x14); + if (puVar8 != (undefined4 *)0x0) { + piVar7 = puVar8 + 1; + *piVar7 = *piVar7 + -1; + if (*piVar7 == 0) { + (**(code **)*puVar8)(1); + } + *(undefined4 *)(param_1 + 0x14) = 0; + } + piVar7 = (int *)FUN_00447e40(); + *(int **)(param_1 + 0x14) = piVar7; + cVar6 = (**(code **)(*piVar7 + 4))(4,0x102,1,1,0xffffffff); + piVar7 = *(int **)(param_1 + 0x14); + if (cVar6 == '\0') { + if (piVar7 != (int *)0x0) { + piVar1 = piVar7 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*piVar7)(1); + } + *(undefined4 *)(param_1 + 0x14) = 0; + } + return 0; + } + puVar8 = (undefined4 *)(**(code **)(*piVar7 + 0xc))(0,piVar7[0x1f]); + iVar9 = *(int *)(param_1 + 0x1c) + -1; + fVar2 = (float)iVar9; + if (iVar9 < 0) { + fVar2 = fVar2 + _DAT_0079920c; + } + iVar9 = *(int *)(*(int *)(param_1 + 8) + 0x88) + -1; + fVar3 = (float)iVar9; + if (iVar9 < 0) { + fVar3 = fVar3 + _DAT_0079920c; + } + iVar9 = *(int *)(param_1 + 0x20) + -1; + fVar4 = (float)iVar9; + if (iVar9 < 0) { + fVar4 = fVar4 + _DAT_0079920c; + } + iVar9 = *(int *)(*(int *)(param_1 + 8) + 0x8c) + -1; + fVar5 = (float)iVar9; + if (iVar9 < 0) { + fVar5 = fVar5 + _DAT_0079920c; + } + puVar8[1] = 0; + puVar8[3] = 0; + puVar8[4] = 0; + *puVar8 = 0xbf000000; + puVar8[2] = 0x3f000000; + puVar8[5] = 0x3f000000; + puVar8[6] = 0; + puVar8[7] = 0x3f000000; + puVar8[9] = 0; + puVar8[8] = fVar2 / fVar3; + puVar8[10] = 0xbf000000; + puVar8[0xb] = 0; + puVar8[0xc] = 0xbf000000; + puVar8[0xe] = fVar4 / fVar5; + puVar8[0xd] = 0; + puVar8[0xf] = 0x3f000000; + puVar8[0x10] = 0; + puVar8[0x11] = 0xbf000000; + puVar8[0x12] = fVar2 / fVar3; + puVar8[0x13] = fVar4 / fVar5; + (**(code **)(**(int **)(param_1 + 0x14) + 0x10))(1,0); + return 1; +} + + + +// --- FUN_00440940 at 0x00440940 (size: 169) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __fastcall FUN_00440940(int param_1) + +{ + int *piVar1; + int iVar2; + int iVar3; + undefined4 *puVar4; + int iVar5; + + iVar5 = *(int *)(param_1 + 8); + *(undefined1 *)(param_1 + 0x24) = 0; + if (iVar5 != 0) { + iVar2 = *(int *)(iVar5 + 0x8c); + iVar3 = *(int *)(iVar5 + 0x88); + iVar5 = FUN_0043d7d0(*(undefined4 *)(iVar5 + 0x60)); + DAT_00838cd4 = DAT_00838cd4 - ((uint)*(byte *)(iVar5 + 0xc) * iVar2 * iVar3 >> 3); + } + if (*(int *)(param_1 + 0x10) != 0) { + *(double *)(*(int *)(param_1 + 0x10) + 0x70) = _DAT_008379b0 - _DAT_0079a5a8; + if (*(int **)(param_1 + 0x10) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x10) + 0x14))(); + *(undefined4 *)(param_1 + 0x10) = 0; + } + } + puVar4 = *(undefined4 **)(param_1 + 0x14); + if (puVar4 != (undefined4 *)0x0) { + piVar1 = puVar4 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar4)(1); + } + *(undefined4 *)(param_1 + 0x14) = 0; + } + if (*(int **)(param_1 + 0xc) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0xc) + 0x14))(); + *(undefined4 *)(param_1 + 0xc) = 0; + } + if (*(int **)(param_1 + 8) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 8) + 0x14))(); + *(undefined4 *)(param_1 + 8) = 0; + } + return; +} + + + +// --- FUN_004409f0 at 0x004409F0 (size: 215) --- + +undefined4 FUN_004409f0(uint param_1,uint param_2,uint *param_3,uint *param_4,char param_5) + +{ + int iVar1; + uint uVar2; + + if ((*(char *)(DAT_00870340 + 0x4e) != '\0') && (param_5 == '\0')) { + *param_3 = param_1; + *param_4 = param_2; + return 1; + } + if (param_1 == 0) { + *param_3 = 0; + } + else if (param_1 < 0x800) { + *param_3 = param_1; + iVar1 = 0x1f; + if (param_1 != 0) { + for (; param_1 >> iVar1 == 0; iVar1 = iVar1 + -1) { + } + } + uVar2 = 1 << ((byte)iVar1 & 0x1f); + if (uVar2 < *param_3) { + *param_3 = uVar2 * 2; + } + } + else { + *param_3 = 0x800; + } + if (param_2 == 0) { + *param_4 = 0; + return 1; + } + if (0x7ff < param_2) { + *param_4 = 0x800; + return 1; + } + *param_4 = param_2; + iVar1 = 0x1f; + if (param_2 != 0) { + for (; param_2 >> iVar1 == 0; iVar1 = iVar1 + -1) { + } + } + uVar2 = 1 << ((byte)iVar1 & 0x1f); + if (uVar2 < *param_4) { + *param_4 = uVar2 * 2; + } + return 1; +} + + + +// --- FUN_00440ad0 at 0x00440AD0 (size: 84) --- + +undefined4 FUN_00440ad0(int param_1,int param_2) + +{ + int local_8; + int local_4; + + local_8 = 0; + local_4 = 0; + FUN_004409f0(param_1,param_2,&local_8,&local_4,1); + if ((param_1 == local_8) && (param_2 == local_4)) { + return 1; + } + return 0; +} + + + +// --- FUN_00440b30 at 0x00440B30 (size: 490) --- + +uint __thiscall FUN_00440b30(int param_1,int *param_2,uint param_3,byte param_4) + +{ + int iVar1; + int iVar2; + undefined4 uVar3; + int *piVar4; + int iVar5; + uint uVar6; + uint uVar7; + uint uVar8; + int iVar9; + + piVar4 = DAT_00870340; + if ((((DAT_00870340 != (int *)0x0) && (piVar4 = param_2, param_2 < (int *)0x801)) && + (param_3 < 0x801)) && ((param_2 != (int *)0x0 && (param_3 != 0)))) { + *(int **)(param_1 + 0x1c) = param_2; + *(uint *)(param_1 + 0x20) = param_3; + uVar6 = *(uint *)(param_1 + 0x20); + uVar8 = *(uint *)(param_1 + 0x1c); + piVar4 = DAT_00870340; + if (*(char *)((int)DAT_00870340 + 0x4e) == '\0') { + if (uVar8 == 0) { + uVar8 = 0; + } + else if (uVar8 < 0x800) { + piVar4 = (int *)0x1f; + if (uVar8 != 0) { + for (; uVar8 >> (int)piVar4 == 0; piVar4 = (int *)((int)piVar4 + -1)) { + } + } + uVar7 = 1 << ((byte)piVar4 & 0x1f); + if (uVar7 < uVar8) { + uVar8 = uVar7 * 2; + } + } + else { + uVar8 = 0x800; + } + if (uVar6 == 0) { + uVar6 = 0; + } + else if (uVar6 < 0x800) { + piVar4 = (int *)0x1f; + if (uVar6 != 0) { + for (; uVar6 >> (int)piVar4 == 0; piVar4 = (int *)((int)piVar4 + -1)) { + } + } + uVar7 = 1 << ((byte)piVar4 & 0x1f); + if (uVar7 < uVar6) { + uVar6 = uVar7 * 2; + } + } + else { + uVar6 = 0x800; + } + } + if ((uVar8 != 0) && (uVar6 != 0)) { + uVar3 = FUN_0054fe80(); + *(undefined1 *)(param_1 + 0x18) = 0; + if ((param_4 & 1) != 0) { + *(undefined1 *)(param_1 + 0x18) = 1; + uVar3 = FUN_0054fe80(); + } + piVar4 = (int *)(**(code **)(*DAT_00870340 + 0x14))(); + *(int **)(param_1 + 8) = piVar4; + if (*(int **)(param_1 + 8) != (int *)0x0) { + iVar9 = 1; + piVar4 = (int *)(**(code **)(**(int **)(param_1 + 8) + 0x58))(uVar8,uVar6,1,uVar3); + if ((char)piVar4 != '\0') { + iVar5 = (**(code **)(*piRam0000000a + 100))(0,0); + if (iVar5 == 0) { + iVar5 = 0; + } + else { + iVar5 = iVar5 + -0x30; + } + *(int *)(iVar9 + 0xc) = iVar5; + piVar4 = (int *)0x0; + if ((*(int *)(iVar9 + 0xc) != 0) && (piVar4 = (int *)FUN_00440820(), (char)piVar4 != '\0') + ) { + *(undefined1 *)(*(int *)(iVar9 + 0xc) + 0x11c) = 1; + iVar5 = *(int *)(iVar9 + 8); + iVar1 = *(int *)(iVar5 + 0x88); + iVar2 = *(int *)(iVar5 + 0x8c); + iVar5 = FUN_0043d7d0(*(undefined4 *)(iVar5 + 0x60)); + uVar6 = (uint)*(byte *)(iVar5 + 0xc) * iVar1 * iVar2; + DAT_00838cd4 = DAT_00838cd4 + (uVar6 >> 3); + *(undefined1 *)(iVar9 + 0x24) = 1; + return CONCAT31((uint3)(uVar6 >> 0xb),1); + } + } + } + } + } + return (uint)piVar4 & 0xffffff00; +} + + + +// --- FUN_00440d20 at 0x00440D20 (size: 90) --- + +undefined4 __fastcall FUN_00440d20(int param_1) + +{ + undefined4 uVar1; + undefined4 uVar2; + char cVar3; + + if ((*(char *)(param_1 + 0x24) != '\0') && (DAT_00870340 != 0)) { + if ((*(char *)(*(int *)(param_1 + 8) + 0x38) != '\0') || + (*(char *)(*(int *)(param_1 + 0xc) + 0x38) != '\0')) { + cVar3 = *(char *)(param_1 + 0x18); + uVar1 = *(undefined4 *)(param_1 + 0x20); + uVar2 = *(undefined4 *)(param_1 + 0x1c); + FUN_00440940(); + cVar3 = FUN_00440b30(uVar2,uVar1,cVar3 != '\0'); + if (cVar3 == '\0') { + return 0; + } + } + return 1; + } + return 0; +} + + + +// --- FUN_00440d80 at 0x00440D80 (size: 42) --- + +undefined4 * __thiscall FUN_00440d80(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079a5b0; + FUN_00440940(); + *param_1 = &PTR_LAB_00796c4c; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00440e50 at 0x00440E50 (size: 227) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 __fastcall FUN_00440e50(int param_1) + +{ + int iVar1; + char cVar2; + int *piVar3; + + if (*(char *)(param_1 + 0x24) == '\0') { + return 0; + } + cVar2 = FUN_00440d20(); + if (cVar2 == '\0') { + return 0; + } + if (*(int *)(param_1 + 0xc) == 0) { + return 0; + } + if (*(int *)(param_1 + 8) == 0) { + return 0; + } + if (*(char *)(*(int *)(param_1 + 0xc) + 0x11c) == '\0') { + return 1; + } + iVar1 = *(int *)(param_1 + 0x10); + if (iVar1 != 0) { + if (*(char *)(iVar1 + 0x38) == '\0') goto LAB_00440f15; + if (iVar1 != 0) { + *(double *)(iVar1 + 0x70) = _DAT_008379b0 - _DAT_0079a5a8; + if (*(int **)(param_1 + 0x10) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x10) + 0x14))(); + *(undefined4 *)(param_1 + 0x10) = 0; + } + } + } + piVar3 = (int *)(**(code **)(*DAT_00870340 + 0x14))(); + *(int **)(param_1 + 0x10) = piVar3; + if (piVar3 == (int *)0x0) { + return 0; + } + iVar1 = *(int *)(param_1 + 8); + cVar2 = (**(code **)(*piVar3 + 0x58)) + (*(undefined4 *)(iVar1 + 0x88),*(undefined4 *)(iVar1 + 0x8c), + *(undefined4 *)(iVar1 + 0x5c),*(undefined4 *)(iVar1 + 0x60),0); + piVar3 = *(int **)(param_1 + 0x10); + if (cVar2 == '\0') { + if (piVar3 == (int *)0x0) { + return 0; + } + (**(code **)(*piVar3 + 0x14))(); + *(undefined4 *)(param_1 + 0x10) = 0; + return 0; + } + *(undefined1 *)(piVar3 + 0x1e) = 0; +LAB_00440f15: + cVar2 = (**(code **)(**(int **)(param_1 + 0x10) + 0x60))(*(undefined4 *)(param_1 + 8)); + if (cVar2 == '\0') { + return 0; + } + *(undefined1 *)(*(int *)(param_1 + 0xc) + 0x11c) = 0; + return 1; +} + + + +// --- FUN_00440f40 at 0x00440F40 (size: 9) --- + +undefined4 __fastcall FUN_00440f40(int param_1) + +{ + return CONCAT31((int3)((uint)*(int *)(param_1 + 0x1c) >> 8),*(int *)(param_1 + 0x1c) == 0); +} + + + +// --- FUN_00440f50 at 0x00440F50 (size: 143) --- + +void __thiscall FUN_00440f50(int param_1,int param_2,int *param_3) + +{ + int *piVar1; + + *(int *)(param_1 + 4) = param_2; + *(undefined4 *)(param_1 + 8) = 0; + piVar1 = (int *)(param_1 + 0xc); + *piVar1 = *param_3; + *(int *)(param_1 + 0x10) = param_3[1]; + *(int *)(param_1 + 0x14) = param_3[2]; + *(int *)(param_1 + 0x18) = param_3[3]; + if (*piVar1 < 0) { + *piVar1 = 0; + } + if (*(int *)(param_1 + 0x10) < 0) { + *(undefined4 *)(param_1 + 0x10) = 0; + } + if (*(int *)(param_2 + 0xa0) < *(int *)(param_1 + 0x14)) { + *(int *)(param_1 + 0x14) = *(int *)(param_2 + 0xa0); + } + if (*(int *)(param_2 + 0xa4) < *(int *)(param_1 + 0x18)) { + *(int *)(param_1 + 0x18) = *(int *)(param_2 + 0xa4); + } + if (*(int *)(param_1 + 0x14) < 1) { + *(undefined4 *)(param_1 + 0x14) = 1; + } + if (*(int *)(param_1 + 0x18) < 1) { + *(undefined4 *)(param_1 + 0x18) = 1; + } + if (*(int *)(param_1 + 0x14) <= *piVar1) { + *piVar1 = *(int *)(param_1 + 0x14) + -1; + } + if (*(int *)(param_1 + 0x18) <= *(int *)(param_1 + 0x10)) { + *(int *)(param_1 + 0x10) = *(int *)(param_1 + 0x18) + -1; + } + return; +} + + + +// --- FUN_00440fe0 at 0x00440FE0 (size: 58) --- + +void FUN_00440fe0(undefined4 param_1,undefined4 param_2,undefined4 param_3,int param_4,int param_5) + +{ + undefined4 local_10; + undefined4 local_c; + int local_8; + int local_4; + + local_10 = param_2; + local_c = param_3; + local_8 = param_4 + 1; + local_4 = param_5 + 1; + FUN_00440f50(param_1,&local_10); + return; +} + + + +// --- FUN_00441020 at 0x00441020 (size: 81) --- + +void FUN_00441020(int param_1,int *param_2) + +{ + int extraout_ECX; + int local_10; + int local_c; + int local_8; + int local_4; + + local_10 = *param_2 + *(int *)(param_1 + 0xc); + local_c = param_2[1] + *(int *)(param_1 + 0x10); + local_8 = param_2[2] + *(int *)(param_1 + 0xc); + local_4 = param_2[3] + *(int *)(param_1 + 0x10); + FUN_00440f50(*(undefined4 *)(param_1 + 4),&local_10); + *(int *)(extraout_ECX + 8) = param_1; + return; +} + + + +// --- FUN_00441080 at 0x00441080 (size: 54) --- + +void __thiscall +FUN_00441080(int param_1,int param_2,int param_3,undefined4 param_4,undefined4 param_5) + +{ + FUN_005a48c0(*(int *)(param_1 + 0xc) + param_2,*(int *)(param_1 + 0x10) + param_3, + *(undefined4 *)(*(int *)(param_1 + 4) + 0xa0), + *(undefined4 *)(*(int *)(param_1 + 4) + 0xa4),param_4,param_5); + return; +} + + + +// --- FUN_004410c0 at 0x004410C0 (size: 259) --- + +undefined4 __thiscall FUN_004410c0(int param_1,undefined4 param_2) + +{ + int *piVar1; + int iVar2; + char cVar3; + int iVar4; + int iVar5; + + piVar1 = *(int **)(param_1 + 4); + if (piVar1 != (int *)0x0) { + if (*(int *)(param_1 + 0x1c) == 0) { + if (*(int *)(param_1 + 8) != 0) { + FUN_004410c0(param_2); + *(bool *)(param_1 + 0x20) = (char)param_2 == '\0'; + iVar2 = *(int *)(param_1 + 8); + *(int *)(param_1 + 0x1c) = *(int *)(param_1 + 0x1c) + 1; + iVar4 = *(int *)(param_1 + 0xc) - *(int *)(iVar2 + 0xc); + iVar5 = *(int *)(param_1 + 0x10) - *(int *)(iVar2 + 0x10); + *(undefined4 *)(param_1 + 0x24) = *(undefined4 *)(iVar2 + 0x24); + *(undefined4 *)(param_1 + 0x28) = *(undefined4 *)(iVar2 + 0x28); + if (iVar4 != 0) { + iVar4 = (uint)*(byte *)(*(int *)(param_1 + 4) + 0xe8) * iVar4; + *(int *)(param_1 + 0x24) = + *(int *)(param_1 + 0x24) + ((int)(iVar4 + (iVar4 >> 0x1f & 7U)) >> 3); + } + if (iVar5 == 0) { + return 1; + } + *(int *)(param_1 + 0x24) = *(int *)(param_1 + 0x24) + *(int *)(param_1 + 0x28) * iVar5; + return 1; + } + if (((char)piVar1[0x36] == '\0') && + (cVar3 = (**(code **)(*piVar1 + 0x60)) + (param_1 + 0xc,-((char)param_2 != '\0') & 2,param_1 + 0x28, + param_1 + 0x24), cVar3 != '\0')) { + *(int *)(param_1 + 0x1c) = *(int *)(param_1 + 0x1c) + 1; + *(bool *)(param_1 + 0x20) = (char)param_2 == '\0'; + return 1; + } + } + else if (((char)param_2 == '\0') == (bool)*(char *)(param_1 + 0x20)) { + *(int *)(param_1 + 0x1c) = *(int *)(param_1 + 0x1c) + 1; + return 1; + } + } + return 0; +} + + + +// --- FUN_004411d0 at 0x004411D0 (size: 109) --- + +uint __fastcall FUN_004411d0(int param_1) + +{ + int *piVar1; + int iVar2; + uint in_EAX; + + iVar2 = *(int *)(param_1 + 4); + if (((iVar2 != 0) && (in_EAX = *(uint *)(param_1 + 0x1c), in_EAX != 0)) && + (*(char *)(iVar2 + 0xd8) != '\0')) { + if (*(int *)(param_1 + 8) == 0) { + if (*(char *)(param_1 + 0x20) != '\0') { + *(undefined1 *)(iVar2 + 0x11c) = 1; + } + piVar1 = (int *)(param_1 + 0x1c); + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)(**(int **)(param_1 + 4) + 100))(); + } + } + else { + *(uint *)(param_1 + 0x1c) = in_EAX - 1; + if (in_EAX - 1 == 0) { + FUN_004411d0(); + } + } + if (*(int *)(param_1 + 0x1c) == 0) { + *(undefined4 *)(param_1 + 0x28) = 0; + *(undefined4 *)(param_1 + 0x24) = 0; + *(undefined1 *)(param_1 + 0x20) = 0; + } + return CONCAT31((int3)((uint)*(int *)(param_1 + 0x1c) >> 8),1); + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_00441240 at 0x00441240 (size: 57) --- + +undefined4 __thiscall FUN_00441240(int *param_1,undefined4 param_2) + +{ + char cVar1; + + if ((char)param_1[1] != '\0') { + return 1; + } + if (*param_1 != 0) { + cVar1 = FUN_004410c0(param_2); + if (cVar1 != '\0') { + *(undefined1 *)(param_1 + 1) = 1; + return 1; + } + } + *(undefined1 *)(param_1 + 1) = 0; + return 0; +} + + + +// --- FUN_00441280 at 0x00441280 (size: 302) --- + +undefined4 __thiscall FUN_00441280(int param_1,int param_2) + +{ + int iVar1; + char cVar2; + uint uVar3; + int local_20; + undefined4 local_1c; + undefined4 local_18; + int local_14; + undefined4 local_10; + undefined4 local_c; + uint local_8; + uint local_4; + + if (param_1 == 0) { + return 0; + } + cVar2 = FUN_004410c0(0); + if (cVar2 == '\0') { + return 0; + } + if ((param_2 == 0) || (cVar2 = FUN_004410c0(1), cVar2 == '\0')) goto LAB_0044139d; + if (*(int *)(param_1 + 4) == 0) { +LAB_004412e0: + local_14 = -1; + } + else { + iVar1 = *(int *)(*(int *)(param_1 + 4) + 0xdc); + if (iVar1 == 0x15) { + local_14 = 2; + } + else { + if (iVar1 != 0x1c) goto LAB_004412e0; + local_14 = 1; + } + } + local_c = *(undefined4 *)(param_1 + 0x28); + local_10 = *(undefined4 *)(param_1 + 0x24); + if (*(int *)(param_2 + 4) == 0) { +LAB_0044131a: + local_20 = -1; + } + else { + iVar1 = *(int *)(*(int *)(param_2 + 4) + 0xdc); + if (iVar1 == 0x15) { + local_20 = 2; + } + else { + if (iVar1 != 0x1c) goto LAB_0044131a; + local_20 = 1; + } + } + local_18 = *(undefined4 *)(param_2 + 0x28); + local_1c = *(undefined4 *)(param_2 + 0x24); + if ((local_14 != -1) && (local_20 != -1)) { + local_8 = *(int *)(param_2 + 0x14) - *(int *)(param_2 + 0xc); + local_4 = *(int *)(param_2 + 0x18) - *(int *)(param_2 + 0x10); + uVar3 = *(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10); + if (uVar3 < local_4) { + local_4 = uVar3; + } + uVar3 = *(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc); + if (uVar3 < local_8) { + local_8 = uVar3; + } + FUN_006613a0(&local_20); + FUN_004411d0(); + FUN_004411d0(); + return 1; + } + FUN_004411d0(); +LAB_0044139d: + FUN_004411d0(); + return 0; +} + + + +// --- FUN_004413b0 at 0x004413B0 (size: 479) --- + +undefined4 __thiscall +FUN_004413b0(int param_1,undefined4 param_2,int param_3,int param_4,int param_5,int param_6) + +{ + int iVar1; + byte bVar2; + char cVar3; + int iVar4; + undefined4 uVar5; + int iVar6; + int iVar7; + int iVar8; + int iVar9; + int iVar10; + int iVar11; + + iVar7 = param_4; + iVar4 = *(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc); + iVar9 = *(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10); + if (((((param_3 <= iVar4) || (param_5 <= iVar4)) && ((-1 < param_3 || (-1 < param_5)))) && + ((param_4 <= iVar9 || (param_6 <= iVar9)))) && ((-1 < param_4 || (-1 < param_6)))) { + uVar5 = FUN_00424000(); + bVar2 = *(byte *)(*(int *)(param_1 + 4) + 0xe8) >> 3; + cVar3 = FUN_004410c0(0); + if (cVar3 != '\0') { + iVar1 = *(int *)(param_1 + 0x24); + iVar6 = param_5 - param_3; + iVar10 = iVar6; + if (iVar6 < 0) { + iVar10 = param_3 - param_5; + } + param_5 = iVar10; + iVar8 = param_6 - param_4; + iVar10 = iVar8; + if (iVar8 < 0) { + iVar10 = param_4 - param_6; + } + iVar11 = param_5 - iVar10; + if (iVar6 < 1) { + param_6 = -(uint)(iVar6 < 0); + } + else { + param_6 = 1; + } + if (iVar8 < 1) { + param_2 = -(uint)(iVar8 < 0); + } + else { + param_2 = 1; + } + param_4 = iVar10; + if (param_5 < iVar10) { +LAB_00441520: + if ((((-1 < param_3) && (-1 < iVar7)) && (param_3 < iVar4)) && (iVar7 < iVar9)) { + *(undefined4 *)(*(int *)(param_1 + 0x28) * iVar7 + iVar1 + (uint)bVar2 * param_3) = uVar5; + } + if (-1 < iVar11) goto code_r0x0044155b; + goto LAB_00441563; + } + param_4 = param_5; +LAB_004414c0: + if (((-1 < param_3) && (-1 < iVar7)) && ((param_3 < iVar4 && (iVar7 < iVar9)))) { + *(undefined4 *)(*(int *)(param_1 + 0x28) * iVar7 + iVar1 + (uint)bVar2 * param_3) = uVar5; + } + if (-1 < iVar11) goto code_r0x004414fb; + goto LAB_00441512; + } + } + return 0; +code_r0x0044155b: + param_3 = param_3 + param_6; + iVar11 = iVar11 - iVar10; + if (iVar11 < 0) { +LAB_00441563: + if (param_4 != 0) { + iVar11 = iVar11 + param_5; + iVar7 = iVar7 + param_2; + param_4 = param_4 + -1; + goto LAB_00441520; + } + goto LAB_0044157a; + } + goto LAB_00441520; +code_r0x004414fb: + iVar6 = param_4 + -1; + if (param_4 == 0) { +LAB_0044157a: + FUN_004411d0(); + return 1; + } + param_3 = param_3 + param_6; + iVar11 = iVar11 - iVar10; + param_4 = iVar6; + if (iVar11 < 0) { +LAB_00441512: + iVar7 = iVar7 + param_2; + iVar11 = iVar11 + param_5; + } + goto LAB_004414c0; +} + + + +// --- FUN_00441590 at 0x00441590 (size: 129) --- + +bool FUN_00441590(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4, + undefined4 param_5) + +{ + char cVar1; + + cVar1 = FUN_004413b0(param_1,param_2,param_3,param_4,param_3); + if (cVar1 == '\0') { + return false; + } + cVar1 = FUN_004413b0(param_1,param_2,param_5,param_4,param_5); + if (cVar1 != '\0') { + cVar1 = FUN_004413b0(param_1,param_2,param_3,param_2,param_5); + if (cVar1 != '\0') { + cVar1 = FUN_004413b0(param_1,param_4,param_3,param_4,param_5); + return cVar1 != '\0'; + } + } + return false; +} + + + +// --- FUN_00441620 at 0x00441620 (size: 176) --- + +void __fastcall +FUN_00441620(undefined4 param_1,int param_2,int param_3,int param_4,int param_5,int param_6, + int param_7,int param_8,int param_9,int param_10,int *param_11,int *param_12) + +{ + int unaff_EBX; + + *param_11 = param_3 - param_2; + param_11[1] = param_4 - param_10; + param_11[2] = param_3 + param_5 + param_2; + param_11[3] = param_4 + param_6 + param_10; + param_12[1] = unaff_EBX - param_10; + param_12[2] = param_5 + param_7 + param_2; + param_7 = param_7 - param_2; + *param_12 = param_7; + param_12[3] = param_6 + unaff_EBX + param_2; + if (param_7 < 0) { + *param_11 = *param_11 - param_7; + *param_12 = 0; + } + if (param_12[1] < 0) { + param_11[1] = param_11[1] - param_12[1]; + param_12[1] = 0; + } + if (param_8 < param_12[2]) { + param_11[2] = param_11[2] + (param_8 - param_12[2]); + param_12[2] = param_8; + } + if (param_9 < param_12[3]) { + param_11[3] = param_11[3] + (param_9 - param_12[3]); + param_12[3] = param_9; + } + return; +} + + + +// --- FUN_004416d0 at 0x004416D0 (size: 118) --- + +undefined1 __fastcall FUN_004416d0(int param_1) + +{ + int iVar1; + int iVar2; + int iVar3; + int iVar4; + char cVar5; + int iVar6; + undefined4 uVar7; + int iVar8; + int iVar9; + + cVar5 = FUN_004410c0(0); + if (cVar5 == '\0') { + return 0; + } + iVar1 = *(int *)(param_1 + 0x14); + iVar2 = *(int *)(param_1 + 0xc); + iVar6 = FUN_00424000(); + uVar7 = FUN_00424000(); + iVar9 = *(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10); + iVar3 = *(int *)(param_1 + 0x24); + while (iVar9 = iVar9 + -1, -1 < iVar9) { + iVar8 = *(int *)(param_1 + 0x28) * iVar9 + iVar3; + iVar4 = iVar1 - iVar2; + while (iVar4 = iVar4 + -1, -1 < iVar4) { + if (*(int *)(iVar8 + iVar4 * 4) == iVar6) { + *(undefined4 *)(iVar8 + iVar4 * 4) = uVar7; + } + } + } + FUN_004411d0(); + return 1; +} + + + +// --- FUN_00441750 at 0x00441750 (size: 232) --- + +undefined4 __thiscall FUN_00441750(int param_1,undefined4 param_2,int param_3) + +{ + int iVar1; + int iVar2; + int iVar3; + int iVar4; + char cVar5; + int iVar6; + int iVar7; + int iVar8; + int iVar9; + int iVar10; + int *piVar11; + + if ((((uint)(*(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc)) <= + (uint)(*(int *)(param_3 + 0x14) - *(int *)(param_3 + 0xc))) && + ((uint)(*(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10)) <= + (uint)(*(int *)(param_3 + 0x18) - *(int *)(param_3 + 0x10)))) && + (cVar5 = FUN_004410c0(0), cVar5 != '\0')) { + cVar5 = FUN_004410c0(1); + if (cVar5 != '\0') { + iVar10 = *(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc); + iVar6 = FUN_00424000(); + iVar2 = *(int *)(param_1 + 0x24); + iVar3 = *(int *)(param_3 + 0x24); + iVar9 = (*(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10)) + -1; + if (-1 < iVar9) { + iVar1 = iVar10 + -1; + do { + iVar7 = *(int *)(param_1 + 0x28) * iVar9 + iVar2; + iVar4 = *(int *)(param_3 + 0x28); + if (-1 < iVar1) { + piVar11 = (int *)(iVar7 + iVar1 * 4); + iVar8 = iVar10; + do { + if (*piVar11 == iVar6) { + *piVar11 = *(int *)(((iVar4 * iVar9 + iVar3) - iVar7) + (int)piVar11); + } + piVar11 = piVar11 + -1; + iVar8 = iVar8 + -1; + } while (iVar8 != 0); + } + iVar9 = iVar9 + -1; + } while (-1 < iVar9); + } + FUN_004411d0(); + FUN_004411d0(); + return 1; + } + FUN_004411d0(); + } + return 0; +} + + + +// --- FUN_00441840 at 0x00441840 (size: 129) --- + +bool __thiscall FUN_00441840(int param_1,int param_2,int param_3) + +{ + int iVar1; + char cVar2; + uint uVar3; + + if ((((-1 < param_2) && (-1 < param_3)) && + (param_2 < *(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc))) && + (param_3 < *(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10))) { + cVar2 = FUN_004410c0(1); + if (cVar2 != '\0') { + iVar1 = *(int *)(param_1 + 4); + uVar3 = *(uint *)((uint)(*(byte *)(iVar1 + 0xe8) >> 3) * param_2 + + *(int *)(param_1 + 0x28) * param_3 + *(int *)(param_1 + 0x24)); + if ((*(byte *)(iVar1 + 0xe0) & 2) != 0) { + uVar3 = uVar3 & ~*(uint *)(iVar1 + 0xf8); + } + FUN_004411d0(); + return uVar3 != 0; + } + } + return false; +} + + + +// --- FUN_004418d0 at 0x004418D0 (size: 117) --- + +undefined4 __thiscall FUN_004418d0(int param_1,undefined4 param_2,int param_3,int param_4) + +{ + undefined4 uVar1; + char cVar2; + + if ((((-1 < param_3) && (-1 < param_4)) && + (param_3 < *(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc))) && + (param_4 < *(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10))) { + cVar2 = FUN_004410c0(1); + if (cVar2 != '\0') { + uVar1 = *(undefined4 *) + ((uint)(*(byte *)(*(int *)(param_1 + 4) + 0xe8) >> 3) * param_3 + + *(int *)(param_1 + 0x28) * param_4 + *(int *)(param_1 + 0x24)); + FUN_004411d0(); + FUN_00430cd0(uVar1); + return 1; + } + } + return 0; +} + + + +// --- FUN_00441950 at 0x00441950 (size: 507) --- + +char __thiscall FUN_00441950(int param_1,int *param_2,int *param_3,undefined4 param_4,char param_5) + +{ + char cVar1; + int iVar2; + uint uVar3; + uint uVar4; + int iVar5; + uint uVar6; + int iVar7; + uint uVar8; + int iVar9; + int iVar10; + int iVar11; + char local_3d; + + local_3d = '\0'; + cVar1 = FUN_004410c0(1); + if (cVar1 == '\0') { + return '\0'; + } + iVar2 = FUN_005df4c4(); + uVar3 = FUN_005df4c4(); + uVar4 = FUN_005df4c4(); + iVar5 = *(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10); + iVar9 = *(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc); + iVar10 = 0; + param_4 = 0xffffffff; + if (0 < iVar5) { + do { + if (local_3d != '\0') break; + iVar11 = 0; + if (0 < iVar9) { + do { + uVar6 = *(uint *)((uint)(*(byte *)(*(int *)(param_1 + 4) + 0xe8) >> 3) * iVar11 + + *(int *)(param_1 + 0x28) * iVar10 + *(int *)(param_1 + 0x24)); + uVar6 = (uVar6 << 8 | uVar6) << 8 | uVar6; + if (uVar6 == ((iVar2 << 8 | uVar3) << 8 | uVar4)) { + *param_2 = iVar11; + *param_3 = iVar10; + local_3d = '\x01'; + break; + } + if (param_5 != '\0') { + FUN_00430cd0(uVar6); + iVar7 = FUN_005df4c4(); + uVar6 = FUN_005df4c4(); + uVar8 = FUN_005df4c4(); + uVar8 = (iVar7 << 8 | uVar6) << 8 | uVar8; + if (uVar8 < param_4) { + *param_2 = iVar11; + *param_3 = iVar10; + param_4 = uVar8; + } + } + iVar11 = iVar11 + 1; + } while (iVar11 < iVar9); + } + iVar10 = iVar10 + 1; + } while (iVar10 < iVar5); + } + FUN_004411d0(); + cVar1 = '\x01'; + if (param_5 == '\0') { + cVar1 = local_3d; + } + return cVar1; +} + + + +// --- FUN_00441b60 at 0x00441B60 (size: 361) --- + +undefined4 FUN_00441b60(int *param_1,uint param_2,int *param_3,uint *param_4) + +{ + int *piVar1; + uint uVar2; + uint uVar3; + uint uVar4; + + piVar1 = param_1; + if (*param_1 == *param_3) { + *param_4 = param_2; + return 1; + } + if (((*(byte *)(param_3 + 1) & 4) == 0) && ((*(byte *)(param_1 + 1) & 4) == 0)) { + *param_4 = 0; + if (((*(byte *)(param_1 + 1) & 1) != 0) && ((*(byte *)(param_3 + 1) & 1) != 0)) { + uVar2 = (param_1[4] & param_2) >> (*(byte *)(param_1 + 9) & 0x1f); + uVar3 = (param_1[5] & param_2) >> (*(byte *)((int)param_1 + 0x25) & 0x1f); + uVar4 = (param_1[6] & param_2) >> (*(byte *)((int)param_1 + 0x26) & 0x1f); + if (((char)param_1[8] != '\0') && ((char)param_1[8] != (char)param_3[8])) { + uVar2 = (param_3[10] * uVar2) / (uint)param_1[10]; + } + param_1 = (int *)uVar2; + if ((*(char *)((int)piVar1 + 0x21) != '\0') && + (*(char *)((int)piVar1 + 0x21) != *(char *)((int)param_3 + 0x21))) { + uVar3 = (param_3[0xb] * uVar3) / (uint)piVar1[0xb]; + } + if ((*(char *)((int)piVar1 + 0x22) != '\0') && + (*(char *)((int)piVar1 + 0x22) != *(char *)((int)param_3 + 0x22))) { + uVar4 = (param_3[0xc] * uVar4) / (uint)piVar1[0xc]; + } + uVar2 = (int)param_1 << (*(byte *)(param_3 + 9) & 0x1f) & param_3[4]; + *param_4 = uVar2; + uVar2 = uVar3 << (*(byte *)((int)param_3 + 0x25) & 0x1f) & param_3[5] | uVar2; + *param_4 = uVar2; + *param_4 = uVar4 << (*(byte *)((int)param_3 + 0x26) & 0x1f) & param_3[6] | uVar2; + } + if ((*(byte *)(param_3 + 1) & 2) != 0) { + if ((*(byte *)(piVar1 + 1) & 2) != 0) { + uVar2 = (piVar1[7] & param_2) >> (*(byte *)((int)piVar1 + 0x27) & 0x1f); + if ((*(char *)((int)piVar1 + 0x23) != '\0') && + (*(char *)((int)piVar1 + 0x23) != *(char *)((int)param_3 + 0x23))) { + uVar2 = (param_3[0xd] * uVar2) / (uint)piVar1[0xd]; + } + *param_4 = *param_4 | uVar2 << (*(byte *)((int)param_3 + 0x27) & 0x1f) & param_3[7]; + return 1; + } + *param_4 = *param_4 | param_3[7]; + } + return 1; + } + return 0; +} + + + +// --- FUN_00441cd0 at 0x00441CD0 (size: 41) --- + +void __fastcall FUN_00441cd0(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_00799d14; + param_1[1] = 0; + param_1[6] = 0; + param_1[5] = 0; + param_1[4] = 0; + param_1[3] = 0; + param_1[7] = 0; + *(undefined1 *)(param_1 + 8) = 0; + param_1[10] = 0; + param_1[9] = 0; + param_1[2] = 0; + return; +} + + + +// --- FUN_00441d00 at 0x00441D00 (size: 58) --- + +undefined4 __thiscall FUN_00441d00(undefined4 *param_1,undefined4 param_2,undefined4 param_3) + +{ + undefined4 extraout_ECX; + + param_1[1] = 0; + param_1[6] = 0; + param_1[5] = 0; + param_1[4] = 0; + param_1[3] = 0; + param_1[7] = 0; + *(undefined1 *)(param_1 + 8) = 0; + param_1[10] = 0; + param_1[9] = 0; + param_1[2] = 0; + *param_1 = &PTR_FUN_00799d14; + FUN_00440f50(param_2,param_3); + return extraout_ECX; +} + + + +// --- FUN_00441d40 at 0x00441D40 (size: 98) --- + +undefined4 __thiscall +FUN_00441d40(undefined4 *param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4, + int param_5,int param_6) + +{ + undefined4 extraout_ECX; + undefined4 local_10; + undefined4 local_c; + int local_8; + int local_4; + + param_1[1] = 0; + param_1[6] = 0; + param_1[5] = 0; + param_1[4] = 0; + param_1[3] = 0; + param_1[7] = 0; + *(undefined1 *)(param_1 + 8) = 0; + param_1[10] = 0; + param_1[9] = 0; + param_1[2] = 0; + local_10 = param_3; + local_c = param_4; + local_8 = param_5 + 1; + local_4 = param_6 + 1; + *param_1 = &PTR_FUN_00799d14; + FUN_00440f50(param_2,&local_10); + return extraout_ECX; +} + + + +// --- FUN_00441db0 at 0x00441DB0 (size: 58) --- + +undefined4 __thiscall FUN_00441db0(undefined4 *param_1,undefined4 param_2,undefined4 param_3) + +{ + undefined4 extraout_ECX; + + param_1[1] = 0; + param_1[6] = 0; + param_1[5] = 0; + param_1[4] = 0; + param_1[3] = 0; + param_1[7] = 0; + *(undefined1 *)(param_1 + 8) = 0; + param_1[10] = 0; + param_1[9] = 0; + param_1[2] = 0; + *param_1 = &PTR_FUN_00799d14; + FUN_00441020(param_2,param_3); + return extraout_ECX; +} + + + +// --- FUN_00441df0 at 0x00441DF0 (size: 2446) --- + +uint __thiscall +FUN_00441df0(int param_1,int param_2,byte param_3,undefined4 param_4,int param_5,int param_6) + +{ + bool bVar1; + bool bVar2; + bool bVar3; + bool bVar4; + bool bVar5; + bool bVar6; + bool bVar7; + char cVar8; + byte bVar9; + uint uVar10; + int iVar11; + int iVar12; + byte *pbVar13; + undefined1 *puVar14; + undefined4 uVar15; + undefined3 uVar16; + undefined3 extraout_var; + uint *puVar17; + uint uVar18; + int iVar19; + undefined1 *puVar20; + uint uVar21; + int iVar22; + byte bVar23; + undefined4 *puVar24; + uint *puVar25; + uint uVar26; + int iVar27; + undefined4 *puVar28; + uint uVar29; + bool bVar30; + undefined4 local_80; + char local_7c; + byte local_7b; + byte local_7a; + char local_79; + uint local_78; + undefined4 *local_74; + int local_70; + int local_6c; + undefined4 *local_68; + uint *local_64; + int local_60; + int local_5c; + int local_58; + uint local_54; + int local_50; + int local_4c; + int local_48; + int local_44; + int local_40; + int local_3c; + int local_38; + int local_34; + int local_30; + undefined4 *local_2c; + int local_28; + uint local_24; + uint local_20; + int *local_1c; + uint local_18; + int local_14; + uint local_10; + int local_c; + int *local_8; + int local_4; + + iVar22 = *(int *)(param_1 + 4); + local_4c = *(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc); + local_70 = *(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10); + local_60 = *(int *)(param_2 + 0x14) - *(int *)(param_2 + 0xc); + local_44 = *(int *)(param_2 + 0x18) - *(int *)(param_2 + 0x10); + iVar27 = *(int *)(param_2 + 4); + local_1c = (int *)(iVar27 + 0xdc); + local_8 = (int *)(iVar22 + 0xdc); + iVar11 = *local_1c; + bVar30 = iVar11 == *(int *)(iVar22 + 0xdc); + bVar3 = false; + if ((((iVar11 == 0x16) && (*(int *)(iVar22 + 0xdc) == 0x15)) || + ((iVar11 == 0x15 && (*local_8 == 0x16)))) && (bVar30 = true, *local_8 == 0x15)) { + bVar3 = true; + } + if (((*(byte *)(iVar27 + 0xe0) & 4) != 0) || + (local_7c = '\0', (*(byte *)(iVar22 + 0xe0) & 4) != 0)) { + local_7c = '\x01'; + } + if ((local_60 != local_4c) || (bVar4 = false, local_44 != local_70)) { + bVar4 = true; + } + if (((param_3 & 4) == 0) || (bVar5 = true, bVar30)) { + bVar5 = false; + } + if ((((param_3 & 0x10) == 0) || (iVar11 != 0x15)) || (!bVar30)) { + bVar6 = false; + } + else { + bVar6 = true; + } + if ((((param_3 & 0x50) != 0x50) || (!bVar6)) || (bVar7 = true, *local_8 != 0x15)) { + bVar7 = false; + } + if ((((param_3 & 0x20) == 0) || (!bVar30)) || (param_5 == 0)) { + bVar1 = false; +LAB_00441f5c: + bVar2 = false; + } + else { + bVar1 = true; + if ((param_6 == 0) || + ((iVar11 = *(int *)(*(int *)(param_6 + 4) + 0xdc), iVar11 != 0x15 && (iVar11 != 0x1c)))) + goto LAB_00441f5c; + bVar2 = true; + } + local_3c = param_1; + uVar10 = FUN_004410c0(1); + if ((char)uVar10 == '\0') { +LAB_00442050: + return uVar10 & 0xffffff00; + } + cVar8 = FUN_004410c0(0); + if (cVar8 == '\0') { + uVar10 = FUN_004411d0(); + return uVar10 & 0xffffff00; + } + local_74 = *(undefined4 **)(param_1 + 0x24); + bVar9 = *(byte *)(iVar27 + 0xe8) >> 3; + local_68 = *(undefined4 **)(param_2 + 0x24); + bVar23 = *(byte *)(iVar22 + 0xe8) >> 3; + local_7b = bVar23; + local_40 = FUN_005df4c4(); + local_48 = 0; + if (bVar1) { + local_78 = FUN_00424000(); + uVar21 = local_78 >> 8 & 0xff; + uVar10 = local_78 >> 0x10 & 0xff; + local_6c = uVar10 + (uVar10 != 0); + local_58 = uVar21 + (uVar21 != 0); + local_5c = (local_78 & 0xff) + (uint)((local_78 & 0xff) != 0); + } + if (bVar2) { + cVar8 = FUN_004410c0(1); + if (cVar8 == '\0') { + FUN_004411d0(); + uVar10 = FUN_004411d0(); + goto LAB_00442050; + } + local_48 = *(int *)(param_6 + 0x24); + local_7a = *(byte *)(*(int *)(param_6 + 4) + 0xe8) >> 3; + local_79 = *(int *)(*(int *)(param_6 + 4) + 0xdc) == 0x1c; + } + if (local_7c == '\0') { + if (((((bVar30) && (!bVar3)) && (!bVar4)) && ((!bVar5 && (!bVar6)))) && (!bVar1)) { + iVar27 = *(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc); + iVar22 = *(int *)(param_1 + 4); + if ((iVar27 == *(int *)(iVar22 + 0xa0)) && + (*(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10) == *(int *)(iVar22 + 0xa4))) { + iVar11 = *(int *)(param_2 + 4); + local_78 = *(uint *)(iVar22 + 0xa8); + if (((local_78 == *(uint *)(iVar11 + 0xa8)) && + (((iVar22 = *(int *)(param_2 + 0x14) - *(int *)(param_2 + 0xc), + iVar22 == *(int *)(iVar11 + 0xa0) && + (*(int *)(param_2 + 0x18) - *(int *)(param_2 + 0x10) == *(int *)(iVar11 + 0xa4))) && + (*(int *)(param_1 + 0x28) == (uint)bVar23 * iVar27)))) && + (*(int *)(param_2 + 0x28) == (uint)bVar9 * iVar22)) { + puVar24 = local_68; + puVar28 = local_74; + for (uVar10 = local_78 >> 2; uVar10 != 0; uVar10 = uVar10 - 1) { + *puVar28 = *puVar24; + puVar24 = puVar24 + 1; + puVar28 = puVar28 + 1; + } + for (uVar10 = local_78 & 3; uVar10 != 0; uVar10 = uVar10 - 1) { + *(undefined1 *)puVar28 = *(undefined1 *)puVar24; + puVar24 = (undefined4 *)((int)puVar24 + 1); + puVar28 = (undefined4 *)((int)puVar28 + 1); + } + goto LAB_00442746; + } + } + } + if ((bVar9 < 3) || (bVar23 < 3)) { + local_78 = local_70 - 1; + if (-1 < (int)local_78) { + iVar22 = local_4c + -1; + do { + if (-1 < iVar22) { + local_54 = (uint)bVar9; + puVar20 = (undefined1 *) + ((int)local_74 + + iVar22 * (uint)local_7b + *(int *)(local_3c + 0x28) * local_78); + puVar14 = (undefined1 *) + ((int)local_68 + iVar22 * local_54 + *(int *)(param_2 + 0x28) * local_78); + iVar27 = local_4c; + do { + *puVar20 = *puVar14; + puVar14 = puVar14 + -local_54; + puVar20 = puVar20 + -(uint)local_7b; + iVar27 = iVar27 + -1; + } while (iVar27 != 0); + } + local_78 = local_78 - 1; + } while (-1 < (int)local_78); + } + } + else { + local_50 = local_70 + -1; + if (-1 < local_50) { + local_78 = local_50 * local_44; + local_4 = -local_44; + do { + local_34 = (int)local_78 / local_70; + puVar24 = (undefined4 *)(*(int *)(param_2 + 0x28) * local_34 + (int)local_68); + iVar22 = local_4c + -1; + local_38 = iVar22; + local_2c = puVar24; + if (-1 < iVar22) { + local_10 = (uint)local_7b; + local_54 = (uint)bVar9; + local_c = -local_10; + local_14 = -local_60; + local_28 = iVar22 * local_60; + puVar25 = (uint *)((int)local_74 + + iVar22 * local_10 + *(int *)(local_3c + 0x28) * local_50); + do { + local_30 = iVar22; + if (bVar4) { + local_30 = local_28 / local_4c; + } + puVar17 = (uint *)(local_30 * local_54 + (int)puVar24); + if (((-1 < local_30) && (local_30 < local_60)) || + ((-1 < local_34 && (local_34 < local_44)))) { + if (bVar5) { + local_64 = puVar25; + local_38 = iVar22; + FUN_00441b60(local_1c,*puVar17,local_8,&local_80); + if (local_10 == 2) { + *(undefined2 *)puVar25 = (undefined2)local_80; + } + else if (local_10 == 3) { + *(undefined2 *)puVar25 = (undefined2)local_80; + *(byte *)((int)puVar25 + 2) = local_80._2_1_; + } + else if (local_10 == 4) { + *puVar25 = local_80; + } + } + else if (bVar6) { + local_80 = *puVar17; + if ((local_80 >> 0x18 != 0) && (local_40 != 0)) { + local_18 = *puVar25; + uVar10 = (local_80 >> 0x18) + 1; + if ((bVar1) || (uVar10 != 0x100)) { + if (local_40 != 0x100) goto LAB_0044237a; +LAB_00442380: + uVar26 = local_18 >> 0x10 & 0xff; + local_24 = local_80 >> 8 & 0xff; + local_20 = local_80 & 0xff; + uVar29 = local_18 >> 8 & 0xff; + uVar21 = local_18 & 0xff; + uVar18 = local_18 >> 0x18; + local_80._2_1_ = (byte)(local_80 >> 0x10); + if (bVar7) { + iVar19 = uVar18 + (uVar18 != 0); + iVar27 = iVar19 * uVar10; + iVar19 = iVar19 + (uVar10 - ((int)(iVar27 + (iVar27 >> 0x1f & 0xffU)) >> 8)) + ; + iVar11 = (int)((uVar26 - local_80._2_1_) * uVar10) / iVar19; + iVar12 = (int)((uVar29 - local_24) * uVar10) / iVar19; + iVar27 = (int)((uVar21 - local_20) * uVar10) / iVar19; + uVar18 = iVar19 - (uint)(iVar19 != 0); + } + else { + iVar27 = (uVar26 - local_80._2_1_) * uVar10; + iVar11 = (int)(iVar27 + (iVar27 >> 0x1f & 0xffU)) >> 8; + iVar27 = (uVar29 - local_24) * uVar10; + iVar12 = (int)(iVar27 + (iVar27 >> 0x1f & 0xffU)) >> 8; + iVar27 = (uVar21 - local_20) * uVar10; + iVar27 = (int)(iVar27 + (iVar27 >> 0x1f & 0xffU)) >> 8; + } + uVar29 = uVar29 - iVar12; + uVar26 = uVar26 - iVar11; + local_80 = uVar21 - iVar27; + if (bVar2) { + pbVar13 = (byte *)(*(int *)(param_6 + 0x28) * local_34 + + local_48 + (uint)local_7a * local_30); + if (local_79 == '\0') { + bVar23 = pbVar13[3]; + } + else { + bVar23 = *pbVar13; + } + iVar11 = (uint)bVar23 + (uint)(bVar23 != 0); + iVar27 = (uVar26 - (uVar26 * local_6c >> 8)) * iVar11; + uVar26 = uVar26 - ((int)(iVar27 + (iVar27 >> 0x1f & 0xffU)) >> 8); + iVar27 = (uVar29 - (uVar29 * local_58 >> 8)) * iVar11; + uVar29 = uVar29 - ((int)(iVar27 + (iVar27 >> 0x1f & 0xffU)) >> 8); + iVar11 = (local_80 - (local_80 * local_5c >> 8)) * iVar11; + local_80 = local_80 - ((int)(iVar11 + (iVar11 >> 0x1f & 0xffU)) >> 8); + } + else if (bVar1) { + uVar26 = uVar26 * local_6c >> 8; + uVar29 = uVar29 * local_58 >> 8; + local_80 = local_80 * local_5c >> 8; + } + local_80 = ((uVar18 << 8 | uVar26) << 8 | uVar29) << 8 | local_80; + puVar24 = local_2c; + } + else { + if (local_40 != 0x100) { +LAB_0044237a: + uVar10 = uVar10 * local_40 >> 8; + goto LAB_00442380; + } + if (!bVar7) { + local_80 = (local_18 ^ local_80) & 0xffffff ^ local_18; + *puVar25 = local_80; + goto LAB_00442676; + } + } + *puVar25 = local_80; + } + } + else if (bVar1) { + uVar10 = *puVar17; + uVar21 = uVar10 >> 0x10 & 0xff; + uVar18 = uVar10 >> 8 & 0xff; + local_80 = uVar10 & 0xff; + if (bVar2) { + pbVar13 = (byte *)(*(int *)(param_6 + 0x28) * local_34 + + local_48 + (uint)local_7a * local_30); + if (local_79 == '\0') { + bVar23 = pbVar13[3]; + } + else { + bVar23 = *pbVar13; + } + iVar11 = (uint)bVar23 + (uint)(bVar23 != 0); + iVar27 = (uVar21 - (uVar21 * local_6c >> 8)) * iVar11; + uVar21 = uVar21 - ((int)(iVar27 + (iVar27 >> 0x1f & 0xffU)) >> 8); + iVar27 = (uVar18 - (uVar18 * local_58 >> 8)) * iVar11; + uVar18 = uVar18 - ((int)(iVar27 + (iVar27 >> 0x1f & 0xffU)) >> 8); + iVar11 = (local_80 - (local_80 * local_5c >> 8)) * iVar11; + local_80 = local_80 - ((int)(iVar11 + (iVar11 >> 0x1f & 0xffU)) >> 8); + } + else { + uVar21 = uVar21 * local_6c >> 8; + uVar18 = uVar18 * local_58 >> 8; + local_80 = local_80 * local_5c >> 8; + } + local_80 = (((uVar10 >> 0x18) << 8 | uVar21) << 8 | uVar18) << 8 | local_80; + *puVar25 = local_80; + puVar24 = local_2c; + } + else if (bVar3) { + *puVar25 = *puVar17 | 0xff000000; + } + else { + *puVar25 = *puVar17; + } + } +LAB_00442676: + iVar22 = iVar22 + -1; + local_28 = local_28 + local_14; + puVar25 = (uint *)((int)puVar25 + local_c); + local_64 = puVar25; + local_38 = iVar22; + } while (-1 < iVar22); + } + local_50 = local_50 + -1; + local_78 = local_78 + local_4; + } while (-1 < local_50); + } + } + } + else { + uVar10 = *(uint *)(*(int *)(param_1 + 4) + 0xa8); + puVar24 = local_68; + puVar28 = local_74; + for (uVar21 = uVar10 >> 2; uVar21 != 0; uVar21 = uVar21 - 1) { + *puVar28 = *puVar24; + puVar24 = puVar24 + 1; + puVar28 = puVar28 + 1; + } + for (uVar10 = uVar10 & 3; uVar10 != 0; uVar10 = uVar10 - 1) { + *(undefined1 *)puVar28 = *(undefined1 *)puVar24; + puVar24 = (undefined4 *)((int)puVar24 + 1); + puVar28 = (undefined4 *)((int)puVar28 + 1); + } + } +LAB_00442746: + FUN_004411d0(); + uVar15 = FUN_004411d0(); + uVar16 = (undefined3)((uint)uVar15 >> 8); + if (bVar2) { + FUN_004411d0(); + uVar16 = extraout_var; + } + return CONCAT31(uVar16,1); +} + + + +// --- FUN_00442780 at 0x00442780 (size: 298) --- + +undefined4 __thiscall FUN_00442780(int param_1,int param_2,uint param_3,int param_4,int param_5) + +{ + int iVar1; + uint uVar2; + uint uVar3; + uint uVar4; + char cVar5; + int *piVar6; + uint *puVar7; + int iVar8; + int iVar9; + uint uVar10; + int local_8; + int local_4; + + local_8 = 0; + piVar6 = &local_8; + if (-1 < param_2) { + piVar6 = ¶m_2; + } + param_2 = *piVar6; + piVar6 = (int *)(param_1 + 0x14); + if (param_4 <= *(int *)(param_1 + 0x14)) { + piVar6 = ¶m_4; + } + local_8 = *piVar6; + param_4 = 0; + piVar6 = ¶m_4; + if (-1 < (int)param_3) { + piVar6 = (int *)¶m_3; + } + iVar8 = *piVar6; + piVar6 = (int *)(param_1 + 0x18); + if (param_5 <= *(int *)(param_1 + 0x18)) { + piVar6 = ¶m_5; + } + iVar9 = *piVar6; + iVar1 = *(int *)(param_1 + 4); + uVar2 = *(uint *)(iVar1 + 0xf0); + uVar3 = *(uint *)(iVar1 + 0xf4); + uVar4 = *(uint *)(iVar1 + 0xec); + param_3 = *(uint *)(iVar1 + 0xf8); + if (((*(byte *)(iVar1 + 0xe0) & 4) == 0) && + (local_4 = iVar9, cVar5 = FUN_004410c0(0), cVar5 != '\0')) { + param_4 = iVar8; + if (iVar8 < iVar9) { + uVar10 = (uint)(*(byte *)(*(int *)(param_1 + 4) + 0xe8) >> 3); + param_5 = uVar10 * param_2; + do { + puVar7 = (uint *)(*(int *)(param_1 + 0x28) * iVar8 + *(int *)(param_1 + 0x24) + param_5); + if (param_2 < local_8) { + iVar9 = local_8 - param_2; + do { + *puVar7 = ~*puVar7 & (uVar3 | uVar2 | uVar4) | *puVar7 & param_3; + puVar7 = (uint *)((int)puVar7 + uVar10); + iVar9 = iVar9 + -1; + } while (iVar9 != 0); + } + iVar8 = iVar8 + 1; + param_4 = iVar8; + } while (iVar8 < local_4); + } + FUN_004411d0(); + return 1; + } + return 0; +} + + + +// --- FUN_004428b0 at 0x004428B0 (size: 804) --- + +/* WARNING: Removing unreachable block (ram,0x00442ade) */ +/* WARNING: Removing unreachable block (ram,0x00442bb8) */ +/* WARNING: Removing unreachable block (ram,0x00442a72) */ + +undefined1 __thiscall +FUN_004428b0(int param_1,int param_2,int param_3,undefined4 param_4,uint param_5,int param_6, + undefined4 param_7) + +{ + int iVar1; + int iVar2; + char cVar3; + undefined1 uVar4; + uint uVar5; + uint uVar6; + uint uVar7; + uint local_54; + char local_50; + int local_44; + undefined4 local_40; + int local_3c; + undefined4 local_38; + undefined4 local_34; + uint local_30; + uint local_2c; + int local_28; + int local_24; + undefined4 local_20; + undefined4 local_1c; + int local_18; + undefined4 local_14; + undefined4 local_10; + uint local_c; + uint local_8; + undefined1 local_4; + + iVar2 = param_2; + local_54 = param_5; + local_50 = '\0'; + if ((param_1 == 0) || (cVar3 = FUN_004410c0(0), cVar3 == '\0')) { + return 0; + } + if (*(int *)(param_1 + 4) == 0) { +LAB_00442914: + local_18 = -1; + } + else { + iVar1 = *(int *)(*(int *)(param_1 + 4) + 0xdc); + if (iVar1 == 0x14) { + local_18 = 2; + } + else if (iVar1 == 0x15) { + local_18 = 0; + } + else { + if (iVar1 != 0x16) goto LAB_00442914; + local_18 = 1; + } + } + local_10 = *(undefined4 *)(param_1 + 0x28); + local_14 = *(undefined4 *)(param_1 + 0x24); + local_28 = 7; + uVar6 = local_8; + uVar7 = local_c; + if (((param_2 != 0) && (param_3 != 7)) && + (cVar3 = FUN_00441240(1), uVar6 = local_8, uVar7 = local_c, cVar3 != '\0')) { + local_28 = param_3; + if (*(int *)(param_2 + 4) == 0) { +LAB_00442995: + param_2 = -1; + } + else { + iVar1 = *(int *)(*(int *)(param_2 + 4) + 0xdc); + if (iVar1 == 0x14) { + param_2 = 2; + } + else if (iVar1 == 0x15) { + param_2 = 0; + } + else { + if (iVar1 != 0x16) goto LAB_00442995; + param_2 = 1; + } + } + local_1c = *(undefined4 *)(iVar2 + 0x28); + local_20 = *(undefined4 *)(iVar2 + 0x24); + local_24 = param_2; + uVar7 = *(int *)(iVar2 + 0x14) - *(int *)(iVar2 + 0xc); + uVar6 = *(int *)(iVar2 + 0x18) - *(int *)(iVar2 + 0x10); + local_c = uVar7; + local_8 = uVar6; + local_4 = FUN_005df4c4(); + uVar5 = *(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc); + if (uVar5 < uVar7) { + uVar7 = uVar5; + local_c = uVar5; + } + uVar5 = *(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10); + if (uVar5 < uVar6) { + uVar6 = uVar5; + local_8 = uVar5; + } + if ((local_18 == -1) || (param_2 == -1)) { + uVar6 = 4; + if (param_3 == 1) { + uVar6 = 0x14; + } + else if (param_3 == 2) { + uVar6 = 0x54; + } + if (param_6 != 7) { + uVar6 = uVar6 | 0x20; + } + FUN_00430cd0(param_7); + uVar4 = FUN_00441df0(iVar2,uVar6,param_4,&local_54,param_5); + FUN_004411d0(); + return uVar4; + } + } + local_44 = param_6; + if (param_6 == 7) goto LAB_00442b8d; + if (param_5 == 0) { + local_3c = 0; + } + else { + cVar3 = FUN_00441240(1); + if (cVar3 == '\0') goto LAB_00442ac5; + if (*(int *)(param_5 + 4) == 0) { +LAB_00442b1f: + local_3c = -1; + } + else { + iVar2 = *(int *)(*(int *)(param_5 + 4) + 0xdc); + if (iVar2 == 0x15) { + local_3c = 2; + } + else { + if (iVar2 != 0x1c) goto LAB_00442b1f; + local_3c = 1; + } + } + local_38 = *(undefined4 *)(param_5 + 0x24); + local_34 = *(undefined4 *)(param_5 + 0x28); + uVar7 = *(int *)(param_5 + 0x14) - *(int *)(param_5 + 0xc); + uVar6 = *(int *)(param_5 + 0x18) - *(int *)(param_5 + 0x10); + if (local_3c == -1) { + local_3c = -1; + local_30 = uVar7; + local_2c = uVar6; +LAB_00442ac5: + if (local_50 != '\0') { + FUN_004411d0(); + } + FUN_004411d0(); + return 0; + } + } + local_40 = param_7; + uVar5 = *(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc); + local_30 = uVar7; + if (uVar5 < uVar7) { + local_30 = uVar5; + } + uVar7 = *(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10); + local_2c = uVar6; + if (uVar7 < uVar6) { + local_2c = uVar7; + } +LAB_00442b8d: + FUN_006612a0(&local_28,&local_44); + if (local_50 != '\0') { + FUN_004411d0(); + } + FUN_004411d0(); + return 1; +} + + + +// --- FUN_00442be0 at 0x00442BE0 (size: 137) --- + +undefined4 __thiscall FUN_00442be0(int *param_1,uint param_2) + +{ + int iVar1; + int iVar2; + + if (param_2 < (uint)param_1[2]) { + return 0; + } + if ((param_1[1] & 0x7fffffffU) < param_2) { + if (param_2 == 0) { + FUN_0059d3e0(); + return 1; + } + iVar2 = thunk_FUN_005df0f5(param_2); + if (iVar2 == 0) { + return 0; + } + if (*param_1 != 0) { + iVar1 = param_1[2]; + while (iVar1 = iVar1 + -1, -1 < iVar1) { + *(undefined1 *)(iVar1 + iVar2) = *(undefined1 *)(iVar1 + *param_1); + } + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + } + } + *param_1 = iVar2; + param_1[1] = param_2 | 0x80000000; + } + return 1; +} + + + +// --- FUN_00442c70 at 0x00442C70 (size: 32) --- + +void FUN_00442c70(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + FUN_004428b0(param_1,param_2,param_3,0,7,0xff000000); + return; +} + + + +// --- FUN_00442c90 at 0x00442C90 (size: 114) --- + +void FUN_00442c90(undefined4 param_1,undefined4 param_2) + +{ + int iVar1; + uint uVar2; + uint uVar3; + uint uVar4; + + iVar1 = FUN_005df4c4(); + uVar2 = FUN_005df4c4(); + uVar3 = FUN_005df4c4(); + uVar4 = FUN_005df4c4(); + FUN_004428b0(0,7,0x3f800000,param_1,param_2,((iVar1 << 8 | uVar2) << 8 | uVar3) << 8 | uVar4); + return; +} + + + +// --- FUN_00442d10 at 0x00442D10 (size: 32) --- + +void FUN_00442d10(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + FUN_004428b0(0,7,0x3f800000,param_1,param_2,param_3); + return; +} + + + +// --- FUN_00442d30 at 0x00442D30 (size: 769) --- + +uint __thiscall +FUN_00442d30(int param_1,int param_2,undefined4 param_3,int param_4,undefined4 param_5, + undefined4 param_6,uint param_7,undefined4 param_8) + +{ + undefined1 uVar1; + undefined2 uVar2; + undefined2 uVar3; + int iVar4; + char cVar5; + int iVar6; + uint uVar7; + int iVar8; + int iVar9; + uint local_b0; + int local_98; + int local_94; + int local_90; + int local_8c; + undefined1 local_88 [4]; + int local_84; + undefined1 local_30 [16]; + undefined1 local_20 [16]; + undefined1 local_10 [16]; + + if (((param_4 == 0) || (*(int *)(param_1 + 0x1c) == 0)) || + (iVar4 = FUN_004434c0(param_5), iVar4 == 0)) { + return 0; + } + uVar1 = *(undefined1 *)(iVar4 + 7); + uVar7 = (uint)*(byte *)(iVar4 + 6); + iVar6 = 0; + if ((param_7 & 1) == 0) { + local_b0 = uVar7; + if ((param_7 & 0x1000) != 0) { + iVar6 = (int)*(char *)(iVar4 + 8); + local_b0 = *(char *)(iVar4 + 9) + iVar6 + uVar7; + } + } + else { + local_b0 = *(int *)(param_4 + 0x34) + 1; + } + iVar8 = *(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc); + cVar5 = (char)(param_7 >> 8); + iVar9 = *(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10); + uVar2 = *(undefined2 *)(iVar4 + 4); + uVar3 = *(undefined2 *)(iVar4 + 2); + FUN_00441620(uVar3,uVar2,uVar7,uVar1,iVar6 + param_2,iVar8,iVar9,0,local_10,&local_98); + if ((local_98 < local_90) && (local_94 < local_8c)) { + if ((*(int *)(param_4 + 0x60) != 0) && ((param_7 & 0x4000) != 0)) { + FUN_00441620(uVar3,uVar2,uVar7,uVar1,iVar6 + param_2,iVar8,iVar9, + *(undefined4 *)(param_4 + 0x44),local_20,local_30); + FUN_00441db0(*(int *)(param_4 + 0x60) + 0xac,local_20); + FUN_00441db0(param_1,local_30); + if ((param_7 & 0x100) == 0) { + if ((*(int *)(local_84 + 0xdc) == 0x1c) || (cVar5 < '\0')) { + FUN_00442d10(local_88,2,param_8); + } + else { + FUN_004428b0(local_88,2,0x3f800000,0,7,0xff000000); + } + } + else { + FUN_00441280(local_88); + } + } + if (((param_7 & 0x2000) == 0) && (*(int *)(param_4 + 0x54) != 0)) { + FUN_00441db0(*(int *)(param_4 + 0x54) + 0xac,local_10); + FUN_00441db0(param_1,&local_98); + if ((param_7 & 0x100) != 0) { + FUN_00441280(local_88); + return local_b0; + } + if ((*(int *)(local_84 + 0xdc) != 0x1c) && (-1 < cVar5)) { + FUN_004428b0(local_88,2,0x3f800000,0,7,0xff000000); + return local_b0; + } + FUN_00442d10(local_88,2,param_6); + } + } + return local_b0; +} + + + +// --- FUN_00443040 at 0x00443040 (size: 362) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 __fastcall FUN_00443040(int param_1) + +{ + int iVar1; + char extraout_AL; + char cVar2; + uint uVar3; + undefined4 uVar4; + undefined4 *puVar5; + undefined4 *puVar6; + uint uVar7; + uint uVar8; + uint uVar9; + undefined4 *puVar10; + int iStack00000004; + + iVar1 = *(int *)(param_1 + 4); + if ((((*(byte *)(iVar1 + 0xe0) & 4) != 0) || (*(char *)(iVar1 + 0xe8) != ' ')) || + (FUN_004410c0(0), extraout_AL == '\0')) { + return 0; + } + iStack00000004 = *(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10); + uVar9 = *(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc); + uVar7 = *(byte *)(iVar1 + 0xe8) * uVar9; + uVar3 = (uint)(*(byte *)(iVar1 + 0xe8) >> 3); + uVar8 = uVar7 >> 3; + uVar4 = FUN_00424000(); + if (uVar9 < 0x101) { + puVar5 = *(undefined4 **)(param_1 + 0x24); + if (-1 < iStack00000004 + -1) { + do { + puVar6 = puVar5; + uVar7 = uVar9; + if (-1 < (int)(uVar9 - 1)) { + do { + *puVar6 = uVar4; + uVar7 = uVar7 - 1; + puVar6 = (undefined4 *)((int)puVar6 + uVar3); + } while (uVar7 != 0); + } + puVar5 = (undefined4 *)((int)puVar5 + *(int *)(param_1 + 0x28)); + iStack00000004 = iStack00000004 + -1; + } while (iStack00000004 != 0); + } + } + else { + if ((DAT_00838e14 & 1) == 0) { + DAT_00838e14 = DAT_00838e14 | 1; + DAT_00838e08 = (undefined4 *)0x0; + DAT_00838e0c = 0; + _DAT_00838e10 = 0; + _atexit((_func_4879 *)&LAB_0072b6d0); + } + if ((uVar8 <= (DAT_00838e0c & 0x7fffffff)) || (cVar2 = FUN_00442be0(uVar8), cVar2 != '\0')) { + _DAT_00838e10 = uVar8; + } + puVar5 = DAT_00838e08; + if (-1 < (int)(uVar9 - 1)) { + do { + *puVar5 = uVar4; + uVar9 = uVar9 - 1; + puVar5 = (undefined4 *)((int)puVar5 + uVar3); + } while (uVar9 != 0); + } + puVar5 = *(undefined4 **)(param_1 + 0x24); + if (-1 < iStack00000004 + -1) { + do { + puVar6 = DAT_00838e08; + puVar10 = puVar5; + for (uVar3 = uVar7 >> 5; uVar3 != 0; uVar3 = uVar3 - 1) { + *puVar10 = *puVar6; + puVar6 = puVar6 + 1; + puVar10 = puVar10 + 1; + } + for (uVar3 = uVar8 & 3; uVar3 != 0; uVar3 = uVar3 - 1) { + *(undefined1 *)puVar10 = *(undefined1 *)puVar6; + puVar6 = (undefined4 *)((int)puVar6 + 1); + puVar10 = (undefined4 *)((int)puVar10 + 1); + } + puVar5 = (undefined4 *)((int)puVar5 + *(int *)(param_1 + 0x28)); + iStack00000004 = iStack00000004 + -1; + } while (iStack00000004 != 0); + FUN_004411d0(); + return 1; + } + } + FUN_004411d0(); + return 1; +} + + + +// --- FUN_004431b0 at 0x004431B0 (size: 146) --- + +void __thiscall FUN_004431b0(int param_1,undefined4 param_2,int *param_3) + +{ + int local_3c; + int local_38; + int local_34; + int local_30; + undefined **local_2c; + undefined4 local_28; + int local_24; + undefined4 local_20; + undefined4 local_1c; + undefined4 local_18; + undefined4 local_14; + undefined4 local_10; + undefined1 local_c; + undefined4 local_8; + undefined4 local_4; + + local_28 = 0; + local_14 = 0; + local_18 = 0; + local_1c = 0; + local_20 = 0; + local_10 = 0; + local_c = 0; + local_4 = 0; + local_8 = 0; + local_24 = 0; + local_3c = *param_3 + *(int *)(param_1 + 0xc); + local_38 = param_3[1] + *(int *)(param_1 + 0x10); + local_34 = param_3[2] + *(int *)(param_1 + 0xc); + local_30 = param_3[3] + *(int *)(param_1 + 0x10); + local_2c = &PTR_FUN_00799d14; + FUN_00440f50(*(undefined4 *)(param_1 + 4),&local_3c); + local_24 = param_1; + FUN_00443040(param_2); + return; +} + + + +// --- FUN_00443250 at 0x00443250 (size: 58) --- + +void FUN_00443250(undefined4 param_1,undefined4 param_2,undefined4 param_3,int param_4,int param_5) + +{ + undefined4 local_10; + undefined4 local_c; + int local_8; + int local_4; + + local_10 = param_2; + local_c = param_3; + local_8 = param_4 + 1; + local_4 = param_5 + 1; + FUN_004431b0(param_1,&local_10); + return; +} + + + +// --- FUN_00443290 at 0x00443290 (size: 437) --- + +uint __thiscall FUN_00443290(int param_1,uint param_2) + +{ + int iVar1; + int iVar2; + bool bVar3; + uint uVar4; + char cVar5; + undefined1 uVar6; + uint *puVar7; + uint uVar8; + uint uVar9; + uint *puVar10; + undefined4 *puVar11; + undefined4 *puVar12; + uint local_c; + uint local_8; + uint local_4; + + if (param_1 == 0) { + return 0; + } + cVar5 = FUN_004410c0(0); + uVar4 = param_2; + if (cVar5 == '\0') { + return 0; + } + if ((param_2 == 0) || (cVar5 = FUN_004410c0(1), cVar5 == '\0')) { + FUN_004411d0(); + return 0; + } + iVar1 = *(int *)(uVar4 + 4); + iVar2 = *(int *)(param_1 + 4); + if ((((*(byte *)(iVar1 + 0xe0) & 4) == 0) || (*(int *)(iVar2 + 0xa8) != *(int *)(iVar1 + 0xa8))) + && (*(int *)(param_1 + 0x28) != *(int *)(uVar4 + 0x28))) { + bVar3 = false; + } + else { + bVar3 = true; + } + if (((((*(int *)(iVar1 + 0xdc) == *(int *)(iVar2 + 0xdc)) && (bVar3)) && + ((*(int *)(param_1 + 0xc) == 0 && + ((*(int *)(param_1 + 0x10) == 0 && (*(int *)(uVar4 + 0x14) == *(int *)(param_1 + 0x14))))))) + && (*(int *)(uVar4 + 0x18) == *(int *)(param_1 + 0x18))) && + ((*(int *)(param_1 + 0x14) == *(int *)(iVar2 + 0xa0) && + (*(int *)(param_1 + 0x18) == *(int *)(iVar2 + 0xa4))))) { + uVar9 = *(uint *)(iVar2 + 0xa8); + puVar11 = *(undefined4 **)(uVar4 + 0x24); + puVar12 = *(undefined4 **)(param_1 + 0x24); + for (uVar8 = uVar9 >> 2; uVar8 != 0; uVar8 = uVar8 - 1) { + *puVar12 = *puVar11; + puVar11 = puVar11 + 1; + puVar12 = puVar12 + 1; + } + for (uVar9 = uVar9 & 3; uVar9 != 0; uVar9 = uVar9 - 1) { + *(undefined1 *)puVar12 = *(undefined1 *)puVar11; + puVar11 = (undefined4 *)((int)puVar11 + 1); + puVar12 = (undefined4 *)((int)puVar12 + 1); + } + FUN_004411d0(); + FUN_004411d0(); + return 1; + } + if (*(int *)(iVar1 + 0xdc) == 0x1c) { + if (*(int *)(iVar2 + 0xdc) != 0x1c) { + param_2 = *(int *)(uVar4 + 0x18) - *(int *)(uVar4 + 0x10); + local_c = *(int *)(param_1 + 0x18) - *(int *)(param_1 + 0x10); + local_8 = *(int *)(uVar4 + 0x14) - *(int *)(uVar4 + 0xc); + local_4 = *(int *)(param_1 + 0x14) - *(int *)(param_1 + 0xc); + puVar10 = ¶m_2; + if (local_c <= param_2) { + puVar10 = &local_c; + } + puVar7 = &local_8; + if (local_4 <= local_8) { + puVar7 = &local_4; + } + FUN_00443250(&DAT_00818e00,0,0,*puVar7 - 1,*puVar10 - 1); + } + } + else if (*(int *)(iVar2 + 0xdc) != 0x1c) { + uVar6 = FUN_004428b0(uVar4,0,0x3f800000,0,7,0xff000000); + goto LAB_004433a1; + } + uVar6 = FUN_00441280(uVar4); +LAB_004433a1: + param_2 = CONCAT31(param_2._1_3_,uVar6); + FUN_004411d0(); + FUN_004411d0(); + return param_2 & 0xff; +} + + + +// --- FUN_00443450 at 0x00443450 (size: 56) --- + +void __fastcall FUN_00443450(int *param_1) + +{ + (**(code **)(*param_1 + 0x2c))(); + if ((void *)param_1[0x1b] != (void *)0x0) { + operator_delete__((void *)param_1[0x1b]); + param_1[0x1b] = 0; + } + if ((void *)param_1[0xf] != (void *)0x0) { + operator_delete__((void *)param_1[0xf]); + param_1[0xf] = 0; + } + return; +} + + + +// --- FUN_00443490 at 0x00443490 (size: 45) --- + +undefined4 __fastcall FUN_00443490(int param_1) + +{ + if (*(int **)(param_1 + 0x54) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x54) + 0x14))(); + *(undefined4 *)(param_1 + 0x54) = 0; + } + if (*(int **)(param_1 + 0x60) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x60) + 0x14))(); + *(undefined4 *)(param_1 + 0x60) = 0; + } + return 1; +} + + + +// --- FUN_004434c0 at 0x004434C0 (size: 131) --- + +int __thiscall FUN_004434c0(int param_1,ushort param_2) + +{ + ushort uVar1; + ushort *puVar2; + uint uVar3; + ushort *puVar4; + + puVar2 = *(ushort **)(param_1 + 0x3c); + if (puVar2 == (ushort *)0x0) { + return 0; + } + do { + if (*(int *)(param_1 + 0x6c) == 0) { + uVar3 = 0; + puVar4 = puVar2; + if (*(uint *)(param_1 + 0x38) != 0) { + do { + if (*puVar4 == param_2) goto LAB_00443505; + uVar3 = uVar3 + 1; + puVar4 = (ushort *)((int)puVar4 + 0xb); + } while (uVar3 < *(uint *)(param_1 + 0x38)); + } + } + else if ((*(ushort *)(param_1 + 100) <= param_2) && (param_2 <= *(ushort *)(param_1 + 0x66))) { + uVar1 = *(ushort *) + (*(int *)(param_1 + 0x6c) + ((uint)param_2 - (uint)*(ushort *)(param_1 + 100)) * 2); + if (*(uint *)(param_1 + 0x38) <= (uint)uVar1) { + return 0; + } + if ((uint)uVar1 * 0xb + (int)puVar2 != 0) { + uVar3 = (uint)uVar1; +LAB_00443505: + return uVar3 * 0xb + (int)puVar2; + } + } + if (param_2 == 0x3f) { + return 0; + } + param_2 = 0x3f; + } while( true ); +} + + + +// --- FUN_00443550 at 0x00443550 (size: 42) --- + +int FUN_00443550(undefined4 param_1) + +{ + int iVar1; + + iVar1 = FUN_004434c0(param_1); + if (iVar1 != 0) { + return (uint)*(byte *)(iVar1 + 9) + (uint)*(byte *)(iVar1 + 8) + (uint)*(byte *)(iVar1 + 6); + } + return 0; +} + + + +// --- FUN_00443580 at 0x00443580 (size: 71) --- + +undefined1 __thiscall FUN_00443580(int param_1,ushort param_2) + +{ + uint uVar1; + + if (*(int *)(param_1 + 0x3c) != 0) { + if (*(int *)(param_1 + 0x6c) == 0) { + return 1; + } + if ((((*(ushort *)(param_1 + 100) <= param_2) && (param_2 <= *(ushort *)(param_1 + 0x66))) && + (uVar1 = (uint)*(ushort *) + (*(int *)(param_1 + 0x6c) + + ((uint)param_2 - (uint)*(ushort *)(param_1 + 100)) * 2), + uVar1 < *(uint *)(param_1 + 0x38))) && (uVar1 * 0xb + *(int *)(param_1 + 0x3c) != 0)) { + return 1; + } + } + return 0; +} + + + +// --- FUN_004435d0 at 0x004435D0 (size: 196) --- + +uint __fastcall FUN_004435d0(int param_1) + +{ + ushort uVar1; + uint in_EAX; + uint uVar2; + int iVar3; + undefined4 *puVar4; + uint uVar5; + + if (*(int *)(param_1 + 0x3c) != 0) { + uVar5 = 0; + *(undefined2 *)(param_1 + 100) = 0xffff; + *(undefined2 *)(param_1 + 0x66) = 0; + if (*(int *)(param_1 + 0x38) != 0) { + uVar2 = 0; + do { + uVar1 = *(ushort *)(uVar2 * 0xb + *(int *)(param_1 + 0x3c)); + if (uVar1 < *(ushort *)(param_1 + 100)) { + *(ushort *)(param_1 + 100) = uVar1; + } + if (*(ushort *)(param_1 + 0x66) < uVar1) { + *(ushort *)(param_1 + 0x66) = uVar1; + } + uVar5 = uVar5 + 1; + uVar2 = uVar5 & 0xffff; + } while (uVar2 < *(uint *)(param_1 + 0x38)); + } + uVar1 = *(ushort *)(param_1 + 0x66); + in_EAX = (uint)uVar1; + if (*(ushort *)(param_1 + 100) <= uVar1) { + iVar3 = ((uint)uVar1 - (uint)*(ushort *)(param_1 + 100)) + 1; + *(int *)(param_1 + 0x68) = iVar3; + puVar4 = (undefined4 *)thunk_FUN_005df0f5(iVar3 * 2); + uVar2 = *(int *)(param_1 + 0x68) << 1; + *(undefined4 **)(param_1 + 0x6c) = puVar4; + for (uVar5 = uVar2 >> 2; uVar5 != 0; uVar5 = uVar5 - 1) { + *puVar4 = 0; + puVar4 = puVar4 + 1; + } + for (uVar2 = uVar2 & 3; uVar2 != 0; uVar2 = uVar2 - 1) { + *(undefined1 *)puVar4 = 0; + puVar4 = (undefined4 *)((int)puVar4 + 1); + } + uVar5 = 0; + if (*(int *)(param_1 + 0x38) != 0) { + uVar2 = 0; + do { + *(short *)(*(int *)(param_1 + 0x6c) + + ((uint)*(ushort *)(uVar2 * 0xb + *(int *)(param_1 + 0x3c)) - + (uint)*(ushort *)(param_1 + 100)) * 2) = (short)uVar5; + uVar5 = uVar5 + 1; + uVar2 = uVar5 & 0xffff; + } while (uVar2 < *(uint *)(param_1 + 0x38)); + } + return CONCAT31((int3)(uVar5 >> 8),1); + } + } + return in_EAX & 0xffffff00; +} + + + +// --- FUN_004436a0 at 0x004436A0 (size: 59) --- + +undefined4 __fastcall FUN_004436a0(int param_1) + +{ + char cVar1; + + if ((*(int *)(param_1 + 0x54) != 0) && (cVar1 = FUN_004410c0(1), cVar1 == '\0')) { + return 0; + } + if ((*(int *)(param_1 + 0x60) != 0) && (cVar1 = FUN_004410c0(1), cVar1 == '\0')) { + return 0; + } + return 1; +} + + + +// --- FUN_004436e0 at 0x004436E0 (size: 55) --- + +undefined4 __fastcall FUN_004436e0(int param_1) + +{ + char cVar1; + + if ((*(int *)(param_1 + 0x54) != 0) && (cVar1 = FUN_004411d0(), cVar1 == '\0')) { + return 0; + } + if ((*(int *)(param_1 + 0x60) != 0) && (cVar1 = FUN_004411d0(), cVar1 == '\0')) { + return 0; + } + return 1; +} + + + +// --- FUN_00443960 at 0x00443960 (size: 187) --- + +void __fastcall FUN_00443960(int param_1) + +{ + undefined *puVar1; + undefined4 uVar2; + LONG LVar3; + LONG *pLVar4; + + *(undefined4 *)(param_1 + 0x30) = 0; + *(undefined4 *)(param_1 + 0x34) = 0; + *(undefined4 *)(param_1 + 0x38) = 0; + *(undefined4 *)(param_1 + 0x3c) = 0; + *(undefined4 *)(param_1 + 0x40) = 0; + *(undefined4 *)(param_1 + 0x44) = 0; + puVar1 = *(undefined **)(param_1 + 0x4c); + if (puVar1 != PTR_DAT_00818344) { + LVar3 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + pLVar4 = (LONG *)(PTR_DAT_00818344 + -0x10); + *(undefined **)(param_1 + 0x4c) = PTR_DAT_00818344; + InterlockedIncrement(pLVar4); + } + *(undefined4 *)(param_1 + 0x50) = DAT_00838e84; + *(undefined4 *)(param_1 + 0x54) = 0; + puVar1 = *(undefined **)(param_1 + 0x58); + if (puVar1 != PTR_DAT_00818344) { + LVar3 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + pLVar4 = (LONG *)(PTR_DAT_00818344 + -0x10); + *(undefined **)(param_1 + 0x58) = PTR_DAT_00818344; + InterlockedIncrement(pLVar4); + } + uVar2 = DAT_00838e84; + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined2 *)(param_1 + 100) = 0; + *(undefined2 *)(param_1 + 0x66) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + *(undefined4 *)(param_1 + 0x5c) = uVar2; + return; +} + + + +// --- FUN_00443a20 at 0x00443A20 (size: 62) --- + +void __fastcall FUN_00443a20(int *param_1) + +{ + (**(code **)(*param_1 + 0x2c))(); + if ((void *)param_1[0x1b] != (void *)0x0) { + operator_delete__((void *)param_1[0x1b]); + param_1[0x1b] = 0; + } + if ((void *)param_1[0xf] != (void *)0x0) { + operator_delete__((void *)param_1[0xf]); + param_1[0xf] = 0; + } + FUN_00443960(); + return; +} + + + +// --- FUN_00443ac0 at 0x00443AC0 (size: 34) --- + +undefined4 FUN_00443ac0(undefined4 param_1) + +{ + switch(param_1) { + case 0x29: + case 0x65: + case 0xf3: + case 0xf4: + return 0; + default: + return 1; + } +} + + + +// --- FUN_00443bc0 at 0x00443BC0 (size: 95) --- + +void __fastcall FUN_00443bc0(int param_1) + +{ + undefined4 uVar1; + + *(undefined4 *)(param_1 + 0x58) = 0; + *(undefined4 *)(param_1 + 0x5c) = 0; + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + FUN_0043d290(0); + *(undefined4 *)(param_1 + 0xa0) = 0; + *(undefined4 *)(param_1 + 0xa4) = 0; + *(undefined4 *)(param_1 + 0xa8) = 0; + *(undefined1 *)(param_1 + 0xd8) = 0; + FUN_0043d290(0); + *(undefined4 *)(param_1 + 0x114) = 0; + uVar1 = DAT_00838f14; + *(undefined1 *)(param_1 + 0x11c) = 0; + *(undefined1 *)(param_1 + 0x11d) = 0; + *(undefined4 *)(param_1 + 0x118) = uVar1; + return; +} + + + +// --- FUN_00443c20 at 0x00443C20 (size: 29) --- + +undefined1 __fastcall FUN_00443c20(int *param_1) + +{ + char cVar1; + + cVar1 = FUN_00413a70(); + if (cVar1 != '\0') { + cVar1 = (**(code **)(*param_1 + 0x5c))(); + if (cVar1 == '\0') { + return 0; + } + } + return 1; +} + + + +// --- FUN_00443c40 at 0x00443C40 (size: 122) --- + +undefined4 __thiscall FUN_00443c40(int param_1,int *param_2,uint param_3,uint *param_4,int *param_5) + +{ + int iVar1; + uint uVar2; + + if (*(char *)(param_1 + 0xd8) == '\0') { + if (*(int *)(param_1 + 0x114) != 0) { + uVar2 = *(int *)(param_1 + 0xa0) * (uint)*(byte *)(param_1 + 0xe8) >> 3; + *param_4 = uVar2; + iVar1 = (uint)*(byte *)(param_1 + 0xe8) * *param_2; + *param_5 = ((int)(iVar1 + (iVar1 >> 0x1f & 7U)) >> 3) + param_2[1] * uVar2 + + *(int *)(param_1 + 0x114); + } + *(byte *)(param_1 + 0x11d) = (byte)(param_3 >> 1) & 1; + *(undefined1 *)(param_1 + 0xd8) = 1; + return 1; + } + return 0; +} + + + +// --- FUN_00443cc0 at 0x00443CC0 (size: 40) --- + +void __fastcall FUN_00443cc0(int param_1) + +{ + if (*(char *)(param_1 + 0xd8) != '\0') { + if (*(char *)(param_1 + 0x11d) == '\0') { + *(undefined1 *)(param_1 + 0x11c) = 1; + } + *(undefined1 *)(param_1 + 0xd8) = 0; + *(undefined1 *)(param_1 + 0x11d) = 0; + } + return; +} + + + +// --- FUN_00443cf0 at 0x00443CF0 (size: 198) --- + +undefined4 __thiscall FUN_00443cf0(int param_1,undefined4 param_2) + +{ + uint uVar1; + char cVar2; + undefined4 uVar3; + + cVar2 = FUN_00413a70(); + if (((cVar2 != '\0') && (DAT_0086734c != 0)) && (DAT_00819248 != '\0')) { + cVar2 = FUN_00443ac0(param_2); + if (cVar2 == '\0') { + return param_2; + } + if (*(int *)(param_1 + 4) == 6) { + uVar3 = FUN_0054fe80(); + return uVar3; + } + if (*(int *)(param_1 + 4) != 10) { + uVar1 = *(uint *)(param_1 + 0x6c); + if ((uVar1 & 4) == 0) { + if (((uVar1 & 2) != 0) && ((uVar1 & 1) != 0)) { + return *(undefined4 *)(DAT_00870340 + 0x6c); + } + if ((uVar1 & 2) != 0) { + return *(undefined4 *)(DAT_00870340 + 0x70); + } + if ((uVar1 & 1) != 0) { + return *(undefined4 *)(DAT_00870340 + 0x68); + } + } + else if (*(char *)(DAT_00870340 + 0x55) == '\0') { + return *(undefined4 *)(DAT_00870340 + 0x6c); + } + } + } + return param_2; +} + + + +// --- FUN_00443dc0 at 0x00443DC0 (size: 405) --- + +/* WARNING: Function: __chkstk replaced with injection: alloca_probe */ + +undefined4 __fastcall FUN_00443dc0(int *param_1) + +{ + char cVar1; + int *piVar2; + int iVar3; + int *piVar4; + int *piVar5; + int local_4e70; + int local_4e6c; + int iStack_4e68; + uint uStack_4e64; + undefined4 uStack_4e60; + undefined4 uStack_4e58; + int iStack_4e4c; + int iStack_4e48; + undefined4 uStack_4e44; + undefined4 uStack_4e40; + undefined4 uStack_4e3c; + undefined4 uStack_4e28; + undefined4 *puStack_c; + undefined4 uStack_4; + + uStack_4 = 0x443dca; + piVar2 = param_1; + if (param_1[0x37] != 0x14) { + piVar2 = (int *)(**(code **)(*DAT_00870340 + 0x10))(); + if (piVar2 == (int *)0x0) { + return 0; + } + cVar1 = (**(code **)(*piVar2 + 0x58))(param_1[0x28],param_1[0x29],0x14,1); + if (cVar1 == '\0') { + return 0; + } + cVar1 = (**(code **)(*piVar2 + 0x68))(param_1); + if (cVar1 == '\0') { + return 0; + } + } + piVar5 = &local_4e70; + piVar4 = &local_4e6c; + local_4e70 = 0; + cVar1 = (**(code **)(*piVar2 + 0x60))(param_1 + 0x2e,2,piVar4,piVar5); + if (((cVar1 != '\0') && (piVar4 != (int *)0x0)) && + (iVar3 = FUN_00615c60(&stack0xffffb188), iVar3 == 0)) { + local_4e70 = piVar2[0x28]; + local_4e6c = piVar2[0x29]; + iStack_4e68 = (int)piVar5 - ((uint)*(byte *)(piVar2 + 0x3a) * piVar2[0x28] >> 3); + uStack_4e58 = *puStack_c; + uStack_4e64 = (uint)(*(byte *)(piVar2 + 0x3a) >> 3); + uStack_4e60 = 2; + iStack_4e4c = piVar2[0x28]; + iStack_4e48 = piVar2[0x29]; + uStack_4e44 = 3; + uStack_4e40 = 3; + uStack_4e3c = 1; + uStack_4e28 = 0x5a; + iVar3 = FUN_00617900(&stack0xffffb188,8); + if (iVar3 == 0) { + iVar3 = FUN_006163f0(&stack0xffffb188); + if (iVar3 == 0) { + (**(code **)(*piVar2 + 100))(); + if (piVar2 != param_1) { + (**(code **)(*piVar2 + 0x14))(); + } + return 1; + } + (**(code **)(*piVar2 + 100))(); + return 0; + } + (**(code **)(*piVar2 + 100))(); + } + return 0; +} + + + +// --- FUN_00443f60 at 0x00443F60 (size: 365) --- + +undefined1 __thiscall FUN_00443f60(int *param_1,int *param_2) + +{ + int iVar1; + undefined1 uVar2; + char cVar3; + int *piVar4; + int *piVar5; + + iVar1 = param_2[0x37]; + if (((iVar1 == param_1[0x37]) && (param_2[0x28] == param_1[0x28])) && + (param_2[0x29] == param_1[0x29])) { + uVar2 = FUN_00443290(param_2 + 0x2b); + return uVar2; + } + cVar3 = FUN_00443ac0(param_1[0x37]); + if (((cVar3 != '\0') && (cVar3 = FUN_00443ac0(iVar1), cVar3 != '\0')) && + (DAT_00870340 != (int *)0x0)) { + if (param_1[0x45] == 0) { + (**(code **)(*param_1 + 0x10))(); + piVar4 = param_1; + } + else { + piVar4 = (int *)(**(code **)(*DAT_00870340 + 0x10))(); + if (piVar4 == (int *)0x0) { + return 0; + } + cVar3 = (**(code **)(*piVar4 + 0x58))(param_1[0x28],param_1[0x29],param_1[0x37],0); + if (cVar3 == '\0') { + return 0; + } + } + if (param_2[0x45] == 0) { + (**(code **)(*param_2 + 0x10))(); + } + else { + piVar5 = (int *)(**(code **)(*DAT_00870340 + 0x10))(); + if (piVar5 == (int *)0x0) { + return 0; + } + cVar3 = (**(code **)(*piVar5 + 0x58))(param_2[0x28],param_2[0x29],param_2[0x37],0); + if (cVar3 == '\0') { + return 0; + } + cVar3 = FUN_00443290(param_2 + 0x2b); + param_2 = piVar5; + if (cVar3 == '\0') { + return 0; + } + } + cVar3 = (**(code **)(*piVar4 + 0x68))(param_2); + if (cVar3 != '\0') { + if ((param_1[0x45] != 0) && (cVar3 = FUN_00443290(piVar4 + 0x2b), cVar3 == '\0')) { + return 0; + } + (**(code **)(*param_2 + 0x14))(); + (**(code **)(*piVar4 + 0x14))(); + return 1; + } + } + return 0; +} + + + +// --- FUN_004440d0 at 0x004440D0 (size: 28) --- + +void __fastcall FUN_004440d0(int param_1) + +{ + if (*(void **)(param_1 + 100) != (void *)0x0) { + operator_delete__(*(void **)(param_1 + 100)); + *(undefined4 *)(param_1 + 100) = 0; + } + return; +} + + + +// --- FUN_004440f0 at 0x004440F0 (size: 79) --- + +undefined4 * __fastcall FUN_004440f0(undefined4 *param_1) + +{ + FUN_00415460(DAT_00838f14); + FUN_00447220(); + *param_1 = &PTR_LAB_0079a690; + param_1[0xc] = &PTR_LAB_0079a67c; + FUN_00535a80(); + FUN_00441cd0(); + FUN_00535a80(); + FUN_00443bc0(); + return param_1; +} + + + +// --- FUN_00444150 at 0x00444150 (size: 168) --- + +undefined4 __thiscall +FUN_00444150(int param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4,char param_5) + +{ + char cVar1; + int iVar2; + + *(undefined4 *)(param_1 + 0xa4) = param_3; + *(undefined4 *)(param_1 + 0xa0) = param_2; + *(undefined1 *)(param_1 + 0xd8) = 0; + *(undefined1 *)(param_1 + 0x11c) = 0; + FUN_0043d290(param_4); + *(uint *)(param_1 + 0xa8) = + (uint)*(byte *)(param_1 + 0xe8) * *(int *)(param_1 + 0xa0) * *(int *)(param_1 + 0xa4) >> 3; + FUN_00440fe0(param_1,0,0,*(int *)(param_1 + 0xa0) + -1,*(int *)(param_1 + 0xa4) + -1); + if ((param_5 == '\0') && (cVar1 = FUN_00443ac0(param_4), cVar1 != '\0')) { + return 1; + } + iVar2 = thunk_FUN_005df0f5(*(undefined4 *)(param_1 + 0xa8)); + *(int *)(param_1 + 0x114) = iVar2; + if (iVar2 != 0) { + return 1; + } + return 0; +} + + + +// --- FUN_00444200 at 0x00444200 (size: 753) --- + +/* WARNING: Function: __chkstk replaced with injection: alloca_probe */ + +undefined4 __fastcall FUN_00444200(int *param_1) + +{ + byte bVar1; + char cVar2; + int iVar3; + uint uVar4; + int unaff_EBX; + int *piVar5; + undefined4 unaff_ESI; + uint uVar6; + undefined4 *puVar7; + undefined4 *puVar8; + undefined4 *puVar9; + uint uStack_4ed0; + undefined4 uStack_4ecc; + int *local_4ec8; + uint local_4ec4; + undefined4 *puStack_4ec0; + undefined4 uStack_4ebc; + int *local_4eb8; + uint local_4eac; + undefined1 auStack_4e80 [4]; + undefined4 *puStack_4e7c; + undefined1 *puStack_4e74; + int local_4e70 [9]; + int local_4e4c; + int local_4e48; + uint local_4e44; + int *local_4e40; + int local_4e3c; + undefined4 uStack_c; + + uStack_c = 0x444210; + if (param_1[0x19] == 0) { + return 0; + } + if (DAT_00870340 == (int *)0x0) { + return 0; + } + uVar6 = param_1[0x1a]; + local_4ec4 = param_1[0x16]; + local_4ec8 = (int *)param_1[0x17]; + if (uVar6 == 500) { + piVar5 = local_4e70; + for (iVar3 = 0x139a; iVar3 != 0; iVar3 = iVar3 + -1) { + *piVar5 = 0; + piVar5 = piVar5 + 1; + } + iVar3 = FUN_00615c60(local_4e70); + if (iVar3 != 0) { + return 0; + } + local_4e4c = param_1[0x19]; + local_4e48 = param_1[0x18]; + iVar3 = FUN_00616de0(local_4e70,1); + if (iVar3 != 0) { + return 0; + } + local_4ec4 = local_4e44; + local_4ec8 = local_4e40; + uVar6 = 0x14; + if (local_4e3c != 3) { + return 0; + } + } + uStack_4ecc = (undefined4 *)((uint)uStack_4ecc & 0xffffff); + local_4eac = FUN_00443cf0(uVar6); + if (local_4eac == uVar6) { + local_4eb8 = param_1; + (**(code **)(*param_1 + 0x10))(); + piVar5 = param_1; + } + else { + uStack_4ecc = (undefined4 *)CONCAT13(1,(undefined3)uStack_4ecc); + local_4eb8 = (int *)(**(code **)(*DAT_00870340 + 0x10))(); + piVar5 = local_4eb8; + if (local_4eb8 == (int *)0x0) { + return 0; + } + } + cVar2 = (**(code **)(*piVar5 + 0x58))(local_4ec4,local_4ec8,uVar6,1); + if ((cVar2 != '\0') && + (cVar2 = (**(code **)(*piVar5 + 0x60))(piVar5 + 0x2e,1,&uStack_4ed0,&puStack_4ec0), + cVar2 != '\0')) { + if (puStack_4ec0 == (undefined4 *)0x0) { + (**(code **)(*piVar5 + 0x14))(); + return 0; + } + if (param_1[0x1a] == 500) { + FUN_00535a80(); + FUN_0043d290(uVar6); + local_4e70[0] = uStack_4ed0 - ((local_4eac & 0xff) * unaff_EBX >> 3); + local_4e70[1] = 3; + local_4e70[2] = 2; + puStack_4e7c = puStack_4ec0; + local_4e48 = 3; + puStack_4e74 = &stack0xfffffffc; + iVar3 = FUN_00616de0(auStack_4e80,3); + if (iVar3 != 0) { + return 0; + } + iVar3 = FUN_006163f0(auStack_4e80); + if (iVar3 != 0) { + return 0; + } + } + else { + puVar8 = (undefined4 *)param_1[0x19]; + if ((*(byte *)(param_1 + 0x1b) & 4) == 0) { + uVar6 = (uint)*(byte *)(param_1 + 0x1d) * param_1[0x16] >> 3; + uStack_4ecc = puVar8; + if (uStack_4ed0 == uVar6) { + uVar6 = param_1[0x18]; + for (uVar4 = uVar6 >> 2; uVar4 != 0; uVar4 = uVar4 - 1) { + *puStack_4ec0 = *puVar8; + puVar8 = puVar8 + 1; + puStack_4ec0 = puStack_4ec0 + 1; + } + for (uVar6 = uVar6 & 3; uVar6 != 0; uVar6 = uVar6 - 1) { + *(undefined1 *)puStack_4ec0 = *(undefined1 *)puVar8; + puVar8 = (undefined4 *)((int)puVar8 + 1); + puStack_4ec0 = (undefined4 *)((int)puStack_4ec0 + 1); + } + } + else { + local_4ec4 = 0; + if (param_1[0x17] != 0) { + do { + bVar1 = *(byte *)(param_1 + 0x1d); + iVar3 = param_1[0x16]; + puVar7 = puVar8; + puVar9 = puStack_4ec0; + for (uVar4 = (uint)bVar1 * iVar3 >> 5; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar9 = *puVar7; + puVar7 = puVar7 + 1; + puVar9 = puVar9 + 1; + } + for (uVar4 = (uint)bVar1 * iVar3 >> 3 & 3; uVar4 != 0; uVar4 = uVar4 - 1) { + *(undefined1 *)puVar9 = *(undefined1 *)puVar7; + puVar7 = (undefined4 *)((int)puVar7 + 1); + puVar9 = (undefined4 *)((int)puVar9 + 1); + } + puStack_4ec0 = (undefined4 *)((int)puStack_4ec0 + uStack_4ed0); + puVar8 = (undefined4 *)((int)puVar8 + uVar6); + local_4ec4 = local_4ec4 + 1; + piVar5 = local_4ec8; + uStack_4ecc = puVar8; + } while (local_4ec4 < (uint)param_1[0x17]); + } + } + } + else { + uVar6 = param_1[0x18]; + for (uVar4 = uVar6 >> 2; uVar4 != 0; uVar4 = uVar4 - 1) { + *puStack_4ec0 = *puVar8; + puVar8 = puVar8 + 1; + puStack_4ec0 = puStack_4ec0 + 1; + } + for (uVar6 = uVar6 & 3; uVar6 != 0; uVar6 = uVar6 - 1) { + *(undefined1 *)puStack_4ec0 = *(undefined1 *)puVar8; + puVar8 = (undefined4 *)((int)puVar8 + 1); + puStack_4ec0 = (undefined4 *)((int)puStack_4ec0 + 1); + } + } + } + (**(code **)(*piVar5 + 100))(); + FUN_004440d0(); + if (((char)((uint)unaff_ESI >> 0x18) == '\0') || + ((cVar2 = (**(code **)(*param_1 + 0x58))(unaff_EBX,&stack0xfffffffc,uStack_4ebc,1), + cVar2 != '\0' && (cVar2 = (**(code **)(*param_1 + 0x68))(piVar5), cVar2 != '\0')))) { + (**(code **)(*piVar5 + 0x14))(); + return 1; + } + } + (**(code **)(*piVar5 + 0x14))(); + return 0; +} + + + +// --- FUN_00444540 at 0x00444540 (size: 63) --- + +void __fastcall FUN_00444540(int param_1) + +{ + if (*(void **)(param_1 + 100) != (void *)0x0) { + operator_delete__(*(void **)(param_1 + 100)); + *(undefined4 *)(param_1 + 100) = 0; + } + if (*(void **)(param_1 + 0x114) != (void *)0x0) { + operator_delete__(*(void **)(param_1 + 0x114)); + *(undefined4 *)(param_1 + 0x114) = 0; + } + FUN_00443bc0(); + return; +} + + + +// --- FUN_00444580 at 0x00444580 (size: 104) --- + +void __fastcall FUN_00444580(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_0079a690; + param_1[0xc] = &PTR_LAB_0079a67c; + if ((void *)param_1[0x19] != (void *)0x0) { + operator_delete__((void *)param_1[0x19]); + param_1[0x19] = 0; + } + if ((void *)param_1[0x45] != (void *)0x0) { + operator_delete__((void *)param_1[0x45]); + param_1[0x45] = 0; + } + param_1[0x2b] = &PTR_FUN_00799d14; + FUN_00440f40(); + FUN_00446f00(); + FUN_004154b0(); + return; +} + + + +// --- FUN_00444620 at 0x00444620 (size: 30) --- + +void * __thiscall FUN_00444620(void *param_1,byte param_2) + +{ + FUN_00444580(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00444800 at 0x00444800 (size: 21) --- + +undefined4 * __fastcall FUN_00444800(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_0079a750; + FUN_00406d60(); + return param_1; +} + + + +// --- FUN_00444850 at 0x00444850 (size: 45) --- + +undefined4 * __thiscall FUN_00444850(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079a750; + FUN_00406f90(); + *param_1 = &PTR_FUN_0079702c; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00444880 at 0x00444880 (size: 75) --- + +undefined4 __thiscall FUN_00444880(float *param_1,float *param_2,float param_3) + +{ + float fVar1; + undefined4 uVar2; + + fVar1 = *param_2 * *param_1 + param_2[1] * param_1[1] + param_2[2] * param_1[2] + param_1[3]; + if (param_3 < fVar1) { + return 0; + } + uVar2 = 1; + if (-param_3 <= fVar1) { + uVar2 = 2; + } + return uVar2; +} + + + +// --- FUN_00444900 at 0x00444900 (size: 228) --- + +void FUN_00444900(undefined4 param_1,uint param_2) + +{ + char cVar1; + uint uVar2; + undefined4 *puVar3; + undefined4 *puVar4; + undefined4 uVar5; + uint uVar6; + undefined4 *puVar7; + undefined1 local_c [12]; + + uVar6 = param_2; + if (((byte)*(undefined4 *)(param_2 + 4) & 5) == 1) { + param_2 = FUN_00406db0(); + } + FUN_004449f0(¶m_2,uVar6); + if ((*(byte *)(uVar6 + 4) & 5) == 0) { + uVar2 = FUN_0040a8f0(); + if (uVar2 < param_2) { +LAB_0044495b: + FUN_0040aa50(); + return; + } + uVar2 = FUN_00406db0(); + if (uVar2 < param_2) { + cVar1 = FUN_00406d70(); + if (cVar1 == '\0') goto LAB_0044495b; + FUN_004074b0(param_2,1); + } + } + uVar2 = param_2; + puVar3 = (undefined4 *)FUN_00406d80(); + puVar4 = (undefined4 *)FUN_0040acf0(uVar2); + if (puVar4 != (undefined4 *)0x0) { + if ((*(byte *)(uVar6 + 4) & 1) == 0) { + puVar7 = puVar4; + for (uVar6 = uVar2 >> 2; uVar6 != 0; uVar6 = uVar6 - 1) { + *puVar3 = *puVar7; + puVar7 = puVar7 + 1; + puVar3 = puVar3 + 1; + } + } + else { + puVar7 = puVar3; + puVar3 = puVar4; + for (uVar6 = uVar2 >> 2; uVar6 != 0; uVar6 = uVar6 - 1) { + *puVar3 = *puVar7; + puVar7 = puVar7 + 1; + puVar3 = puVar3 + 1; + } + } + for (uVar2 = uVar2 & 3; uVar2 != 0; uVar2 = uVar2 - 1) { + *(undefined1 *)puVar3 = *(undefined1 *)puVar7; + puVar7 = (undefined4 *)((int)puVar7 + 1); + puVar3 = (undefined4 *)((int)puVar3 + 1); + } + } + uVar5 = FUN_00407140(local_c,0,param_2); + FUN_004070d0(uVar5); + FUN_00406f90(); + return; +} + + + +// --- FUN_004449f0 at 0x004449F0 (size: 49) --- + +void FUN_004449f0(undefined4 *param_1,int param_2) + +{ + undefined4 *puVar1; + + FUN_0040ad10(4); + puVar1 = (undefined4 *)FUN_0040acf0(4); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *puVar1 = *param_1; + return; + } + *param_1 = *puVar1; + } + return; +} + + + +// --- FUN_00444a30 at 0x00444A30 (size: 139) --- + +undefined4 __fastcall FUN_00444a30(int param_1) + +{ + int *piVar1; + undefined4 uVar2; + int iVar3; + uint uVar4; + undefined1 local_d; + + iVar3 = *(int *)(param_1 + 0x38); + local_d = 1; + if ((iVar3 != 0) && (uVar4 = 0, *(int *)(iVar3 + 0x10) != 0)) { + do { + piVar1 = (int *)(*(int *)(iVar3 + 8) + uVar4 * 8); + if (*piVar1 != DAT_00839058) { + uVar2 = FUN_004220b0(*piVar1,0x21); + iVar3 = FUN_00415430(uVar2); + if (iVar3 == 0) { + local_d = 0; + } + else { + if ((int *)piVar1[1] != (int *)0x0) { + (**(code **)(*(int *)piVar1[1] + 0x14))(); + piVar1[1] = 0; + } + piVar1[1] = iVar3; + } + } + iVar3 = *(int *)(param_1 + 0x38); + uVar4 = uVar4 + 1; + } while (uVar4 < *(uint *)(iVar3 + 0x10)); + return CONCAT31((int3)((uint)iVar3 >> 8),local_d); + } + return CONCAT31((int3)((uint)iVar3 >> 8),1); +} + + + +// --- FUN_00444b00 at 0x00444B00 (size: 117) --- + +void __fastcall FUN_00444b00(int param_1) + +{ + int iVar1; + uint uVar2; + uint uVar3; + int *piVar4; + int *piVar5; + uint local_4; + + *(undefined1 *)(param_1 + 0x71) = 0; + local_4 = 0; + if (*(int *)(param_1 + 0x58) == 0) { + return; + } + piVar4 = *(int **)(param_1 + 0x50); + do { + iVar1 = *(int *)(*(int *)(param_1 + 0x44) + *piVar4 * 4); + uVar2 = *(uint *)(iVar1 + 0x14); + uVar3 = 0; + if (uVar2 != 0) { + piVar5 = *(int **)(iVar1 + 0xc); + do { + if (*(int *)(*(int *)(*(int *)(*(int *)(*(int *)(*piVar5 + 0xc) + 0x3c) + 8) + + *(int *)(*piVar5 + 0x14) * 4) + 0x20) != 0) { + *(undefined1 *)(param_1 + 0x71) = 1; + return; + } + uVar3 = uVar3 + 1; + piVar5 = piVar5 + 1; + } while (uVar3 < uVar2); + } + local_4 = local_4 + 1; + piVar4 = piVar4 + 1; + } while (local_4 < *(uint *)(param_1 + 0x58)); + return; +} + + + +// --- FUN_00444b80 at 0x00444B80 (size: 109) --- + +void __fastcall FUN_00444b80(int param_1) + +{ + int iVar1; + undefined4 *puVar2; + uint uVar3; + undefined4 *puVar4; + + if (*(int *)(param_1 + 0x58) != 0) { + FUN_005b2ea0(); + iVar1 = *(int *)(*(int *)(param_1 + 0x44) + **(int **)(param_1 + 0x50) * 4); + uVar3 = 0; + if (*(int *)(iVar1 + 0x14) != 0) { + do { + FUN_005b2e20(param_1 + 0x7c); + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(iVar1 + 0x14)); + } + return; + } + puVar2 = &DAT_008ef180; + puVar4 = (undefined4 *)(param_1 + 0x7c); + for (iVar1 = 6; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar4 = *puVar2; + puVar2 = puVar2 + 1; + puVar4 = puVar4 + 1; + } + return; +} + + + +// --- FUN_00444bf0 at 0x00444BF0 (size: 350) --- + +uint __thiscall FUN_00444bf0(int param_1,int param_2) + +{ + int iVar1; + int iVar2; + char cVar3; + uint uVar4; + int *piVar5; + int iVar6; + char local_11; + undefined4 local_10; + int local_c; + uint local_8; + int local_4; + + uVar4 = 0; + local_11 = '\0'; + if (*(uint *)(param_1 + 0x4c) != 0) { + piVar5 = *(int **)(param_1 + 0x44); + while (*(int *)(*piVar5 + 0x1c) != param_2) { + uVar4 = uVar4 + 1; + piVar5 = piVar5 + 1; + if (*(uint *)(param_1 + 0x4c) <= uVar4) { + return uVar4 & 0xffffff00; + } + } + iVar6 = (*(int **)(param_1 + 0x44))[uVar4]; + if (iVar6 != 0) { + uVar4 = 0; + local_8 = 0; + local_c = iVar6; + if (*(int *)(iVar6 + 0x14) != 0) { + do { + iVar1 = *(int *)(*(int *)(iVar6 + 0xc) + local_8 * 4); + param_2 = *(undefined4 *)(iVar1 + 0x2c); + piVar5 = *(int **)(*(int *)(*(int *)(*(int *)(iVar1 + 0xc) + 0x3c) + 8) + + *(int *)(iVar1 + 0x14) * 4); + local_10 = *(undefined4 *)(iVar1 + 0x30); + if (*(int *)(iVar1 + 0x18) == -1) { + cVar3 = (**(code **)(*piVar5 + 0x18)) + (*(undefined4 *)(iVar1 + 8),0,*(undefined4 *)(iVar1 + 0x20),¶m_2, + &local_10); + if (cVar3 == '\0') goto LAB_00444d0e; + local_11 = '\x01'; +LAB_00444d16: + *(undefined4 *)(iVar1 + 0x24) = 0; + *(undefined4 *)(iVar1 + 0x28) = 0; + *(int *)(iVar1 + 0x2c) = param_2; + *(undefined4 *)(iVar1 + 0x30) = local_10; + } + else { + iVar6 = *(int *)(*(int *)(*(int *)(*(int *)(iVar1 + 0xc) + 0x40) + 8) + + *(int *)(iVar1 + 0x18) * 4); + FUN_0044cb90(); + iVar2 = *(int *)(iVar6 + 0x20); + FUN_0044cb90(); + local_4 = *(int *)(iVar6 + 0x1c); + FUN_0044cb90(); + cVar3 = (**(code **)(*piVar5 + 0x14)) + (*(undefined4 *)(iVar1 + 8),*(undefined4 *)(iVar1 + 0x1c), + *(undefined4 *)(iVar1 + 0x20),*(undefined4 *)(iVar6 + 0x1c), + (iVar2 - local_4) + 1,0,iVar6,0,¶m_2,&local_10,1); + iVar6 = local_c; + if (cVar3 != '\0') { + local_11 = '\x01'; + goto LAB_00444d16; + } +LAB_00444d0e: + if (local_11 != '\0') goto LAB_00444d16; + } + uVar4 = local_8 + 1; + local_8 = uVar4; + } while (uVar4 < *(uint *)(iVar6 + 0x14)); + } + return CONCAT31((int3)(uVar4 >> 8),local_11); + } + } + return uVar4 & 0xffffff00; +} + + + +// --- FUN_00444d50 at 0x00444D50 (size: 53) --- + +void __fastcall FUN_00444d50(int param_1) + +{ + uint uVar1; + + FUN_00444a30(); + uVar1 = 0; + if (*(int *)(param_1 + 0x58) != 0) { + do { + if (*(int *)(*(int *)(*(int *)(param_1 + 0x44) + + *(int *)(*(int *)(param_1 + 0x50) + uVar1 * 4) * 4) + 0x18) == 0) { + FUN_0044f1e0(); + } + uVar1 = uVar1 + 1; + } while (uVar1 < *(uint *)(param_1 + 0x58)); + } + return; +} + + + +// --- FUN_00444d90 at 0x00444D90 (size: 46) --- + +void __fastcall FUN_00444d90(int param_1) + +{ + uint uVar1; + + FUN_00444a30(); + uVar1 = 0; + if (*(int *)(param_1 + 0x58) != 0) { + do { + FUN_0044e7e0(); + uVar1 = uVar1 + 1; + } while (uVar1 < *(uint *)(param_1 + 0x58)); + } + return; +} + + + +// --- FUN_00444dc0 at 0x00444DC0 (size: 99) --- + +void __fastcall FUN_00444dc0(int *param_1) + +{ + int iVar1; + int iVar2; + undefined4 local_8; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) == 0x80000000) { + if (*param_1 != 0) { + operator_delete__((void *)(*param_1 + -4)); + } + *param_1 = 0; + param_1[1] = 0; + return; + } + if (*param_1 != 0) { + iVar2 = (param_1[1] & 0x7fffffffU) - 1; + while (-1 < iVar2) { + iVar2 = iVar2 + -1; + iVar1 = *param_1; + *(undefined4 *)(iVar1 + 8 + iVar2 * 8) = local_8; + *(undefined4 *)(iVar1 + 0xc + iVar2 * 8) = 0; + } + } + return; +} + + + +// --- FUN_00444e30 at 0x00444E30 (size: 193) --- + +undefined4 __thiscall FUN_00444e30(int *param_1,uint param_2) + +{ + uint *puVar1; + int iVar2; + uint *puVar3; + int iVar4; + + if ((uint)param_1[2] <= param_2) { + if (param_2 <= (param_1[1] & 0x7fffffffU)) { + return 1; + } + if (param_2 == 0) { + FUN_00444dc0(); + return 1; + } + puVar3 = (uint *)thunk_FUN_005df0f5(param_2 * 8 + 4); + if (puVar3 != (uint *)0x0) { + puVar1 = puVar3 + 1; + *puVar3 = param_2; + FUN_00401000(puVar1,8,param_2,&LAB_004448d0); + if (puVar1 != (uint *)0x0) { + if (*param_1 != 0) { + iVar4 = param_1[2] + -1; + while (-1 < iVar4) { + iVar4 = iVar4 + -1; + iVar2 = *param_1; + puVar3[iVar4 * 2 + 3] = *(uint *)(iVar2 + 8 + iVar4 * 8); + puVar3[iVar4 * 2 + 4] = *(uint *)(iVar2 + 0xc + iVar4 * 8); + } + if (((param_1[1] & 0x80000000U) == 0x80000000) && (*param_1 != 0)) { + operator_delete__((void *)(*param_1 + -4)); + } + } + *param_1 = (int)puVar1; + param_1[1] = param_2 | 0x80000000; + return 1; + } + } + } + return 0; +} + + + +// --- FUN_00444f00 at 0x00444F00 (size: 196) --- + +undefined1 __fastcall FUN_00444f00(int param_1) + +{ + char cVar1; + int iVar2; + int *piVar3; + LONG LVar4; + undefined1 uVar5; + int unaff_ESI; + int iStack_4; + + uVar5 = 0; + if (*(int **)(param_1 + 8) != (int *)0x0) { + iStack_4 = param_1; + iVar2 = (**(code **)(**(int **)(param_1 + 8) + 4))(); + if (iVar2 == 9) { + FUN_004070d0(*(int **)(param_1 + 8) + 1); + return 1; + } + (**(code **)(**(int **)(param_1 + 8) + 0x14))(&iStack_4); + piVar3 = (int *)FUN_005df0f5(0x10); + if (piVar3 == (int *)0x0) { + piVar3 = (int *)0x0; + } + else { + *piVar3 = (int)&PTR_FUN_0079a750; + FUN_00406d60(); + } + cVar1 = (**(code **)(*piVar3 + 0x10))(&stack0xfffffff8); + if (cVar1 == '\0') { + (**(code **)*piVar3)(1); + uVar5 = 0; + } + else { + FUN_004070d0(piVar3 + 1); + if (*(undefined4 **)(param_1 + 8) != (undefined4 *)0x0) { + (**(code **)**(undefined4 **)(param_1 + 8))(1); + } + *(int **)(param_1 + 8) = piVar3; + uVar5 = 1; + } + LVar4 = InterlockedDecrement((LONG *)(unaff_ESI + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(unaff_ESI + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(unaff_ESI + -0x14))(1); + } + } + return uVar5; +} + + + +// --- FUN_00444fd0 at 0x00444FD0 (size: 108) --- + +void __fastcall FUN_00444fd0(undefined4 *param_1) + +{ + int *piVar1; + uint uVar2; + + uVar2 = 0; + *param_1 = &PTR_FUN_0079a770; + if (param_1[4] != 0) { + do { + piVar1 = *(int **)(param_1[2] + 4 + uVar2 * 8); + if (piVar1 != (int *)0x0) { + (**(code **)(*piVar1 + 0x14))(); + *(undefined4 *)(param_1[2] + 4 + uVar2 * 8) = 0; + } + uVar2 = uVar2 + 1; + } while (uVar2 < (uint)param_1[4]); + } + FUN_00444dc0(); + if (((param_1[3] & 0x80000000) == 0x80000000) && (param_1[2] != 0)) { + operator_delete__((void *)(param_1[2] + -4)); + } + *param_1 = &PTR_LAB_00796c4c; + return; +} + + + +// --- FUN_00445040 at 0x00445040 (size: 180) --- + +void __fastcall FUN_00445040(undefined4 *param_1) + +{ + int *piVar1; + undefined4 *puVar2; + int iVar3; + uint uVar4; + + uVar4 = 0; + *param_1 = &PTR_FUN_0079a774; + if (param_1[4] != 0) { + do { + puVar2 = *(undefined4 **)(param_1[2] + uVar4 * 4); + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + *(undefined4 *)(param_1[2] + uVar4 * 4) = 0; + } + uVar4 = uVar4 + 1; + } while (uVar4 < (uint)param_1[4]); + } + param_1[4] = 0; + if ((param_1[3] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[2]); + param_1[2] = 0; + param_1[3] = 0; + } + else if (param_1[2] != 0) { + iVar3 = (param_1[3] & 0x7fffffff) - 1; + while (-1 < iVar3) { + iVar3 = iVar3 + -1; + *(undefined4 *)(param_1[2] + 4 + iVar3 * 4) = 0; + } + } + if ((param_1[3] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[2]); + } + *param_1 = &PTR_LAB_00796c4c; + return; +} + + + +// --- FUN_00445100 at 0x00445100 (size: 180) --- + +void __fastcall FUN_00445100(undefined4 *param_1) + +{ + undefined4 *puVar1; + int iVar2; + uint uVar3; + + uVar3 = 0; + *param_1 = &PTR_FUN_0079a778; + if (param_1[4] != 0) { + do { + puVar1 = *(undefined4 **)(param_1[2] + uVar3 * 4); + if (puVar1 != (undefined4 *)0x0) { + (**(code **)*puVar1)(1); + } + *(undefined4 *)(param_1[2] + uVar3 * 4) = 0; + uVar3 = uVar3 + 1; + } while (uVar3 < (uint)param_1[4]); + } + param_1[4] = 0; + if ((param_1[3] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[2]); + param_1[2] = 0; + param_1[3] = 0; + } + else if (param_1[2] != 0) { + iVar2 = (param_1[3] & 0x7fffffff) - 1; + while (-1 < iVar2) { + iVar2 = iVar2 + -1; + *(undefined4 *)(param_1[2] + 4 + iVar2 * 4) = 0; + } + } + if ((param_1[3] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[2]); + } + *param_1 = &PTR_LAB_00796c4c; + return; +} + + + +// --- FUN_004451c0 at 0x004451C0 (size: 252) --- + +undefined4 * __fastcall FUN_004451c0(undefined4 *param_1) + +{ + FUN_00415460(DAT_00839058); + *param_1 = &PTR_LAB_0079a780; + param_1[0xc] = 7; + param_1[0xd] = 0; + param_1[0xe] = 0; + param_1[0xf] = 0; + param_1[0x10] = 0; + param_1[0x11] = 0; + param_1[0x12] = 0; + param_1[0x13] = 0; + param_1[0x14] = 0; + param_1[0x15] = 0; + param_1[0x16] = 0; + param_1[0x17] = 0; + param_1[0x18] = 0; + param_1[0x19] = 0; + *(undefined1 *)(param_1 + 0x1b) = 0; + *(undefined1 *)((int)param_1 + 0x6d) = 0; + *(undefined1 *)((int)param_1 + 0x6e) = 0; + *(undefined1 *)((int)param_1 + 0x6f) = 0; + *(undefined1 *)(param_1 + 0x1c) = 0; + *(undefined1 *)((int)param_1 + 0x71) = 0; + *(undefined1 *)((int)param_1 + 0x72) = 0; + param_1[0x1a] = 0xffffffff; + param_1[0x1d] = 0xffffffff; + param_1[0x1e] = 0xffffffff; + param_1[0x1f] = DAT_008ef180; + param_1[0x20] = DAT_008ef184; + param_1[0x21] = DAT_008ef188; + param_1[0x22] = DAT_008ef18c; + param_1[0x23] = DAT_008ef190; + param_1[0x24] = DAT_008ef194; + param_1[0x25] = DAT_008ef180; + param_1[0x26] = DAT_008ef184; + param_1[0x27] = DAT_008ef188; + param_1[0x28] = DAT_008ef18c; + param_1[0x29] = DAT_008ef190; + param_1[0x2a] = DAT_008ef194; + *(undefined1 *)(param_1 + 0x2b) = 0; + return param_1; +} + + + +// --- FUN_004452d0 at 0x004452D0 (size: 277) --- + +void __fastcall FUN_004452d0(int param_1) + +{ + int *piVar1; + undefined4 *puVar2; + int iVar3; + uint uVar4; + + uVar4 = 0; + *(undefined4 *)(param_1 + 0x30) = 7; + if (*(int *)(param_1 + 0x4c) != 0) { + do { + puVar2 = *(undefined4 **)(*(int *)(param_1 + 0x44) + uVar4 * 4); + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + *(undefined4 *)(*(int *)(param_1 + 0x44) + uVar4 * 4) = 0; + } + uVar4 = uVar4 + 1; + } while (uVar4 < *(uint *)(param_1 + 0x4c)); + } + *(undefined4 *)(param_1 + 0x4c) = 0; + if ((*(uint *)(param_1 + 0x48) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)(param_1 + 0x44)); + *(undefined4 *)(param_1 + 0x44) = 0; + *(undefined4 *)(param_1 + 0x48) = 0; + } + else if (*(int *)(param_1 + 0x44) != 0) { + iVar3 = (*(uint *)(param_1 + 0x48) & 0x7fffffff) - 1; + while (-1 < iVar3) { + iVar3 = iVar3 + -1; + *(undefined4 *)(*(int *)(param_1 + 0x44) + 4 + iVar3 * 4) = 0; + } + } + *(undefined4 *)(param_1 + 0x58) = 0; + if ((*(uint *)(param_1 + 0x54) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)(param_1 + 0x50)); + *(undefined4 *)(param_1 + 0x50) = 0; + *(undefined4 *)(param_1 + 0x54) = 0; + } + else if (*(int *)(param_1 + 0x50) != 0) { + iVar3 = (*(uint *)(param_1 + 0x54) & 0x7fffffff) - 1; + while (-1 < iVar3) { + iVar3 = iVar3 + -1; + *(undefined4 *)(*(int *)(param_1 + 0x50) + 4 + iVar3 * 4) = 0; + } + } + *(undefined4 *)(param_1 + 100) = 0; + if ((*(uint *)(param_1 + 0x60) & 0x80000000) != 0x80000000) { + if (*(int *)(param_1 + 0x5c) != 0) { + iVar3 = (*(uint *)(param_1 + 0x60) & 0x7fffffff) - 1; + while (-1 < iVar3) { + iVar3 = iVar3 + -1; + *(undefined4 *)(*(int *)(param_1 + 0x5c) + 4 + iVar3 * 4) = 0; + } + } + *(undefined4 *)(param_1 + 0x68) = 0xffffffff; + return; + } + operator_delete__(*(void **)(param_1 + 0x5c)); + *(undefined4 *)(param_1 + 0x5c) = 0; + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 0x68) = 0xffffffff; + return; +} + + + +// --- FUN_004453f0 at 0x004453F0 (size: 186) --- + +void __fastcall FUN_004453f0(int param_1) + +{ + int *piVar1; + int iVar2; + undefined4 *puVar3; + undefined4 *puVar4; + + FUN_0044dcb0(); + FUN_0044dcb0(); + *(undefined4 *)(param_1 + 0x68) = 0xffffffff; + FUN_004452d0(); + *(uint *)(param_1 + 0x30) = *(uint *)(param_1 + 0x30) | 1; + puVar3 = *(undefined4 **)(param_1 + 0x38); + if (puVar3 != (undefined4 *)0x0) { + piVar1 = puVar3 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar3)(1); + } + *(undefined4 *)(param_1 + 0x38) = 0; + } + *(uint *)(param_1 + 0x30) = *(uint *)(param_1 + 0x30) | 2; + puVar3 = *(undefined4 **)(param_1 + 0x3c); + if (puVar3 != (undefined4 *)0x0) { + piVar1 = puVar3 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar3)(1); + } + *(undefined4 *)(param_1 + 0x3c) = 0; + } + *(uint *)(param_1 + 0x30) = *(uint *)(param_1 + 0x30) | 4; + puVar3 = *(undefined4 **)(param_1 + 0x40); + if (puVar3 != (undefined4 *)0x0) { + piVar1 = puVar3 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar3)(1); + } + *(undefined4 *)(param_1 + 0x40) = 0; + } + *(undefined4 *)(param_1 + 0x74) = 0xffffffff; + *(undefined4 *)(param_1 + 0x78) = 0xffffffff; + *(undefined4 *)(param_1 + 0x34) = 0; + *(undefined1 *)(param_1 + 0x6c) = 0; + *(undefined1 *)(param_1 + 0x6d) = 0; + *(undefined1 *)(param_1 + 0x6e) = 0; + *(undefined1 *)(param_1 + 0x6f) = 0; + *(undefined1 *)(param_1 + 0x70) = 0; + *(undefined1 *)(param_1 + 0x71) = 0; + *(undefined1 *)(param_1 + 0x72) = 0; + puVar3 = &DAT_008ef180; + puVar4 = (undefined4 *)(param_1 + 0x7c); + for (iVar2 = 6; iVar2 != 0; iVar2 = iVar2 + -1) { + *puVar4 = *puVar3; + puVar3 = puVar3 + 1; + puVar4 = puVar4 + 1; + } + puVar3 = &DAT_008ef180; + puVar4 = (undefined4 *)(param_1 + 0x94); + for (iVar2 = 6; iVar2 != 0; iVar2 = iVar2 + -1) { + *puVar4 = *puVar3; + puVar3 = puVar3 + 1; + puVar4 = puVar4 + 1; + } + *(undefined1 *)(param_1 + 0xac) = 0; + return; +} + + + +// --- FUN_00445540 at 0x00445540 (size: 30) --- + +void * __thiscall FUN_00445540(void *param_1,byte param_2) + +{ + FUN_00444fd0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00445560 at 0x00445560 (size: 30) --- + +void * __thiscall FUN_00445560(void *param_1,byte param_2) + +{ + FUN_00445040(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00445580 at 0x00445580 (size: 30) --- + +void * __thiscall FUN_00445580(void *param_1,byte param_2) + +{ + FUN_00445100(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004455a0 at 0x004455A0 (size: 107) --- + +void __fastcall FUN_004455a0(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_0079a780; + FUN_004453f0(); + if ((param_1[0x18] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0x17]); + } + if ((param_1[0x15] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0x14]); + } + if ((param_1[0x12] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0x11]); + } + FUN_004154b0(); + return; +} + + + +// --- FUN_00445610 at 0x00445610 (size: 30) --- + +void * __thiscall FUN_00445610(void *param_1,byte param_2) + +{ + FUN_004455a0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00445630 at 0x00445630 (size: 131) --- + +undefined4 __thiscall FUN_00445630(int param_1,undefined4 param_2,undefined4 param_3) + +{ + int iVar1; + undefined4 uVar2; + int iVar3; + int iVar4; + char cVar5; + undefined4 *puVar6; + uint uVar7; + undefined4 uVar8; + + if (*(int *)(param_1 + 0x38) == 0) { + puVar6 = (undefined4 *)FUN_005df0f5(0x14); + if (puVar6 == (undefined4 *)0x0) { + puVar6 = (undefined4 *)0x0; + } + else { + puVar6[1] = 1; + *puVar6 = &PTR_FUN_0079a770; + puVar6[2] = 0; + puVar6[3] = 0; + puVar6[4] = 0; + } + *(undefined4 **)(param_1 + 0x38) = puVar6; + } + iVar1 = *(int *)(param_1 + 0x38); + uVar2 = *(undefined4 *)(iVar1 + 0x10); + uVar7 = *(uint *)(iVar1 + 0xc) & 0x7fffffff; + if (uVar7 <= *(uint *)(iVar1 + 0x10)) { + uVar8 = FUN_00453850(uVar7 + 1); + cVar5 = FUN_00444e30(uVar8); + if (cVar5 == '\0') { + return uVar2; + } + } + iVar3 = *(int *)(iVar1 + 0x10); + iVar4 = *(int *)(iVar1 + 8); + *(undefined4 *)(iVar4 + iVar3 * 8) = param_2; + *(undefined4 *)(iVar4 + 4 + iVar3 * 8) = param_3; + *(int *)(iVar1 + 0x10) = *(int *)(iVar1 + 0x10) + 1; + return uVar2; +} + + + +// --- FUN_004456c0 at 0x004456C0 (size: 123) --- + +undefined4 __thiscall FUN_004456c0(int param_1,undefined4 param_2) + +{ + int iVar1; + undefined4 uVar2; + char cVar3; + undefined4 *puVar4; + uint uVar5; + undefined4 uVar6; + + if (*(int *)(param_1 + 0x3c) == 0) { + puVar4 = (undefined4 *)FUN_005df0f5(0x14); + if (puVar4 == (undefined4 *)0x0) { + puVar4 = (undefined4 *)0x0; + } + else { + puVar4[1] = 1; + *puVar4 = &PTR_FUN_0079a774; + puVar4[2] = 0; + puVar4[3] = 0; + puVar4[4] = 0; + } + *(undefined4 **)(param_1 + 0x3c) = puVar4; + } + iVar1 = *(int *)(param_1 + 0x3c); + uVar2 = *(undefined4 *)(iVar1 + 0x10); + uVar5 = *(uint *)(iVar1 + 0xc) & 0x7fffffff; + if (uVar5 <= *(uint *)(iVar1 + 0x10)) { + uVar6 = FUN_00453850(uVar5 + 1); + cVar3 = FUN_004180a0(uVar6); + if (cVar3 == '\0') { + return uVar2; + } + } + *(undefined4 *)(*(int *)(iVar1 + 8) + *(int *)(iVar1 + 0x10) * 4) = param_2; + *(int *)(iVar1 + 0x10) = *(int *)(iVar1 + 0x10) + 1; + return uVar2; +} + + + +// --- FUN_00445740 at 0x00445740 (size: 123) --- + +undefined4 __thiscall FUN_00445740(int param_1,undefined4 param_2) + +{ + int iVar1; + undefined4 uVar2; + char cVar3; + undefined4 *puVar4; + uint uVar5; + undefined4 uVar6; + + if (*(int *)(param_1 + 0x40) == 0) { + puVar4 = (undefined4 *)FUN_005df0f5(0x14); + if (puVar4 == (undefined4 *)0x0) { + puVar4 = (undefined4 *)0x0; + } + else { + puVar4[1] = 1; + *puVar4 = &PTR_FUN_0079a778; + puVar4[2] = 0; + puVar4[3] = 0; + puVar4[4] = 0; + } + *(undefined4 **)(param_1 + 0x40) = puVar4; + } + iVar1 = *(int *)(param_1 + 0x40); + uVar2 = *(undefined4 *)(iVar1 + 0x10); + uVar5 = *(uint *)(iVar1 + 0xc) & 0x7fffffff; + if (uVar5 <= *(uint *)(iVar1 + 0x10)) { + uVar6 = FUN_00453850(uVar5 + 1); + cVar3 = FUN_004180a0(uVar6); + if (cVar3 == '\0') { + return uVar2; + } + } + *(undefined4 *)(*(int *)(iVar1 + 8) + *(int *)(iVar1 + 0x10) * 4) = param_2; + *(int *)(iVar1 + 0x10) = *(int *)(iVar1 + 0x10) + 1; + return uVar2; +} + + + +// --- FUN_00445ea0 at 0x00445EA0 (size: 524) --- + +undefined4 __thiscall FUN_00445ea0(int param_1,undefined4 *param_2) + +{ + char cVar1; + int *piVar2; + int iVar3; + LONG LVar4; + undefined4 *puVar5; + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined4 extraout_ECX_01; + undefined4 *puVar6; + undefined4 uVar7; + + if (param_2 == (undefined4 *)0x0) { + return 0; + } + FUN_0065cf90(param_2); + piVar2 = (int *)FUN_0065c810(); + do { + if (piVar2 == (int *)0x0) { + FUN_0065cae0(); + return 1; + } + cVar1 = FUN_0065cc50(&DAT_00839758); + puVar5 = (undefined4 *)PTR_DAT_00818344; + if (cVar1 == '\0') { + cVar1 = FUN_0065cc50(&DAT_0083975c); + if (cVar1 == '\0') { + cVar1 = FUN_0065cc50(&DAT_008397a8); + if ((((cVar1 != '\0') || (cVar1 = FUN_0065cc50(&DAT_00839130), cVar1 != '\0')) || + (cVar1 = FUN_0065cc50(&DAT_0083912c), cVar1 != '\0')) || + (cVar1 = FUN_0065cc50(&DAT_008397c0), cVar1 != '\0')) goto LAB_00446074; + uVar7 = extraout_ECX_01; + FUN_00401340("Unrecognized keyword in mesh file"); + FUN_0065d670(piVar2,uVar7); + } + else { + iVar3 = FUN_005df0f5(0x20); + if (iVar3 == 0) { + puVar5 = (undefined4 *)0x0; + } + else { + puVar5 = (undefined4 *)FUN_0044df50(); + } + param_2 = puVar5; + cVar1 = FUN_0044e610(piVar2,param_1); + if (cVar1 == '\0') { + uVar7 = extraout_ECX_00; + FUN_00401340("Error parsing mesh fragment"); + FUN_0065d620(piVar2,uVar7); + if (puVar5 != (undefined4 *)0x0) { + piVar2 = puVar5 + 1; + *piVar2 = *piVar2 + -1; + if (*piVar2 == 0) { + (**(code **)*puVar5)(1); + } + } +LAB_00446074: + FUN_0065cae0(); + return 0; + } + FUN_004637a0(¶m_2); + } + } + else { + param_2 = (undefined4 *)PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + iVar3 = (**(code **)(*piVar2 + 0xc))(0); + if (iVar3 != 0) { + FUN_00426020(¶m_2); + puVar5 = param_2; + } + iVar3 = param_1 + 0x34; + puVar6 = puVar5; + InterlockedIncrement(puVar5 + -4); + cVar1 = FUN_0041b8f0(8,puVar6,iVar3); + if (cVar1 == '\0') { + uVar7 = extraout_ECX; + FUN_00401340("Invalid mesh appearance type name"); + FUN_0065d620(piVar2,uVar7); + LVar4 = InterlockedDecrement(puVar5 + -4); + if ((LVar4 == 0) && (puVar5 + -5 != (undefined4 *)0x0)) { + (**(code **)puVar5[-5])(1); + } + goto LAB_00446074; + } + LVar4 = InterlockedDecrement(puVar5 + -4); + if ((LVar4 == 0) && (puVar5 + -5 != (undefined4 *)0x0)) { + (**(code **)puVar5[-5])(1); + } + } + piVar2 = (int *)FUN_0065cb10(); + } while( true ); +} + + + +// --- FUN_004460c0 at 0x004460C0 (size: 190) --- + +void __fastcall FUN_004460c0(int param_1) + +{ + int iVar1; + char cVar2; + uint uVar3; + undefined4 uVar4; + uint uVar5; + + FUN_0044dcb0(); + FUN_0044dcb0(); + uVar5 = 0; + *(undefined4 *)(param_1 + 0x68) = 0xffffffff; + if (*(int *)(param_1 + 0x4c) != 0) { + do { + iVar1 = *(int *)(*(int *)(*(int *)(param_1 + 0x44) + uVar5 * 4) + 8); + if (iVar1 == 1) { + uVar3 = *(uint *)(param_1 + 0x54) & 0x7fffffff; + if (uVar3 <= *(uint *)(param_1 + 0x58)) { + uVar4 = FUN_00453850(uVar3 + 1); + cVar2 = FUN_004180a0(uVar4); + if (cVar2 == '\0') goto LAB_0044616d; + } + *(uint *)(*(int *)(param_1 + 0x50) + *(int *)(param_1 + 0x58) * 4) = uVar5; + *(int *)(param_1 + 0x58) = *(int *)(param_1 + 0x58) + 1; + } + else if (iVar1 == 2) { + uVar3 = *(uint *)(param_1 + 0x60) & 0x7fffffff; + if (uVar3 <= *(uint *)(param_1 + 100)) { + uVar4 = FUN_00453850(uVar3 + 1); + cVar2 = FUN_004180a0(uVar4); + if (cVar2 == '\0') goto LAB_0044616d; + } + *(uint *)(*(int *)(param_1 + 0x5c) + *(int *)(param_1 + 100) * 4) = uVar5; + *(int *)(param_1 + 100) = *(int *)(param_1 + 100) + 1; + } + else if (iVar1 == 4) { + *(uint *)(param_1 + 0x68) = uVar5; + } +LAB_0044616d: + uVar5 = uVar5 + 1; + } while (uVar5 < *(uint *)(param_1 + 0x4c)); + } + return; +} + + + +// --- FUN_00446180 at 0x00446180 (size: 125) --- + +undefined4 __thiscall FUN_00446180(int param_1,uint param_2,undefined4 param_3) + +{ + int iVar1; + int local_4; + + local_4 = param_1; + if (*(uint *)(param_1 + 0x58) <= param_2) { + if (param_2 != *(uint *)(param_1 + 0x58)) { + return 0; + } + iVar1 = FUN_005df0f5(0x20); + if (iVar1 == 0) { + param_2 = 0; + } + else { + param_2 = FUN_0044df50(); + } + *(undefined4 *)(param_2 + 8) = 1; + local_4 = *(int *)(param_1 + 0x4c); + FUN_004637a0(&local_4); + FUN_004637a0(¶m_2); + } + FUN_0044e5d0(param_3); + return 1; +} + + + +// --- FUN_00446200 at 0x00446200 (size: 900) --- + +void __fastcall FUN_00446200(int param_1) + +{ + char cVar1; + char cVar2; + int iVar3; + int iVar4; + bool bVar5; + int *piVar6; + LONG LVar7; + undefined4 *puVar8; + int iVar9; + undefined *local_24; + undefined *local_20; + undefined *puStack_1c; + int local_18; + uint local_14; + uint local_10; + int local_c; + int iStack_8; + int local_4; + + bVar5 = false; + *(undefined1 *)(param_1 + 0x6c) = 0; + *(undefined1 *)(param_1 + 0x6d) = 0; + *(undefined1 *)(param_1 + 0x6f) = 0; + *(undefined1 *)(param_1 + 0x70) = 0; + *(undefined1 *)(param_1 + 0x6e) = 1; + local_10 = 0; + if (*(int *)(param_1 + 0x58) != 0) { + do { + iVar9 = *(int *)(*(int *)(param_1 + 0x44) + + *(int *)(*(int *)(param_1 + 0x50) + local_10 * 4) * 4); + local_14 = 0; + local_4 = iVar9; + if (*(int *)(iVar9 + 0x14) != 0) { + do { + iVar3 = *(int *)(*(int *)(iVar9 + 0xc) + local_14 * 4); + iVar4 = *(int *)(iVar3 + 0x10); + if ((iVar4 != -1) && + (iVar3 = *(int *)(*(int *)(*(int *)(*(int *)(iVar3 + 0xc) + 0x38) + 8) + 4 + iVar4 * 8) + , iVar3 != 0)) { + local_18 = *(int *)(iVar3 + 0x50); + cVar1 = *(char *)(local_18 + 0x9d); + cVar2 = *(char *)(local_18 + 0x9e); + if (bVar5) { + if (*(char *)(param_1 + 0x6d) != cVar2) { + local_24 = PTR_DAT_008183b4; + InterlockedIncrement((LONG *)(PTR_DAT_008183b4 + -0x10)); + if (*(int *)(local_24 + -4) == 1) { + piVar6 = (int *)FUN_00679240(&local_c,*(undefined4 *)(param_1 + 0x28)); + if (local_24 != (undefined *)*piVar6) { + puVar8 = (undefined4 *)(local_24 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(local_24 + -0x10)); + if ((LVar7 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + local_24 = (undefined *)*piVar6; + InterlockedIncrement((LONG *)(local_24 + -0x10)); + } + puVar8 = (undefined4 *)(local_c + -0x14); + LVar7 = InterlockedDecrement((LONG *)(local_c + -0x10)); + if ((LVar7 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + if (*(int *)(local_24 + -4) == 1) { + if (*(int *)(param_1 + 0x28) == DAT_00839058) { + FUN_00405000("Unknown"); + } + else { + FUN_00402710(&local_24,"DataID:0x%08X",*(int *)(param_1 + 0x28)); + } + } + } + local_20 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00402710(&local_20, + "Mesh [%s] is assigned to materials that contradict each other! At least one of the materials is designed for multi-pass lighting, but another material only works with vertex lighting. This is not allowed!" + ,PTR_DAT_008183b4); + puVar8 = (undefined4 *)(local_20 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(local_20 + -0x10)); + if ((LVar7 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + puVar8 = (undefined4 *)(local_24 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(local_24 + -0x10)); + if ((LVar7 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + } + if (((*(char *)(param_1 + 0x6d) != '\0') || (cVar2 != '\0')) && + (*(char *)(param_1 + 0x6c) != cVar1)) { + local_24 = PTR_DAT_008183b4; + InterlockedIncrement((LONG *)(PTR_DAT_008183b4 + -0x10)); + if (*(int *)(local_24 + -4) == 1) { + piVar6 = (int *)FUN_00679240(&iStack_8,*(undefined4 *)(param_1 + 0x28)); + if (local_24 != (undefined *)*piVar6) { + puVar8 = (undefined4 *)(local_24 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(local_24 + -0x10)); + if ((LVar7 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + local_24 = (undefined *)*piVar6; + InterlockedIncrement((LONG *)(local_24 + -0x10)); + } + puVar8 = (undefined4 *)(iStack_8 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(iStack_8 + -0x10)); + if ((LVar7 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + if (*(int *)(local_24 + -4) == 1) { + if (*(int *)(param_1 + 0x28) == DAT_00839058) { + FUN_00405000("Unknown"); + } + else { + FUN_00402710(&local_24,"DataID:0x%08X",*(int *)(param_1 + 0x28)); + } + } + } + puStack_1c = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00402710(&puStack_1c, + "All materials used within a mesh must be either LIT or UNLIT materials, but not BOTH. Mesh [%s] is breaking this rule! Also keep in mind that all meshes within an object must be either LIT or UNLIT, but not BOTH. Note that this limitation does not apply to \'SIMPLE LIT\' materials -- those can be freely mixed with UNLIT materials within a mesh or entity." + ,local_24); + puVar8 = (undefined4 *)(puStack_1c + -0x14); + LVar7 = InterlockedDecrement((LONG *)(puStack_1c + -0x10)); + if ((LVar7 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + puVar8 = (undefined4 *)(local_24 + -0x14); + LVar7 = InterlockedDecrement((LONG *)(local_24 + -0x10)); + if ((LVar7 == 0) && (puVar8 != (undefined4 *)0x0)) { + (**(code **)*puVar8)(1); + } + } + } + if (cVar1 != '\0') { + *(undefined1 *)(param_1 + 0x6c) = 1; + } + if ((cVar2 != '\0') && + (*(undefined1 *)(param_1 + 0x6d) = 1, *(char *)(local_18 + 0x9f) == '\0')) { + *(undefined1 *)(param_1 + 0x6e) = 0; + } + if (*(char *)(local_18 + 0xa0) != '\0') { + *(undefined1 *)(param_1 + 0x6f) = 1; + } + if (*(char *)(local_18 + 0xa1) != '\0') { + *(undefined1 *)(param_1 + 0x70) = 1; + } + bVar5 = true; + iVar9 = local_4; + } + local_14 = local_14 + 1; + } while (local_14 < *(uint *)(iVar9 + 0x14)); + } + local_10 = local_10 + 1; + } while (local_10 < *(uint *)(param_1 + 0x58)); + } + return; +} + + + +// --- FUN_00446590 at 0x00446590 (size: 23) --- + +void FUN_00446590(void) + +{ + FUN_00446200(); + FUN_00444b00(); + FUN_00444b80(); + return; +} + + + +// --- FUN_004465b0 at 0x004465B0 (size: 34) --- + +undefined1 FUN_004465b0(void) + +{ + char cVar1; + + cVar1 = FUN_00444a30(); + if (cVar1 == '\0') { + return 0; + } + cVar1 = FUN_00413a70(); + if (cVar1 != '\0') { + FUN_00446200(); + } + return 1; +} + + + +// --- FUN_004465e0 at 0x004465E0 (size: 28) --- + +undefined1 FUN_004465e0(void) + +{ + FUN_00446200(); + FUN_00444b00(); + FUN_00444b80(); + return 1; +} + + + +// --- FUN_00446600 at 0x00446600 (size: 150) --- + +undefined4 __thiscall +FUN_00446600(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4, + undefined4 param_5,undefined4 param_6,undefined4 param_7,undefined4 param_8, + undefined4 param_9,undefined4 param_10) + +{ + char cVar1; + int iVar2; + undefined4 *puVar3; + + iVar2 = FUN_005df0f5(0x34); + if (iVar2 == 0) { + puVar3 = (undefined4 *)0x0; + } + else { + puVar3 = (undefined4 *)FUN_0044f2c0(); + } + puVar3[3] = param_1; + cVar1 = FUN_0044f330(param_3,param_4,param_5,param_6,param_7,param_8,param_9,param_10); + if (cVar1 == '\0') { + iVar2 = puVar3[1]; + } + else { + cVar1 = FUN_00446180(param_2,puVar3); + iVar2 = puVar3[1]; + if (cVar1 != '\0') { + puVar3[1] = iVar2 + -1; + if (iVar2 + -1 == 0) { + (**(code **)*puVar3)(1); + } + return 1; + } + } + puVar3[1] = iVar2 + -1; + if (iVar2 + -1 == 0) { + (**(code **)*puVar3)(1); + } + return 0; +} + + + +// --- FUN_004466a0 at 0x004466A0 (size: 44) --- + +void __fastcall FUN_004466a0(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_0079aa94; + if ((param_1[0xe] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0xd]); + } + FUN_0040b060(); + return; +} + + + +// --- FUN_00446770 at 0x00446770 (size: 105) --- + +void __thiscall FUN_00446770(int param_1,undefined4 param_2) + +{ + undefined1 *local_4c; + uint local_48; + undefined4 local_44; + undefined1 local_40 [64]; + + local_4c = local_40; + local_48 = 8; + local_44 = 0; + FUN_00410a00(&local_4c); + if ((local_48 & 0x80000000) == 0x80000000) { + operator_delete__(local_4c); + } + FUN_0040b020(param_1 + 0x24,param_2); + return; +} + + + +// --- FUN_00446890 at 0x00446890 (size: 67) --- + +undefined4 __fastcall FUN_00446890(int param_1) + +{ + char cVar1; + + FUN_004460c0(); + if (*(int *)(param_1 + 0x58) != 0) { + FUN_00444d90(); + FUN_00446200(); + FUN_00444b00(); + FUN_00444b80(); + cVar1 = FUN_00413a70(); + if (cVar1 == '\0') { + FUN_00444d50(); + } + return 1; + } + return 0; +} + + + +// --- FUN_004468e0 at 0x004468E0 (size: 97) --- + +undefined4 * __thiscall FUN_004468e0(undefined4 *param_1,undefined4 param_2,undefined4 param_3) + +{ + *param_1 = &PTR_FUN_00793b3c; + param_1[1] = 0; + param_1[2] = 0; + FUN_00406d60(); + param_1[6] = 0; + param_1[7] = 0; + param_1[8] = 0; + *param_1 = &PTR_LAB_0079aa94; + param_1[9] = &PTR_LAB_0079aa90; + param_1[0xc] = &PTR_LAB_00795430; + param_1[0xd] = param_1 + 0x10; + param_1[0xe] = 8; + param_1[0xf] = 0; + *(undefined1 *)(param_1 + 0x20) = 1; + FUN_00446770(param_3); + return param_1; +} + + + +// --- FUN_00446950 at 0x00446950 (size: 268) --- + +uint __thiscall FUN_00446950(int *param_1,undefined4 param_2) + +{ + char cVar1; + int iVar2; + uint uVar3; + undefined4 uVar4; + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined1 local_90 [8]; + undefined **ppuStack_88; + uint local_84 [12]; + void *pvStack_54; + uint uStack_50; + + iVar2 = FUN_0065ca90(); + if (iVar2 == 0) { + uVar4 = extraout_ECX; + FUN_00401340("Expected binary mesh data, got nothing!"); + uVar3 = FUN_0065d620(param_2,uVar4); + return uVar3 & 0xffffff00; + } + FUN_00406d60(); + cVar1 = FUN_00444f00(local_90); + if (cVar1 == '\0') { + uVar4 = extraout_ECX_00; + FUN_00401340("Failed retrieving binary mesh data"); + FUN_0065d620(param_2,uVar4); + uVar3 = FUN_00406f90(); + return uVar3 & 0xffffff00; + } + FUN_004468e0(0,local_90); + FUN_0040aa10(1); + (**(code **)(*param_1 + 0x1c))(local_84); + FUN_0065e850(); + ppuStack_88 = &PTR_LAB_0079aa94; + if ((uStack_50 & 0x80000000) == 0x80000000) { + operator_delete__(pvStack_54); + } + FUN_0040b060(); + uVar4 = FUN_00406f90(); + return CONCAT31((int3)((uint)uVar4 >> 8),~(byte)(local_84[0] >> 2)) & 0xffffff01; +} + + + +// --- FUN_00446b90 at 0x00446B90 (size: 51) --- + +undefined4 __thiscall FUN_00446b90(int param_1,int param_2) + +{ + *(undefined1 *)(param_2 + 8) = *(undefined1 *)(param_1 + 8); + *(undefined1 *)(param_2 + 0x1c) = *(undefined1 *)(param_1 + 0x1c); + *(undefined1 *)(param_2 + 0x1d) = *(undefined1 *)(param_1 + 0x1d); + *(undefined4 *)(param_2 + 0x20) = *(undefined4 *)(param_1 + 0x20); + *(undefined4 *)(param_2 + 0x10) = *(undefined4 *)(param_1 + 0x10); + *(undefined4 *)(param_2 + 0x14) = *(undefined4 *)(param_1 + 0x14); + *(undefined4 *)(param_2 + 0x18) = *(undefined4 *)(param_1 + 0x18); + return 1; +} + + + +// --- FUN_00446bd0 at 0x00446BD0 (size: 10) --- + +void __thiscall FUN_00446bd0(int param_1,undefined4 param_2) + +{ + *(undefined4 *)(param_1 + 0x20) = param_2; + return; +} + + + +// --- FUN_00446be0 at 0x00446BE0 (size: 10) --- + +void __thiscall FUN_00446be0(int param_1,undefined1 param_2) + +{ + *(undefined1 *)(param_1 + 0x1c) = param_2; + return; +} + + + +// --- FUN_00446bf0 at 0x00446BF0 (size: 10) --- + +void __thiscall FUN_00446bf0(int param_1,undefined1 param_2) + +{ + *(undefined1 *)(param_1 + 0x1d) = param_2; + return; +} + + + +// --- FUN_00446c00 at 0x00446C00 (size: 5) --- + +void __fastcall FUN_00446c00(int param_1) + +{ + *(undefined1 *)(param_1 + 8) = 0; + return; +} + + + +// --- FUN_00446c10 at 0x00446C10 (size: 5) --- + +void __fastcall FUN_00446c10(int param_1) + +{ + *(undefined1 *)(param_1 + 8) = 1; + return; +} + + + +// --- FUN_00446c20 at 0x00446C20 (size: 9) --- + +bool __fastcall FUN_00446c20(int param_1) + +{ + return *(char *)(param_1 + 8) != '\0'; +} + + + +// --- FUN_00446c30 at 0x00446C30 (size: 52) --- + +uint __thiscall FUN_00446c30(uint *param_1,uint param_2) + +{ + uint uVar1; + + uVar1 = param_1[2]; + if (param_2 < uVar1) { + uVar1 = uVar1 - 1; + param_1[2] = uVar1; + if (param_2 != uVar1) { + *(undefined4 *)(*param_1 + param_2 * 4) = *(undefined4 *)(*param_1 + uVar1 * 4); + uVar1 = *param_1; + *(undefined4 *)(uVar1 + param_1[2] * 4) = 0; + } + return CONCAT31((int3)(uVar1 >> 8),1); + } + return uVar1 & 0xffffff00; +} + + + +// --- FUN_00446c70 at 0x00446C70 (size: 93) --- + +void FUN_00446c70(int param_1,int param_2,int param_3,int param_4) + +{ + int iVar1; + int iVar2; + + if (param_2 <= param_3) { + *(int *)(param_1 + param_2 * 4) = param_4; + return; + } + do { + iVar2 = (param_2 + -1) / 2; + iVar1 = *(int *)(param_1 + iVar2 * 4); + if (*(double *)(param_4 + 0x10) <= *(double *)(iVar1 + 0x10)) break; + *(int *)(param_1 + param_2 * 4) = iVar1; + param_2 = iVar2; + } while (param_3 < iVar2); + *(int *)(param_1 + param_2 * 4) = param_4; + return; +} + + + +// --- FUN_00446cd0 at 0x00446CD0 (size: 81) --- + +void FUN_00446cd0(int param_1) + +{ + uint uVar1; + int iVar2; + uint uVar3; + + uVar1 = *(uint *)(param_1 + 0x24); + if (((uVar1 != 0xffffffff) && (DAT_008398cc != 0)) && (uVar1 < DAT_008398cc)) { + uVar3 = DAT_008398cc - 1; + if (uVar1 < uVar3) { + iVar2 = *(int *)(DAT_008398c4 + uVar3 * 4); + *(int *)(DAT_008398c4 + uVar1 * 4) = iVar2; + *(uint *)(iVar2 + 0x24) = uVar1; + } + *(undefined4 *)(param_1 + 0x24) = 0xffffffff; + *(undefined4 *)(DAT_008398c4 + uVar3 * 4) = 0; + FUN_00446c30(uVar3); + } + return; +} + + + +// --- FUN_00446d30 at 0x00446D30 (size: 68) --- + +undefined4 FUN_00446d30(void) + +{ + int *piVar1; + char cVar2; + uint uVar3; + + uVar3 = 0; + if (DAT_008398cc != 0) { + do { + piVar1 = *(int **)(DAT_008398c4 + uVar3 * 4); + if (((piVar1 != (int *)0x0) && ((char)piVar1[2] == '\0')) && + (cVar2 = (**(code **)(*piVar1 + 8))(), cVar2 != '\0')) { + *(undefined1 *)(piVar1 + 2) = 1; + uVar3 = 0xffffffff; + } + uVar3 = uVar3 + 1; + } while (uVar3 < DAT_008398cc); + } + return 1; +} + + + +// --- FUN_00446d80 at 0x00446D80 (size: 64) --- + +undefined4 FUN_00446d80(void) + +{ + int *piVar1; + char cVar2; + uint uVar3; + + uVar3 = 0; + if (DAT_008398cc != 0) { + do { + piVar1 = *(int **)(DAT_008398c4 + uVar3 * 4); + if ((((char)piVar1[2] != '\0') && (*(char *)((int)piVar1 + 0x1d) != '\0')) && + (cVar2 = (**(code **)(*piVar1 + 0xc))(), cVar2 != '\0')) { + uVar3 = 0xffffffff; + } + uVar3 = uVar3 + 1; + } while (uVar3 < DAT_008398cc); + } + return 1; +} + + + +// --- FUN_00446dc0 at 0x00446DC0 (size: 134) --- + +void FUN_00446dc0(double param_1) + +{ + int *piVar1; + undefined4 uVar2; + undefined4 uVar3; + char cVar4; + uint uVar5; + + uVar3 = DAT_008379b4; + uVar2 = DAT_008379b0; + uVar5 = 0; + if (DAT_008398cc != 0) { + do { + piVar1 = *(int **)(DAT_008398c4 + uVar5 * 4); + if (((((char)piVar1[2] == '\0') && ((char)piVar1[7] != '\0')) && + (piVar1[6] != *(int *)(DAT_00870340 + 0xb0))) && + (((piVar1[8] != 0 && (param_1 < (double)CONCAT44(uVar3,uVar2) - *(double *)(piVar1 + 4))) + && (cVar4 = (**(code **)(*piVar1 + 8))(), cVar4 != '\0')))) { + *(undefined1 *)(piVar1 + 2) = 1; + uVar5 = 0xffffffff; + } + uVar5 = uVar5 + 1; + } while (uVar5 < DAT_008398cc); + } + return; +} + + + +// --- FUN_00446e50 at 0x00446E50 (size: 64) --- + +void FUN_00446e50(int *param_1,int *param_2) + +{ + int iVar1; + int iVar2; + int *piVar3; + + for (; param_1 != param_2; param_1 = param_1 + 1) { + iVar1 = *param_1; + piVar3 = param_1; + while( true ) { + iVar2 = piVar3[-1]; + if (*(double *)(iVar2 + 0x10) <= *(double *)(iVar1 + 0x10)) break; + *piVar3 = iVar2; + piVar3 = piVar3 + -1; + } + *piVar3 = iVar1; + } + return; +} + + + +// --- FUN_00446e90 at 0x00446E90 (size: 108) --- + +void FUN_00446e90(int param_1,int param_2,int param_3,undefined4 param_4,undefined4 param_5) + +{ + int iVar1; + int iVar2; + int iVar3; + + iVar3 = param_2; + while( true ) { + iVar1 = iVar3 * 2; + iVar2 = iVar1 + 2; + if (param_3 <= iVar2) break; + if (*(double *)(*(int *)(param_1 + iVar2 * 4) + 0x10) < + *(double *)(*(int *)(param_1 + -4 + iVar2 * 4) + 0x10)) { + iVar2 = iVar1 + 1; + } + *(undefined4 *)(param_1 + iVar3 * 4) = *(undefined4 *)(param_1 + iVar2 * 4); + iVar3 = iVar2; + } + if (iVar2 == param_3) { + *(undefined4 *)(param_1 + iVar3 * 4) = *(undefined4 *)(param_1 + -4 + iVar2 * 4); + iVar3 = iVar1 + 1; + } + FUN_00446c70(param_1,iVar3,param_2,param_4,param_5); + return; +} + + + +// --- FUN_00446f00 at 0x00446F00 (size: 14) --- + +void __fastcall FUN_00446f00(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_0079bf64; + FUN_00446cd0(param_1); + return; +} + + + +// --- FUN_00446f10 at 0x00446F10 (size: 77) --- + +int * FUN_00446f10(int *param_1,int *param_2,int param_3) + +{ + int *piVar1; + int iVar2; + + while( true ) { + for (; *(double *)(*param_1 + 0x10) < *(double *)(param_3 + 0x10); param_1 = param_1 + 1) { + } + do { + piVar1 = param_2 + -1; + param_2 = param_2 + -1; + } while (*(double *)(param_3 + 0x10) < *(double *)(*piVar1 + 0x10)); + if (param_2 <= param_1) break; + iVar2 = *param_1; + *param_1 = *param_2; + *param_2 = iVar2; + param_1 = param_1 + 1; + } + return param_1; +} + + + +// --- FUN_00446f60 at 0x00446F60 (size: 83) --- + +void FUN_00446f60(int param_1,int param_2,undefined4 param_3) + +{ + int iVar1; + int iVar2; + int iVar3; + + iVar2 = param_2 - param_1 >> 2; + if (1 < iVar2) { + iVar3 = (iVar2 + -2) / 2; + FUN_00446e90(param_1,iVar3,iVar2,*(undefined4 *)(param_1 + iVar3 * 4),param_3); + while (iVar3 != 0) { + iVar1 = iVar3 * 4; + iVar3 = iVar3 + -1; + FUN_00446e90(param_1,iVar3,iVar2,*(undefined4 *)(param_1 + -4 + iVar1),param_3); + } + } + return; +} + + + +// --- FUN_00446fc0 at 0x00446FC0 (size: 41) --- + +undefined4 * __thiscall FUN_00446fc0(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079bf64; + FUN_00446cd0(param_1); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00446ff0 at 0x00446FF0 (size: 10) --- + +void FUN_00446ff0(void) + +{ + FUN_0044dcb0(); + return; +} + + + +// --- FUN_00447000 at 0x00447000 (size: 153) --- + +void FUN_00447000(int *param_1,int *param_2) + +{ + int iVar1; + int *piVar2; + int *piVar3; + int *piVar4; + size_t _Size; + int *piVar5; + + if ((param_1 != param_2) && (piVar5 = param_1 + 1, piVar5 != param_2)) { + _Size = (int)piVar5 - (int)param_1; + do { + iVar1 = *piVar5; + if (*(double *)(*param_1 + 0x10) <= *(double *)(iVar1 + 0x10)) { + piVar2 = (int *)((int)param_1 + (_Size - 4)); + piVar4 = piVar5; + while (piVar3 = piVar2, *(double *)(iVar1 + 0x10) < *(double *)(*piVar3 + 0x10)) { + *piVar4 = *piVar3; + piVar4 = piVar3; + piVar2 = piVar3 + -1; + } + *piVar4 = iVar1; + } + else { + if (0 < (int)_Size) { + memmove((void *)((int)piVar5 + (4 - _Size)),param_1,_Size); + } + *param_1 = iVar1; + } + piVar5 = piVar5 + 1; + _Size = _Size + 4; + } while (piVar5 != param_2); + } + return; +} + + + +// --- FUN_004470a0 at 0x004470A0 (size: 77) --- + +void FUN_004470a0(undefined4 *param_1,int param_2,undefined4 param_3) + +{ + undefined4 uVar1; + uint uVar2; + + uVar2 = param_2 - (int)param_1; + while (4 < (int)(uVar2 & 0xfffffffc)) { + uVar1 = *(undefined4 *)((int)param_1 + (uVar2 - 4)); + *(undefined4 *)((int)param_1 + (uVar2 - 4)) = *param_1; + FUN_00446e90(param_1,0,(int)(uVar2 - 4) >> 2,uVar1,param_3); + uVar2 = uVar2 - 4; + } + return; +} + + + +// --- FUN_004470f0 at 0x004470F0 (size: 89) --- + +void FUN_004470f0(int param_1) + +{ + uint uVar1; + char cVar2; + undefined4 uVar3; + + uVar1 = DAT_008398cc; + if ((DAT_008398c8 & 0x7fffffff) <= DAT_008398cc) { + uVar3 = FUN_00453850((DAT_008398c8 & 0x7fffffff) + 1); + cVar2 = FUN_004180a0(uVar3); + if (cVar2 == '\0') { + *(uint *)(param_1 + 0x24) = uVar1; + return; + } + } + *(int *)(DAT_008398c4 + DAT_008398cc * 4) = param_1; + DAT_008398cc = DAT_008398cc + 1; + *(uint *)(param_1 + 0x24) = uVar1; + return; +} + + + +// --- FUN_00447150 at 0x00447150 (size: 72) --- + +void FUN_00447150(int param_1,int param_2,undefined4 param_3) + +{ + if (0x40 < (int)(param_2 - param_1 & 0xfffffffcU)) { + FUN_00447000(param_1,param_1 + 0x40,param_3); + FUN_00446e50(param_1 + 0x40,param_2,0,param_3); + return; + } + FUN_00447000(param_1,param_2,param_3); + return; +} + + + +// --- FUN_004471a0 at 0x004471A0 (size: 116) --- + +void FUN_004471a0(int *param_1,int *param_2,int *param_3,undefined4 param_4,undefined4 param_5) + +{ + int iVar1; + int *piVar2; + + FUN_00446f60(param_1,param_2,param_5,0,0); + for (piVar2 = param_2; piVar2 < param_3; piVar2 = piVar2 + 1) { + iVar1 = *piVar2; + if (*(double *)(iVar1 + 0x10) < *(double *)(*param_1 + 0x10)) { + *piVar2 = *param_1; + FUN_00446e90(param_1,0,(int)param_2 - (int)param_1 >> 2,iVar1,param_5); + } + } + FUN_004470a0(param_1,param_2,param_5); + return; +} + + + +// --- FUN_00447220 at 0x00447220 (size: 88) --- + +undefined4 * __fastcall FUN_00447220(undefined4 *param_1) + +{ + undefined4 uVar1; + + param_1[4] = 0; + param_1[5] = 0; + *param_1 = &PTR_FUN_0079bf64; + *(undefined1 *)(param_1 + 2) = 0; + *(undefined1 *)(param_1 + 7) = 0; + *(undefined1 *)((int)param_1 + 0x1d) = 0; + param_1[8] = 0; + param_1[6] = 0xffffffff; + param_1[9] = 0xffffffff; + uVar1 = DAT_008379b4; + param_1[4] = DAT_008379b0; + param_1[5] = uVar1; + if (DAT_00870340 != 0) { + param_1[6] = *(undefined4 *)(DAT_00870340 + 0xb0); + } + FUN_004470f0(param_1); + return param_1; +} + + + +// --- FUN_00447280 at 0x00447280 (size: 244) --- + +void FUN_00447280(int *param_1,int param_2,undefined4 param_3,int param_4,undefined4 param_5) + +{ + int *piVar1; + int iVar2; + int iVar3; + int *piVar4; + int iVar5; + + if (0x40 < (int)(param_2 - (int)param_1 & 0xfffffffcU)) { + while (param_4 != 0) { + iVar5 = *param_1; + param_4 = param_4 + -1; + iVar3 = (param_2 - (int)param_1 >> 2) - (param_2 - (int)param_1 >> 0x1f) >> 1; + iVar2 = param_1[iVar3]; + piVar1 = (int *)(param_2 + -4); + piVar4 = param_1; + if (*(double *)(iVar2 + 0x10) <= *(double *)(iVar5 + 0x10)) { + if ((*(double *)(*piVar1 + 0x10) <= *(double *)(iVar5 + 0x10)) && + (piVar4 = piVar1, *(double *)(*piVar1 + 0x10) <= *(double *)(iVar2 + 0x10))) + goto LAB_0044731d; + } + else if (*(double *)(iVar2 + 0x10) < *(double *)(*piVar1 + 0x10)) { +LAB_0044731d: + piVar4 = param_1 + iVar3; + } + else if (*(double *)(iVar5 + 0x10) < *(double *)(*piVar1 + 0x10)) { + piVar4 = piVar1; + } + iVar5 = FUN_00446f10(param_1,param_2,*piVar4,param_5); + FUN_00447280(iVar5,param_2,0,param_4,param_5); + param_2 = iVar5; + if ((int)(iVar5 - (int)param_1 & 0xfffffffcU) < 0x41) { + return; + } + } + FUN_004471a0(param_1,param_2,param_2,0,param_5); + } + return; +} + + + +// --- FUN_00447380 at 0x00447380 (size: 74) --- + +void FUN_00447380(int param_1,int param_2,undefined4 param_3) + +{ + int iVar1; + int iVar2; + + if (param_1 != param_2) { + iVar2 = 0; + for (iVar1 = param_2 - param_1 >> 2; iVar1 != 1; iVar1 = iVar1 >> 1) { + iVar2 = iVar2 + 1; + } + FUN_00447280(param_1,param_2,0,iVar2 * 2,param_3); + FUN_00447150(param_1,param_2,param_3); + } + return; +} + + + +// --- FUN_004473d0 at 0x004473D0 (size: 187) --- + +undefined4 FUN_004473d0(uint param_1) + +{ + int *piVar1; + int iVar2; + char cVar3; + uint uVar4; + uint uVar5; + + FUN_00447380(DAT_008398c4,DAT_008398c4 + DAT_008398cc * 4,param_1); + uVar4 = 0; + if (DAT_008398cc != 0) { + do { + *(uint *)(*(int *)(DAT_008398c4 + uVar4 * 4) + 0x24) = uVar4; + uVar4 = uVar4 + 1; + } while (uVar4 < DAT_008398cc); + } + uVar4 = 0; + uVar5 = 0; + if (DAT_008398cc != 0) { + do { + piVar1 = *(int **)(DAT_008398c4 + uVar5 * 4); + if (((((char)piVar1[7] != '\0') && ((char)piVar1[2] == '\0')) && + (iVar2 = piVar1[8], iVar2 != 0)) && + ((piVar1[6] != *(int *)(DAT_00870340 + 0xb0) && + (cVar3 = (**(code **)(*piVar1 + 8))(), cVar3 != '\0')))) { + uVar4 = uVar4 + iVar2; + *(undefined1 *)(piVar1 + 2) = 1; + if (param_1 <= uVar4) { + return 1; + } + uVar5 = 0xffffffff; + } + uVar5 = uVar5 + 1; + } while (uVar5 < DAT_008398cc); + } + if (param_1 <= uVar4) { + return 1; + } + return 0; +} + + + +// --- FUN_00447490 at 0x00447490 (size: 80) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __fastcall FUN_00447490(float *param_1) + +{ + if (_DAT_007938b0 < param_1[3]) { + param_1[3] = 1.0; + } + if (_DAT_007938b0 < *param_1) { + *param_1 = 1.0; + } + if (_DAT_007938b0 < param_1[1]) { + param_1[1] = 1.0; + } + if (_DAT_007938b0 < param_1[2]) { + param_1[2] = 1.0; + } + return; +} + + + +// --- FUN_004474e0 at 0x004474E0 (size: 58) --- + +void __fastcall FUN_004474e0(int param_1) + +{ + int iVar1; + undefined4 *puVar2; + undefined4 *puVar3; + + *(undefined1 *)(param_1 + 0xb0) = 0; + *(undefined4 *)(param_1 + 0x128) = 0; + *(undefined1 *)(param_1 + 300) = 0; + *(undefined1 *)(param_1 + 0x12d) = 1; + puVar2 = &DAT_008ef180; + puVar3 = (undefined4 *)(param_1 + 0x130); + for (iVar1 = 6; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + *(undefined1 *)(param_1 + 0x148) = 0; + return; +} + + + +// --- FUN_00447520 at 0x00447520 (size: 34) --- + +void __fastcall FUN_00447520(int param_1) + +{ + if (*(void **)(param_1 + 0x128) != (void *)0x0) { + operator_delete__(*(void **)(param_1 + 0x128)); + *(undefined4 *)(param_1 + 0x128) = 0; + } + return; +} + + + +// --- FUN_00447550 at 0x00447550 (size: 193) --- + +undefined4 __thiscall +FUN_00447550(int param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4,undefined4 param_5 + ,uint param_6) + +{ + uint *puVar1; + char cVar2; + uint uVar3; + int iVar4; + undefined4 *puVar5; + undefined4 *puVar6; + + cVar2 = FUN_005d83c0(param_2,param_3,param_4,param_5,param_6); + if (cVar2 == '\0') { + return 0; + } + *(bool *)(param_1 + 0xb0) = (char)param_4 == '\0'; + uVar3 = *(uint *)(param_1 + 8) & 0x52; + puVar1 = (uint *)(param_1 + 0xb4); + *puVar1 = uVar3; + if (*(char *)(param_1 + 0x86) == '\0') { + *puVar1 = *(uint *)(param_1 + 8) & 0xf52; + } + else if (*(int *)(param_1 + 0x1c) != 0) { + *puVar1 = uVar3 | 0x100; + } + *puVar1 = *puVar1 & param_6; + FUN_005d97f0(); + if (*(char *)(param_1 + 0xb0) != '\0') { + iVar4 = thunk_FUN_005df0f5(*(int *)(param_1 + 0xb8) * *(int *)(param_1 + 0x7c)); + *(int *)(param_1 + 0x128) = iVar4; + if (iVar4 == 0) { + return 0; + } + } + puVar5 = &DAT_008ef180; + puVar6 = (undefined4 *)(param_1 + 0x130); + for (iVar4 = 6; iVar4 != 0; iVar4 = iVar4 + -1) { + *puVar6 = *puVar5; + puVar5 = puVar5 + 1; + puVar6 = puVar6 + 1; + } + *(undefined1 *)(param_1 + 0x148) = 0; + return 1; +} + + + +// --- FUN_00447620 at 0x00447620 (size: 94) --- + +void __fastcall FUN_00447620(int param_1) + +{ + int iVar1; + undefined4 *puVar2; + undefined4 *puVar3; + + if (*(void **)(param_1 + 0x128) != (void *)0x0) { + operator_delete__(*(void **)(param_1 + 0x128)); + *(undefined4 *)(param_1 + 0x128) = 0; + } + FUN_005d86d0(); + *(undefined1 *)(param_1 + 0xb0) = 0; + *(undefined4 *)(param_1 + 0x128) = 0; + *(undefined1 *)(param_1 + 300) = 0; + *(undefined1 *)(param_1 + 0x12d) = 1; + puVar2 = &DAT_008ef180; + puVar3 = (undefined4 *)(param_1 + 0x130); + for (iVar1 = 6; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + *(undefined1 *)(param_1 + 0x148) = 0; + return; +} + + + +// --- FUN_004476d0 at 0x004476D0 (size: 962) --- + +void FUN_004476d0(undefined4 *param_1,uint *param_2,undefined4 *param_3,uint *param_4,int param_5, + char param_6) + +{ + undefined4 uVar1; + undefined4 uVar2; + bool bVar3; + bool bVar4; + bool bVar5; + bool bVar6; + bool bVar7; + bool bVar8; + uint uVar9; + uint uVar10; + int iVar11; + undefined4 *puVar12; + uint *puVar13; + uint uVar14; + uint uVar15; + undefined4 *puVar16; + uint local_14; + uint local_10; + int local_8; + + uVar10 = *param_2; + uVar9 = *param_4; + if ((uVar10 == uVar9) && (param_6 == '\0')) { + uVar10 = param_4[1]; + for (uVar9 = uVar10 * param_5 >> 2; uVar9 != 0; uVar9 = uVar9 - 1) { + *param_3 = *param_1; + param_1 = param_1 + 1; + param_3 = param_3 + 1; + } + for (uVar10 = uVar10 * param_5 & 3; uVar10 != 0; uVar10 = uVar10 - 1) { + *(undefined1 *)param_3 = *(undefined1 *)param_1; + param_1 = (undefined4 *)((int)param_1 + 1); + param_3 = (undefined4 *)((int)param_3 + 1); + } + return; + } + uVar14 = param_4[5]; + if (param_2[5] < param_4[5]) { + uVar14 = param_2[5]; + } + uVar15 = param_4[4]; + if (param_2[4] < param_4[4]) { + uVar15 = param_2[4]; + } + if (((uVar9 & 0x10) == 0) || (bVar3 = true, (uVar10 & 0x10) == 0)) { + bVar3 = false; + } + if (((uVar9 & 0x20) == 0) || (bVar4 = true, (uVar10 & 0x20) == 0)) { + bVar4 = false; + } + if (((uVar9 & 0x40) == 0) || (bVar5 = true, (uVar10 & 0x40) == 0)) { + bVar5 = false; + } + if ((-1 < (char)uVar9) || (bVar6 = true, -1 < (char)uVar10)) { + bVar6 = false; + } + if (((uVar9 & 0x10000000) == 0) || (bVar7 = true, (uVar10 & 0x10000000) == 0)) { + bVar7 = false; + } + if (((uVar9 & 0x20000000) == 0) || (bVar8 = true, (uVar10 & 0x20000000) == 0)) { + bVar8 = false; + } + if (param_5 != 0) { + local_8 = param_5; + do { + if (param_6 == '\0') { + *param_3 = *param_1; + param_3[1] = param_1[1]; + param_3[2] = param_1[2]; + } + else { + *param_3 = *param_1; + uVar1 = param_1[1]; + param_3[1] = uVar1; + uVar2 = param_1[2]; + param_3[2] = uVar1; + param_3[1] = uVar2; + } + if (uVar15 != 0) { + local_14 = 0; + uVar10 = 0; + if (3 < (int)uVar15) { + local_10 = 3; + iVar11 = 8; + do { + *(undefined4 *)(param_4[8] + iVar11 + -8 + (int)param_3) = + *(undefined4 *)((int)param_1 + param_2[8] + iVar11 + -8); + *(undefined4 *)((int)param_3 + param_4[8] + iVar11 + -4) = + *(undefined4 *)((int)param_1 + param_2[8] + iVar11 + -4); + *(undefined4 *)((int)param_3 + param_4[8] + iVar11) = + *(undefined4 *)((int)param_1 + param_2[8] + iVar11); + *(undefined4 *)((int)param_3 + param_4[8] + iVar11 + 4) = + *(undefined4 *)((int)param_1 + param_2[8] + iVar11 + 4); + local_10 = local_10 + 4; + local_14 = local_14 + 4; + iVar11 = iVar11 + 0x10; + uVar10 = local_14; + } while (local_10 < uVar15); + } + for (; uVar10 < uVar15; uVar10 = uVar10 + 1) { + *(undefined4 *)(param_4[8] + uVar10 * 4 + (int)param_3) = + *(undefined4 *)((int)param_1 + param_2[8] + uVar10 * 4); + } + } + if (bVar3) { + if (param_6 == '\0') { + puVar12 = (undefined4 *)(param_2[0xd] + (int)param_1); + puVar16 = (undefined4 *)(param_4[0xd] + (int)param_3); + *puVar16 = *puVar12; + puVar16[1] = puVar12[1]; + puVar16[2] = puVar12[2]; + } + else { + uVar10 = param_2[0xd]; + puVar12 = (undefined4 *)(param_4[0xd] + (int)param_3); + *puVar12 = *(undefined4 *)(uVar10 + (int)param_1); + uVar1 = *(undefined4 *)((int)param_1 + uVar10 + 4); + puVar12[1] = uVar1; + uVar2 = *(undefined4 *)((int)param_1 + uVar10 + 8); + puVar12[2] = uVar1; + puVar12[1] = uVar2; + } + } + if (bVar4) { + *(undefined4 *)((int)param_3 + param_4[0xe]) = *(undefined4 *)((int)param_1 + param_2[0xe]); + } + if (bVar5) { + *(undefined4 *)((int)param_3 + param_4[0xf]) = *(undefined4 *)((int)param_1 + param_2[0xf]); + } + if (bVar6) { + *(undefined4 *)((int)param_3 + param_4[0x10]) = + *(undefined4 *)((int)param_1 + param_2[0x10]); + } + if ((uVar14 != 0) && (uVar14 != 0)) { + puVar13 = param_4 + 0x11; + local_14 = uVar14; + do { + iVar11 = *(int *)(((int)param_2 - (int)param_4) + (int)puVar13); + uVar10 = *puVar13; + *(undefined4 *)(uVar10 + (int)param_3) = *(undefined4 *)(iVar11 + (int)param_1); + *(undefined4 *)(uVar10 + 4 + (int)param_3) = *(undefined4 *)(iVar11 + 4 + (int)param_1); + puVar13 = puVar13 + 1; + local_14 = local_14 - 1; + } while (local_14 != 0); + } + if (bVar7) { + if (param_6 == '\0') { + puVar12 = (undefined4 *)(param_2[0x19] + (int)param_1); + puVar16 = (undefined4 *)(param_4[0x19] + (int)param_3); + *puVar16 = *puVar12; + puVar16[1] = puVar12[1]; + puVar16[2] = puVar12[2]; + } + else { + uVar10 = param_2[0x19]; + puVar12 = (undefined4 *)(param_4[0x19] + (int)param_3); + *puVar12 = *(undefined4 *)(uVar10 + (int)param_1); + uVar1 = *(undefined4 *)((int)param_1 + uVar10 + 4); + puVar12[1] = uVar1; + uVar2 = *(undefined4 *)((int)param_1 + uVar10 + 8); + puVar12[2] = uVar1; + puVar12[1] = uVar2; + } + } + if (bVar8) { + if (param_6 == '\0') { + puVar12 = (undefined4 *)(param_2[0x1a] + (int)param_1); + puVar16 = (undefined4 *)(param_4[0x1a] + (int)param_3); + *puVar16 = *puVar12; + puVar16[1] = puVar12[1]; + puVar16[2] = puVar12[2]; + } + else { + uVar10 = param_2[0x1a]; + puVar12 = (undefined4 *)(param_4[0x1a] + (int)param_3); + *puVar12 = *(undefined4 *)(uVar10 + (int)param_1); + uVar1 = *(undefined4 *)((int)param_1 + uVar10 + 4); + puVar12[1] = uVar1; + uVar2 = *(undefined4 *)((int)param_1 + uVar10 + 8); + puVar12[2] = uVar1; + puVar12[1] = uVar2; + } + } + param_1 = (undefined4 *)((int)param_1 + param_2[1]); + param_3 = (undefined4 *)((int)param_3 + param_4[1]); + local_8 = local_8 + -1; + } while (local_8 != 0); + } + return; +} + + + +// --- FUN_00447aa0 at 0x00447AA0 (size: 300) --- + +uint __thiscall +FUN_00447aa0(int *param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4, + undefined4 param_5,undefined4 param_6,undefined4 param_7,undefined4 param_8,int param_9, + int param_10,int param_11,int param_12,undefined4 param_13,undefined4 param_14, + undefined4 param_15,undefined4 param_16,undefined4 param_17,undefined4 param_18) + +{ + int iVar1; + float fVar2; + byte bVar3; + char cVar4; + uint uVar5; + ushort uVar6; + undefined1 local_5; + uint local_4; + + fVar2 = *(float *)(param_12 + 0xc); + uVar6 = (ushort)(fVar2 < DAT_00796344) << 8 | (ushort)(NAN(fVar2) || NAN(DAT_00796344)) << 10 | + (ushort)(fVar2 == DAT_00796344) << 0xe; + if (fVar2 != DAT_00796344) { + fVar2 = *(float *)(param_10 + 0xa4); + uVar6 = (ushort)(fVar2 < DAT_00796344) << 8 | (ushort)(NAN(fVar2) || NAN(DAT_00796344)) << 10 | + (ushort)(fVar2 == DAT_00796344) << 0xe; + if (fVar2 != DAT_00796344) { + local_5 = 0; + local_4 = 0; + do { + iVar1 = local_4 + (DAT_0083841c + 0x38 + param_11 * 8) * 3; + bVar3 = *(byte *)(iVar1 + param_10); + uVar5 = CONCAT31((int3)((uint)iVar1 >> 8),bVar3); + if (bVar3 == 0xff) break; + iVar1 = *(int *)((uint)bVar3 * 4 + *(int *)(param_10 + 0x78)); + fVar2 = *(float *)(iVar1 + 0x88); + uVar5 = (uint)(ushort)((ushort)(fVar2 < DAT_00796344) << 8 | + (ushort)(NAN(fVar2) || NAN(DAT_00796344)) << 10 | + (ushort)(fVar2 == DAT_00796344) << 0xe); + if (fVar2 == DAT_00796344) break; + FUN_005a1d80(*(undefined4 *)(*(int *)(param_9 + 0x78) + (uint)bVar3 * 4),iVar1,param_1[0x2d] + ,param_12,param_13,param_14); + cVar4 = (**(code **)(*param_1 + 0x14)) + (param_2,param_3,param_4,param_5,param_6,param_7,param_8,param_15,param_16 + ,param_17,param_18); + if (cVar4 != '\0') { + local_5 = 1; + } + uVar5 = local_4 + 1; + local_4 = uVar5; + } while (uVar5 < 3); + return CONCAT31((int3)(uVar5 >> 8),local_5); + } + } + return (uint)uVar6; +} + + + +// --- FUN_00447be0 at 0x00447BE0 (size: 266) --- + +uint __thiscall +FUN_00447be0(int *param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4,int param_5, + int param_6,int param_7,int param_8,undefined4 param_9,undefined4 param_10, + undefined4 param_11) + +{ + int iVar1; + float fVar2; + byte bVar3; + char cVar4; + uint uVar5; + ushort uVar6; + undefined1 local_5; + uint local_4; + + fVar2 = *(float *)(param_8 + 0xc); + uVar6 = (ushort)(fVar2 < DAT_00796344) << 8 | (ushort)(NAN(fVar2) || NAN(DAT_00796344)) << 10 | + (ushort)(fVar2 == DAT_00796344) << 0xe; + if (fVar2 != DAT_00796344) { + fVar2 = *(float *)(param_6 + 0xa4); + uVar6 = (ushort)(fVar2 < DAT_00796344) << 8 | (ushort)(NAN(fVar2) || NAN(DAT_00796344)) << 10 | + (ushort)(fVar2 == DAT_00796344) << 0xe; + if (fVar2 != DAT_00796344) { + local_5 = 0; + local_4 = 0; + do { + iVar1 = local_4 + (DAT_0083841c + 0x38 + param_7 * 8) * 3; + bVar3 = *(byte *)(iVar1 + param_6); + uVar5 = CONCAT31((int3)((uint)iVar1 >> 8),bVar3); + if (bVar3 == 0xff) break; + iVar1 = *(int *)((uint)bVar3 * 4 + *(int *)(param_6 + 0x78)); + fVar2 = *(float *)(iVar1 + 0x88); + uVar5 = (uint)(ushort)((ushort)(fVar2 < DAT_00796344) << 8 | + (ushort)(NAN(fVar2) || NAN(DAT_00796344)) << 10 | + (ushort)(fVar2 == DAT_00796344) << 0xe); + if (fVar2 == DAT_00796344) break; + FUN_005a1d80(*(undefined4 *)(*(int *)(param_5 + 0x78) + (uint)bVar3 * 4),iVar1,param_1[0x2d] + ,param_8,param_9,0); + cVar4 = (**(code **)(*param_1 + 0x18))(param_2,param_3,param_4,param_10,param_11); + if (cVar4 != '\0') { + local_5 = 1; + } + uVar5 = local_4 + 1; + local_4 = uVar5; + } while (uVar5 < 3); + return CONCAT31((int3)(uVar5 >> 8),local_5); + } + } + return (uint)uVar6; +} + + + +// --- FUN_00447cf0 at 0x00447CF0 (size: 55) --- + +void __fastcall FUN_00447cf0(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_0079bfe8; + FUN_005d86a0(); + if ((param_1[0x29] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0x28]); + } + *param_1 = &PTR_LAB_00796c4c; + return; +} + + + +// --- FUN_00447d30 at 0x00447D30 (size: 75) --- + +undefined4 * __thiscall FUN_00447d30(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079bfe8; + FUN_005d86a0(); + if ((param_1[0x29] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0x28]); + } + *param_1 = &PTR_LAB_00796c4c; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00447d80 at 0x00447D80 (size: 108) --- + +undefined4 * __fastcall FUN_00447d80(undefined4 *param_1) + +{ + int iVar1; + undefined4 *puVar2; + undefined4 *puVar3; + + param_1[1] = 1; + *param_1 = &PTR_FUN_0079bfe8; + param_1[0x28] = 0; + param_1[0x29] = 0; + param_1[0x2a] = 0; + FUN_005d8650(); + *(undefined1 *)(param_1 + 0x2c) = 0; + param_1[0x4a] = 0; + *(undefined1 *)(param_1 + 0x4b) = 0; + *param_1 = &PTR_FUN_0079bffc; + *(undefined1 *)((int)param_1 + 0x12d) = 1; + puVar2 = &DAT_008ef180; + puVar3 = param_1 + 0x4c; + for (iVar1 = 6; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + *(undefined1 *)(param_1 + 0x52) = 0; + return param_1; +} + + + +// --- FUN_00447e10 at 0x00447E10 (size: 43) --- + +undefined4 * __thiscall FUN_00447e10(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079bffc; + FUN_00447520(); + FUN_00447cf0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00447e40 at 0x00447E40 (size: 47) --- + +undefined4 FUN_00447e40(void) + +{ + undefined4 uVar1; + int iVar2; + + if (DAT_0086734c != 0) { + /* WARNING: Could not recover jumptable at 0x00447e51. Too many branches */ + /* WARNING: Treating indirect jump as call */ + uVar1 = (**(code **)(*DAT_00870340 + 0x1c))(); + return uVar1; + } + iVar2 = FUN_005df0f5(0x14c); + if (iVar2 != 0) { + uVar1 = FUN_00447d80(); + return uVar1; + } + return 0; +} + + + +// --- FUN_00447e70 at 0x00447E70 (size: 111) --- + +void __fastcall FUN_00447e70(int param_1) + +{ + int iVar1; + undefined4 *puVar2; + undefined4 *puVar3; + + if ((*(char *)(param_1 + 0xb0) != '\0') && (*(char *)(param_1 + 0x12d) != '\0')) { + FUN_004476d0(*(undefined4 *)(param_1 + 0x80),param_1 + 8,*(undefined4 *)(param_1 + 0x128), + param_1 + 0xb4,*(undefined4 *)(param_1 + 0x7c),*(char *)(param_1 + 0xac) == '\0'); + puVar2 = (undefined4 *)(param_1 + 0x88); + puVar3 = (undefined4 *)(param_1 + 0x130); + for (iVar1 = 6; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar3 = *puVar2; + puVar2 = puVar2 + 1; + puVar3 = puVar3 + 1; + } + *(undefined1 *)(param_1 + 0x148) = 1; + *(undefined1 *)(param_1 + 0x12d) = 0; + } + return; +} + + + +// --- FUN_00447f60 at 0x00447F60 (size: 15) --- + +undefined1 __fastcall FUN_00447f60(int param_1) + +{ + FUN_0054d2e0(param_1 + 0xc); + return 1; +} + + + +// --- FUN_00447f70 at 0x00447F70 (size: 200) --- + +void __fastcall FUN_00447f70(int *param_1) + +{ + undefined *puVar1; + LONG LVar2; + LONG *pLVar3; + + puVar1 = (undefined *)*param_1; + if (puVar1 != PTR_DAT_00818344) { + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + pLVar3 = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = (int)PTR_DAT_00818344; + InterlockedIncrement(pLVar3); + } + puVar1 = (undefined *)param_1[1]; + if (puVar1 != PTR_DAT_00818344) { + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + pLVar3 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[1] = (int)PTR_DAT_00818344; + InterlockedIncrement(pLVar3); + } + param_1[2] = DAT_00839a7c; + param_1[5] = 1; + param_1[6] = 1; + param_1[3] = 0; + param_1[4] = 0; + param_1[0xc] = 0; + param_1[0xf] = 0; + param_1[0x10] = 0; + *(undefined1 *)(param_1 + 0x11) = 0; + param_1[7] = 2; + param_1[8] = 2; + param_1[9] = 2; + param_1[10] = 3; + param_1[0xb] = 2; + param_1[0xd] = 3; + param_1[0xe] = 2; + return; +} + + + +// --- FUN_00448040 at 0x00448040 (size: 251) --- + +undefined4 __thiscall FUN_00448040(int *param_1,char param_2,int *param_3) + +{ + int iVar1; + LONG LVar2; + + if (param_2 == '\0') { + iVar1 = *param_3; + if (iVar1 != *param_1) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *param_1; + *param_3 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + iVar1 = param_3[1]; + if (iVar1 != param_1[1]) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = param_1[1]; + param_3[1] = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + } + param_3[2] = param_1[2]; + param_3[3] = 0; + if ((int *)param_1[3] != (int *)0x0) { + (**(code **)(*(int *)param_1[3] + 0x10))(); + iVar1 = param_1[3]; + param_3[3] = iVar1; + FUN_00695670(iVar1); + } + param_3[4] = param_1[4]; + param_3[5] = param_1[5]; + param_3[6] = param_1[6]; + param_3[7] = param_1[7]; + param_3[8] = param_1[8]; + param_3[9] = param_1[9]; + param_3[10] = param_1[10]; + param_3[0xb] = param_1[0xb]; + param_3[0xc] = param_1[0xc]; + param_3[0xd] = param_1[0xd]; + param_3[0xe] = param_1[0xe]; + param_3[0xf] = param_1[0xf]; + iVar1 = param_1[0x10]; + param_3[0x10] = iVar1; + *(char *)(param_3 + 0x11) = (char)param_1[0x11]; + return CONCAT31((int3)((uint)iVar1 >> 8),1); +} + + + +// --- FUN_00448140 at 0x00448140 (size: 180) --- + +undefined4 __thiscall FUN_00448140(int param_1,int *param_2,int param_3) + +{ + LONG LVar1; + undefined4 uVar2; + int iVar3; + + iVar3 = *(int *)(param_1 + 4); + if (iVar3 != *param_2) { + LVar1 = InterlockedDecrement((LONG *)(iVar3 + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(iVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar3 + -0x14))(1); + } + iVar3 = *param_2; + *(int *)(param_1 + 4) = iVar3; + InterlockedIncrement((LONG *)(iVar3 + -0x10)); + } + if ((*(int *)(param_1 + 8) != param_3) || + ((*(int *)(param_1 + 8) != DAT_00839a7c && (*(int *)(param_1 + 0xc) == 0)))) { + *(int *)(param_1 + 8) = param_3; + iVar3 = 0; + if (param_3 != DAT_00839a7c) { + uVar2 = FUN_004220b0(param_3,0x1e); + iVar3 = FUN_00415430(uVar2); + if (iVar3 == 0) { + return 0; + } + FUN_00695670(iVar3); + } + FUN_0054d2e0((int *)(param_1 + 0xc)); + if (iVar3 != 0) { + *(int *)(param_1 + 0xc) = iVar3; + } + } + return 1; +} + + + +// --- FUN_00448200 at 0x00448200 (size: 134) --- + +undefined4 __thiscall FUN_00448200(int param_1,int *param_2) + +{ + undefined *puVar1; + LONG LVar2; + LONG *lpAddend; + + if (param_2 == (int *)0x0) { + *(undefined4 *)(param_1 + 8) = DAT_00839a7c; + } + else { + (**(code **)(*param_2 + 0x10))(); + FUN_00695670(param_2); + *(int *)(param_1 + 8) = param_2[10]; + } + FUN_0054d2e0((undefined4 *)(param_1 + 0xc)); + puVar1 = *(undefined **)(param_1 + 4); + if (puVar1 != PTR_DAT_00818344) { + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *(undefined **)(param_1 + 4) = PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + *(undefined4 *)(param_1 + 0xc) = param_2; + return 1; +} + + + +// --- FUN_00448290 at 0x00448290 (size: 180) --- + +undefined1 __thiscall FUN_00448290(int *param_1,int *param_2) + +{ + char cVar1; + int iVar2; + int *piVar3; + LONG LVar4; + undefined1 uVar5; + int unaff_ESI; + int *piStack_4; + + uVar5 = 0; + if ((int *)param_1[2] != (int *)0x0) { + piStack_4 = param_1; + iVar2 = (**(code **)(*(int *)param_1[2] + 4))(); + if (iVar2 == 1) { + *param_2 = ((int *)param_1[2])[1]; + return 1; + } + (**(code **)(*(int *)param_1[2] + 0x14))(&piStack_4); + piVar3 = (int *)FUN_005df0f5(8); + if (piVar3 == (int *)0x0) { + piVar3 = (int *)0x0; + } + else { + *piVar3 = (int)&PTR_FUN_00798108; + } + cVar1 = (**(code **)(*piVar3 + 0x10))(&stack0xfffffff8); + if (cVar1 == '\0') { + (**(code **)*piVar3)(1); + uVar5 = 0; + } + else { + *piStack_4 = piVar3[1]; + if ((undefined4 *)param_1[2] != (undefined4 *)0x0) { + (*(code *)**(undefined4 **)param_1[2])(1); + } + param_1[2] = (int)piVar3; + uVar5 = 1; + } + LVar4 = InterlockedDecrement((LONG *)(unaff_ESI + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(unaff_ESI + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(unaff_ESI + -0x14))(1); + } + } + return uVar5; +} + + + +// --- FUN_00448350 at 0x00448350 (size: 54) --- + +undefined4 * __fastcall FUN_00448350(undefined4 *param_1) + +{ + LONG *pLVar1; + + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[1] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + FUN_00447f70(); + return param_1; +} + + + +// --- FUN_00448390 at 0x00448390 (size: 89) --- + +void __fastcall FUN_00448390(int *param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + FUN_0054d2e0(param_1 + 3); + FUN_00447f70(); + puVar2 = (undefined4 *)(param_1[1] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[1] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(*param_1 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*param_1 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return; +} + + + +// --- FUN_004483f0 at 0x004483F0 (size: 98) --- + +uint FUN_004483f0(undefined4 param_1) + +{ + char cVar1; + undefined4 *puVar2; + LONG *pLVar3; + + puVar2 = (undefined4 *)FUN_005df0f5(0x48); + if (puVar2 != (undefined4 *)0x0) { + pLVar3 = (LONG *)(PTR_DAT_00818344 + -0x10); + *puVar2 = PTR_DAT_00818344; + InterlockedIncrement(pLVar3); + pLVar3 = (LONG *)(PTR_DAT_00818344 + -0x10); + puVar2[1] = PTR_DAT_00818344; + InterlockedIncrement(pLVar3); + FUN_00447f70(); + cVar1 = FUN_00448040(param_1,puVar2); + return -(uint)(cVar1 != '\0') & (uint)puVar2; + } + return 0; +} + + + +// --- FUN_00448460 at 0x00448460 (size: 120) --- + +undefined4 __fastcall FUN_00448460(int param_1) + +{ + undefined4 *puVar1; + int iVar2; + char cVar3; + LONG LVar4; + int local_4; + + if (*(int *)(param_1 + 8) != DAT_00839a7c) { + iVar2 = *(int *)(param_1 + 4); + local_4 = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + cVar3 = FUN_00448140(&local_4,*(undefined4 *)(param_1 + 8)); + puVar1 = (undefined4 *)(iVar2 + -0x14); + if (cVar3 == '\0') { + LVar4 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar4 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + return 0; + } + LVar4 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar4 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + } + return 1; +} + + + +// --- FUN_004484e0 at 0x004484E0 (size: 673) --- + +void __thiscall FUN_004484e0(int param_1,int param_2) + +{ + undefined4 *puVar1; + byte *pbVar2; + byte bVar3; + + FUN_00402400(param_2); + FUN_0040ad10(4); + puVar1 = (undefined4 *)FUN_0040acf0(4); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 8) = *puVar1; + } + else { + *puVar1 = *(undefined4 *)(param_1 + 8); + } + } + FUN_0040ad10(4); + puVar1 = (undefined4 *)FUN_0040acf0(4); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x10) = *puVar1; + } + else { + *puVar1 = *(undefined4 *)(param_1 + 0x10); + } + } + bVar3 = *(byte *)(param_1 + 0x14); + FUN_0040ad10(1); + pbVar2 = (byte *)FUN_0040acf0(1); + if (pbVar2 != (byte *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + bVar3 = *pbVar2; + } + else { + *pbVar2 = bVar3; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + *(uint *)(param_1 + 0x14) = (uint)bVar3; + } + bVar3 = *(byte *)(param_1 + 0x18); + FUN_0040ad10(1); + pbVar2 = (byte *)FUN_0040acf0(1); + if (pbVar2 != (byte *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + bVar3 = *pbVar2; + } + else { + *pbVar2 = bVar3; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + *(uint *)(param_1 + 0x18) = (uint)bVar3; + } + bVar3 = *(byte *)(param_1 + 0x1c); + FUN_0040ad10(1); + pbVar2 = (byte *)FUN_0040acf0(1); + if (pbVar2 != (byte *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + bVar3 = *pbVar2; + } + else { + *pbVar2 = bVar3; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + *(uint *)(param_1 + 0x1c) = (uint)bVar3; + } + bVar3 = *(byte *)(param_1 + 0x20); + FUN_0040ad10(1); + pbVar2 = (byte *)FUN_0040acf0(1); + if (pbVar2 != (byte *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + bVar3 = *pbVar2; + } + else { + *pbVar2 = bVar3; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + *(uint *)(param_1 + 0x20) = (uint)bVar3; + } + bVar3 = *(byte *)(param_1 + 0x24); + FUN_0040ad10(1); + pbVar2 = (byte *)FUN_0040acf0(1); + if (pbVar2 != (byte *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + bVar3 = *pbVar2; + } + else { + *pbVar2 = bVar3; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + *(uint *)(param_1 + 0x24) = (uint)bVar3; + } + bVar3 = *(byte *)(param_1 + 0x28); + FUN_0040ad10(1); + pbVar2 = (byte *)FUN_0040acf0(1); + if (pbVar2 != (byte *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + bVar3 = *pbVar2; + } + else { + *pbVar2 = bVar3; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + *(uint *)(param_1 + 0x28) = (uint)bVar3; + } + FUN_0040ad10(4); + puVar1 = (undefined4 *)FUN_0040acf0(4); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x2c) = *puVar1; + } + else { + *puVar1 = *(undefined4 *)(param_1 + 0x2c); + } + } + FUN_0040ad10(4); + puVar1 = (undefined4 *)FUN_0040acf0(4); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x30) = *puVar1; + } + else { + *puVar1 = *(undefined4 *)(param_1 + 0x30); + } + } + bVar3 = *(byte *)(param_1 + 0x34); + FUN_0040ad10(1); + pbVar2 = (byte *)FUN_0040acf0(1); + if (pbVar2 != (byte *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + bVar3 = *pbVar2; + } + else { + *pbVar2 = bVar3; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + *(uint *)(param_1 + 0x34) = (uint)bVar3; + } + FUN_0040ad10(4); + puVar1 = (undefined4 *)FUN_0040acf0(4); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x38) = *puVar1; + } + else { + *puVar1 = *(undefined4 *)(param_1 + 0x38); + } + } + FUN_0040ad10(4); + puVar1 = (undefined4 *)FUN_0040acf0(4); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x3c) = *puVar1; + } + else { + *puVar1 = *(undefined4 *)(param_1 + 0x3c); + } + } + FUN_0040ad10(4); + puVar1 = (undefined4 *)FUN_0040acf0(4); + if (puVar1 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *puVar1 = *(undefined4 *)(param_1 + 0x40); + FUN_00422250(param_1 + 0x44,param_2); + return; + } + *(undefined4 *)(param_1 + 0x40) = *puVar1; + } + FUN_00422250(param_1 + 0x44,param_2); + return; +} + + + +// --- FUN_00448790 at 0x00448790 (size: 124) --- + +undefined4 FUN_00448790(void) + +{ + char cVar1; + undefined2 *puVar2; + + if (DAT_0083a18c != (undefined4 *)0x0) { + (**(code **)*DAT_0083a18c)(1); + } + DAT_0083a18c = (int *)0x0; + DAT_0083a18c = (int *)FUN_0054d2a0(); + if (DAT_0083a18c != (int *)0x0) { + cVar1 = (**(code **)(*DAT_0083a18c + 4))(6,2,1,1,1); + if (cVar1 != '\0') { + puVar2 = (undefined2 *)FUN_0044cb70(); + *puVar2 = 0; + puVar2[1] = 2; + puVar2[2] = 1; + puVar2[3] = 1; + puVar2[4] = 2; + puVar2[5] = 3; + FUN_0044cb80(); + return 1; + } + } + return 0; +} + + + +// --- FUN_00448810 at 0x00448810 (size: 11) --- + +bool FUN_00448810(void) + +{ + char cVar1; + + cVar1 = FUN_00448790(); + return cVar1 != '\0'; +} + + + +// --- FUN_00448820 at 0x00448820 (size: 64) --- + +undefined4 * __thiscall FUN_00448820(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079c09c; + if ((undefined4 *)param_1[0x18] != param_1 + 1) { + operator_delete__((undefined4 *)param_1[0x18]); + } + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_00448860 at 0x00448860 (size: 52) --- + +undefined4 __thiscall FUN_00448860(int param_1,uint *param_2) + +{ + uint *puVar1; + bool bVar2; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + bVar2 = puVar1 == (uint *)0x0; + if (!bVar2) { + do { + if (*puVar1 == *param_2) break; + puVar1 = (uint *)puVar1[1]; + } while (puVar1 != (uint *)0x0); + bVar2 = puVar1 == (uint *)0x0; + } + return CONCAT31((int3)((uint)puVar1 >> 8),!bVar2); +} + + + +// --- FUN_004488a0 at 0x004488A0 (size: 110) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_004488a0(void) + +{ + int iVar1; + + iVar1 = 0; + DAT_0083a190 = 1; + _DAT_0083a194 = 0; + if (DAT_0083a334 != 0) { + if (DAT_0083a338 == 0) { + iVar1 = 0; + } + else { + iVar1 = DAT_0083a338 + -8; + } + } + for (; iVar1 != 0; iVar1 = *(int *)(iVar1 + 8) + -8) { + if ((char)(*(int **)(iVar1 + 0x10))[2] != '\0') { + (**(code **)(**(int **)(iVar1 + 0x10) + 4))(); + } + if (*(int *)(iVar1 + 8) == 0) break; + } + FUN_00695670(); + DAT_0083a190 = 0; + return; +} + + + +// --- FUN_00448910 at 0x00448910 (size: 346) --- + +void FUN_00448910(uint *param_1,uint *param_2,int *param_3,int *param_4) + +{ + int iVar1; + int iVar2; + uint uVar3; + uint uVar4; + uint uVar5; + uint uVar6; + uint uVar7; + + *param_1 = 0; + *param_2 = 0; + iVar2 = FUN_0054fd20(); + *param_3 = iVar2; + iVar2 = FUN_0054fd30(); + *param_4 = iVar2; + uVar5 = 0; + iVar2 = FUN_0054fd20(); + uVar7 = iVar2 - 1; + uVar4 = 0; + iVar2 = FUN_0054fd30(); + uVar6 = iVar2 - 1; + iVar2 = 0; + if (DAT_0083a334 != 0) { + if (DAT_0083a338 == 0) { + iVar2 = 0; + } + else { + iVar2 = DAT_0083a338 + -8; + } + } + for (; iVar2 != 0; iVar2 = *(int *)(iVar2 + 8) + -8) { + iVar1 = *(int *)(iVar2 + 0x10); + if (*(char *)(iVar1 + 8) != '\0') { + switch(*(undefined4 *)(iVar1 + 0xc)) { + case 1: + uVar3 = *(int *)(iVar1 + 0x2c) + *(int *)(iVar1 + 0x24); + if (uVar4 < uVar3) { + uVar4 = uVar3; + } + break; + case 2: + uVar3 = *(int *)(iVar1 + 0x24) - 1; + if (uVar3 < uVar6) { + uVar6 = uVar3; + } + break; + case 3: + uVar3 = *(int *)(iVar1 + 0x28) + *(int *)(iVar1 + 0x20); + if (uVar5 < uVar3) { + uVar5 = uVar3; + } + break; + case 4: + uVar3 = *(int *)(iVar1 + 0x20) - 1; + if (uVar3 < uVar7) { + uVar7 = uVar3; + } + } + } + if (*(int *)(iVar2 + 8) == 0) break; + } + iVar2 = FUN_0054fd20(); + if (iVar2 - 2U <= uVar5) { + iVar2 = FUN_0054fd20(); + uVar5 = iVar2 - 2; + } + iVar2 = FUN_0054fd30(); + if (iVar2 - 2U <= uVar4) { + iVar2 = FUN_0054fd30(); + uVar4 = iVar2 - 2; + } + if (uVar7 <= uVar5) { + uVar7 = uVar5 + 1; + } + if (uVar6 <= uVar4) { + uVar6 = uVar4 + 1; + } + *param_1 = uVar5; + *param_2 = uVar4; + *param_3 = (uVar7 - uVar5) + 1; + *param_4 = (uVar6 - uVar4) + 1; + return; +} + + + +// --- FUN_00448a80 at 0x00448A80 (size: 143) --- + +undefined4 * __thiscall FUN_00448a80(undefined4 *param_1,undefined4 param_2) + +{ + undefined *puVar1; + uint *puVar2; + undefined4 uVar3; + uint uVar4; + int iVar5; + undefined4 *puVar6; + + param_1[0x18] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + *param_1 = &PTR_FUN_0079c09c; + puVar1 = PTR_DAT_00818558; + puVar2 = (uint *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,¶m_2,param_2,0); + if (puVar2 == (uint *)puVar1) { + puVar2 = puVar2 + -1; + } + uVar4 = *puVar2; + param_1[0x1a] = uVar4; + if (uVar4 < 0x18) { + param_1[0x18] = param_1 + 1; + } + else { + uVar3 = thunk_FUN_005df0f5(uVar4 << 2); + param_1[0x18] = uVar3; + } + param_1[0x19] = (undefined4 *)param_1[0x18] + param_1[0x1a]; + puVar6 = (undefined4 *)param_1[0x18]; + for (uVar4 = param_1[0x1a] & 0x3fffffff; uVar4 != 0; uVar4 = uVar4 - 1) { + *puVar6 = 0; + puVar6 = puVar6 + 1; + } + for (iVar5 = 0; iVar5 != 0; iVar5 = iVar5 + -1) { + *(undefined1 *)puVar6 = 0; + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + return param_1; +} + + + +// --- FUN_00448b10 at 0x00448B10 (size: 202) --- + +uint __thiscall FUN_00448b10(int param_1,uint param_2) + +{ + int iVar1; + int iVar2; + int iVar3; + int iVar4; + int *piVar5; + + if (param_2 == *(uint *)(param_1 + 0x68)) { + return param_2 & 0xffffff00; + } + iVar3 = *(int *)(param_1 + 0x6c); + iVar1 = 0; + do { + if (iVar3 == 0) { + if (*(void **)(param_1 + 0x60) != (void *)(param_1 + 4)) { + operator_delete__(*(void **)(param_1 + 0x60)); + } + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined4 *)(param_1 + 0x68) = 0; + *(undefined4 *)(param_1 + 0x6c) = 0; + FUN_00693b20(param_2); + while (iVar1 != 0) { + iVar3 = *(int *)(iVar1 + 4); + FUN_00448c90(iVar1); + iVar1 = iVar3; + } + return 1; + } + piVar5 = *(int **)(param_1 + 100); + while (piVar5 != (int *)(*(int *)(param_1 + 0x60) + *(int *)(param_1 + 0x68) * 4)) { + if (**(int **)(param_1 + 100) != 0) { + piVar5 = *(int **)(param_1 + 100); + iVar4 = *piVar5; + goto LAB_00448b5e; + } + piVar5 = *(int **)(param_1 + 100) + 1; + *(int **)(param_1 + 100) = piVar5; + } + piVar5 = (int *)0x0; + iVar4 = 0; +LAB_00448b5e: + iVar3 = *piVar5; + if (iVar3 == iVar4) { +LAB_00448b71: + *piVar5 = *(int *)(iVar3 + 4); + } + else { + do { + iVar2 = iVar3; + iVar3 = *(int *)(iVar2 + 4); + } while (iVar3 != iVar4); + if (iVar2 == 0) goto LAB_00448b71; + *(undefined4 *)(iVar2 + 4) = *(undefined4 *)(iVar3 + 4); + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; + *(int *)(iVar4 + 4) = iVar1; + iVar3 = *(int *)(param_1 + 0x6c); + iVar1 = iVar4; + } while( true ); +} + + + +// --- FUN_00448be0 at 0x00448BE0 (size: 88) --- + +void FUN_00448be0(void) + +{ + undefined4 local_10; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + FUN_00448910(&local_4,&local_8,&local_c,&local_10); + (**(code **)(*DAT_00870340 + 0x40))(local_4,local_8,local_c,local_10,0); + FUN_00693760(local_4,local_8,local_c,local_10); + return; +} + + + +// --- FUN_00448c40 at 0x00448C40 (size: 73) --- + +void __fastcall FUN_00448c40(int param_1) + +{ + undefined *puVar1; + undefined4 *puVar2; + undefined4 local_4; + + puVar1 = PTR_DAT_00818558; + local_4 = *(undefined4 *)(param_1 + 0x68); + puVar2 = (undefined4 *)FUN_00422d20(PTR_DAT_00818554,PTR_DAT_00818558,&local_4,local_4,0); + if ((puVar2 != (undefined4 *)puVar1) || (puVar2 = puVar2 + -1, puVar2 != (undefined4 *)puVar1)) { + puVar2 = puVar2 + 1; + } + FUN_00448b10(*puVar2); + return; +} + + + +// --- FUN_00448c90 at 0x00448C90 (size: 62) --- + +void __thiscall FUN_00448c90(int param_1,uint *param_2) + +{ + uint *puVar1; + + if (*(int *)(param_1 + 0x68) * 2 < *(int *)(param_1 + 0x6c) + 1) { + FUN_00448c40(); + } + puVar1 = (uint *)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + param_2[1] = *puVar1; + *puVar1 = (uint)param_2; + if (puVar1 < *(uint **)(param_1 + 100)) { + *(uint **)(param_1 + 100) = puVar1; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + 1; + return; +} + + + +// --- FUN_00448cd0 at 0x00448CD0 (size: 198) --- + +void __fastcall FUN_00448cd0(int param_1) + +{ + int *piVar1; + int iVar2; + undefined4 *puVar3; + uint *puVar4; + uint *puVar5; + uint *puVar6; + uint uVar7; + uint *puVar8; + +LAB_00448cd6: + while( true ) { + puVar8 = (uint *)0x0; + if (*(int *)(param_1 + 0x6c) == 0) { + return; + } + piVar1 = *(int **)(param_1 + 0x70); + if (piVar1 != (int *)0x0) { + if ((int *)piVar1[1] == (int *)0x0) { + iVar2 = *piVar1; + *(int *)(param_1 + 0x70) = iVar2; + if (iVar2 != 0) { + *(undefined4 *)(iVar2 + 4) = 0; + } + } + else { + *(int *)piVar1[1] = *piVar1; + } + if (*piVar1 == 0) { + puVar3 = *(undefined4 **)(*(int *)(param_1 + 0x74) + 4); + *(undefined4 **)(param_1 + 0x74) = puVar3; + if (puVar3 != (undefined4 *)0x0) { + *puVar3 = 0; + } + } + else { + *(int *)(*piVar1 + 4) = piVar1[1]; + } + *piVar1 = 0; + piVar1[1] = 0; + if (piVar1 != (int *)0x0) { + puVar8 = (uint *)(piVar1 + -2); + } + } + uVar7 = *puVar8 % *(uint *)(param_1 + 0x68); + puVar6 = *(uint **)(*(int *)(param_1 + 0x60) + uVar7 * 4); + puVar4 = puVar6; + if (puVar6 == (uint *)0x0) break; + do { + if (*puVar4 == *puVar8) { + if (puVar4 == (uint *)0x0) goto LAB_00448d83; + if (puVar6 != puVar4) goto LAB_00448d66; + goto LAB_00448d73; + } + puVar4 = (uint *)puVar4[1]; + } while (puVar4 != (uint *)0x0); + operator_delete(puVar8); + } + goto LAB_00448d83; +LAB_00448d66: + do { + puVar5 = puVar6; + puVar6 = (uint *)puVar5[1]; + } while (puVar6 != puVar4); + if (puVar5 == (uint *)0x0) { +LAB_00448d73: + *(uint *)(*(int *)(param_1 + 0x60) + uVar7 * 4) = puVar6[1]; + } + else { + puVar5[1] = puVar6[1]; + } + *(int *)(param_1 + 0x6c) = *(int *)(param_1 + 0x6c) + -1; +LAB_00448d83: + operator_delete(puVar8); + goto LAB_00448cd6; +} + + + +// --- FUN_00448da0 at 0x00448DA0 (size: 120) --- + +uint __thiscall FUN_00448da0(int param_1,uint *param_2) + +{ + uint *puVar1; + int iVar2; + uint uVar3; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + do { + if (puVar1 == (uint *)0x0) { +LAB_00448dcb: + if ((int)(*(uint *)(param_1 + 0x68) * 2) < *(int *)(param_1 + 0x6c) + 1) { + FUN_00448c40(); + } + uVar3 = *param_2 % *(uint *)(param_1 + 0x68); + iVar2 = *(int *)(param_1 + 0x60); + param_2[1] = *(uint *)(iVar2 + uVar3 * 4); + *(uint **)(iVar2 + uVar3 * 4) = param_2; + uVar3 = iVar2 + uVar3 * 4; + if (uVar3 < *(uint *)(param_1 + 100)) { + *(uint *)(param_1 + 100) = uVar3; + } + iVar2 = *(int *)(param_1 + 0x6c) + 1; + *(int *)(param_1 + 0x6c) = iVar2; + return CONCAT31((int3)((uint)iVar2 >> 8),1); + } + if (*puVar1 == *param_2) { + if (puVar1 != (uint *)0x0) { + return (uint)puVar1 & 0xffffff00; + } + goto LAB_00448dcb; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_00448e20 at 0x00448E20 (size: 124) --- + +undefined4 __thiscall FUN_00448e20(int param_1,uint *param_2) + +{ + uint *puVar1; + undefined3 uVar2; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + do { + if (puVar1 == (uint *)0x0) { +LAB_00448e4b: + FUN_00448da0(param_2); +LAB_00448e53: + puVar1 = param_2 + 2; + *puVar1 = *(uint *)(param_1 + 0x70); + uVar2 = (undefined3)((uint)puVar1 >> 8); + if (*(int *)(param_1 + 0x70) != 0) { + *(uint **)(*(int *)(param_1 + 0x70) + 4) = puVar1; + *(uint **)(param_1 + 0x70) = puVar1; + param_2[3] = 0; + return CONCAT31(uVar2,1); + } + *(uint **)(param_1 + 0x74) = puVar1; + *(uint **)(param_1 + 0x70) = puVar1; + param_2[3] = 0; + return CONCAT31(uVar2,1); + } + if (*puVar1 == *param_2) { + if (puVar1 != (uint *)0x0) { + FUN_00410880(param_2 + 2); + goto LAB_00448e53; + } + goto LAB_00448e4b; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_00448ea0 at 0x00448EA0 (size: 117) --- + +void FUN_00448ea0(void) + +{ + int *piVar1; + undefined4 *puVar2; + int iVar3; + + if (DAT_0083a334 != 0) { + iVar3 = 0; + if (DAT_0083a334 != 0) { + if (DAT_0083a338 == 0) { + iVar3 = 0; + } + else { + iVar3 = DAT_0083a338 + -8; + } + } + for (; iVar3 != 0; iVar3 = *(int *)(iVar3 + 8) + -8) { + puVar2 = *(undefined4 **)(iVar3 + 0x10); + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + if (*(int *)(iVar3 + 8) == 0) break; + } + FUN_00448cd0(); + } + if (DAT_0083a18c != (undefined4 *)0x0) { + (**(code **)*DAT_0083a18c)(1); + } + DAT_0083a18c = (undefined4 *)0x0; + return; +} + + + +// --- FUN_00448f20 at 0x00448F20 (size: 56) --- + +void FUN_00448f20(undefined4 *param_1) + +{ + int iVar1; + undefined4 *puVar2; + void *pvVar3; + + puVar2 = param_1; + if (param_1 != (undefined4 *)0x0) { + pvVar3 = (void *)FUN_006767f0(¶m_1); + if (pvVar3 != (void *)0x0) { + operator_delete(pvVar3); + iVar1 = puVar2[1]; + puVar2[1] = iVar1 + -1; + if (iVar1 + -1 == 0) { + (**(code **)*puVar2)(1); + } + } + } + return; +} + + + +// --- FUN_00448f60 at 0x00448F60 (size: 69) --- + +undefined4 __thiscall FUN_00448f60(int param_1,uint *param_2) + +{ + uint *puVar1; + undefined4 uVar2; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + if (puVar1 != (uint *)0x0) { + while (*puVar1 != *param_2) { + puVar1 = (uint *)puVar1[1]; + if (puVar1 == (uint *)0x0) { + return 0; + } + } + if (puVar1 != (uint *)0x0) { + uVar2 = FUN_00448e20(); + return uVar2; + } + } + return 0; +} + + + +// --- FUN_00448fb0 at 0x00448FB0 (size: 117) --- + +uint __thiscall FUN_00448fb0(int param_1,uint *param_2) + +{ + uint *puVar1; + undefined3 uVar2; + + puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + do { + if (puVar1 == (uint *)0x0) { +LAB_00448fdb: + FUN_00448da0(param_2); + puVar1 = param_2 + 2; + *puVar1 = *(uint *)(param_1 + 0x70); + uVar2 = (undefined3)((uint)puVar1 >> 8); + if (*(int *)(param_1 + 0x70) != 0) { + *(uint **)(*(int *)(param_1 + 0x70) + 4) = puVar1; + *(uint **)(param_1 + 0x70) = puVar1; + param_2[3] = 0; + return CONCAT31(uVar2,1); + } + *(uint **)(param_1 + 0x74) = puVar1; + *(uint **)(param_1 + 0x70) = puVar1; + param_2[3] = 0; + return CONCAT31(uVar2,1); + } + if (*puVar1 == *param_2) { + if (puVar1 != (uint *)0x0) { + return (uint)puVar1 & 0xffffff00; + } + goto LAB_00448fdb; + } + puVar1 = (uint *)puVar1[1]; + } while( true ); +} + + + +// --- FUN_00449030 at 0x00449030 (size: 106) --- + +undefined4 FUN_00449030(int param_1,int param_2) + +{ + char cVar1; + undefined4 uVar2; + + if (param_1 == 0) { + uVar2 = FUN_00448fb0(param_2); + return uVar2; + } + cVar1 = FUN_00448860(param_2); + if (cVar1 != '\0') { + return 0; + } + FUN_00448da0(param_2); + if (param_2 != 0) { + FUN_00410820(param_2 + 8,param_1 + 8); + return 1; + } + FUN_00410820(0,param_1 + 8); + return 1; +} + + + +// --- FUN_004490a0 at 0x004490A0 (size: 129) --- + +undefined4 FUN_004490a0(int param_1,int param_2) + +{ + char cVar1; + undefined4 uVar2; + + if (param_1 == 0) { + uVar2 = FUN_00448e20(param_2); + return uVar2; + } + cVar1 = FUN_00448860(param_2); + if (cVar1 == '\0') { + FUN_00448da0(param_2); + } + else if (param_2 == 0) { + FUN_00410880(0); + } + else { + FUN_00410880(param_2 + 8); + } + if (param_2 != 0) { + FUN_00410820(param_2 + 8,param_1 + 8); + return 1; + } + FUN_00410820(0,param_1 + 8); + return 1; +} + + + +// --- FUN_00449130 at 0x00449130 (size: 147) --- + +char __thiscall FUN_00449130(int param_1,uint *param_2,uint *param_3) + +{ + char cVar1; + uint *puVar2; + + puVar2 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + do { + if (puVar2 == (uint *)0x0) { +LAB_0044915b: + puVar2 = (uint *)FUN_005df0f5(0x14); + if (puVar2 == (uint *)0x0) { + puVar2 = (uint *)0x0; + } + else { + *puVar2 = *param_2; + puVar2[1] = 0; + puVar2[2] = 0; + puVar2[3] = 0; + puVar2[4] = *param_3; + } + cVar1 = FUN_00448fb0(puVar2); + if ((cVar1 == '\0') && (puVar2 != (uint *)0x0)) { + operator_delete(puVar2); + } + return cVar1; + } + if (*puVar2 == *param_2) { + if (puVar2 != (uint *)0x0) { + cVar1 = FUN_00448f60(param_2); + return cVar1; + } + goto LAB_0044915b; + } + puVar2 = (uint *)puVar2[1]; + } while( true ); +} + + + +// --- FUN_004491d0 at 0x004491D0 (size: 109) --- + +uint __thiscall FUN_004491d0(int param_1,uint *param_2,uint *param_3) + +{ + uint *puVar1; + uint *puVar2; + uint uVar3; + + for (puVar1 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + (puVar1 != (uint *)0x0 && (*puVar1 != *param_2)); puVar1 = (uint *)puVar1[1]) { + } + for (puVar2 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_3 % *(uint *)(param_1 + 0x68)) * 4); + (puVar2 != (uint *)0x0 && (*puVar2 != *param_3)); puVar2 = (uint *)puVar2[1]) { + } + if ((puVar1 != (uint *)0x0) && (puVar2 != (uint *)0x0)) { + uVar3 = FUN_004490a0(puVar1,puVar2); + return uVar3; + } + return (uint)puVar2 & 0xffffff00; +} + + + +// --- FUN_00449240 at 0x00449240 (size: 220) --- + +undefined4 __thiscall +FUN_00449240(int param_1,uint *param_2,undefined4 *param_3,undefined4 *param_4) + +{ + char cVar1; + undefined4 uVar2; + undefined4 *puVar3; + uint *puVar4; + + puVar4 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + if (puVar4 != (uint *)0x0) { + while (*puVar4 != *param_2) { + puVar4 = (uint *)puVar4[1]; + if (puVar4 == (uint *)0x0) { + return 0; + } + } + if (puVar4 != (uint *)0x0) { + cVar1 = FUN_00448860(param_3); + if (cVar1 != '\0') { + uVar2 = FUN_004491d0(param_2,param_3); + return uVar2; + } + puVar3 = (undefined4 *)FUN_005df0f5(0x14); + if (puVar3 == (undefined4 *)0x0) { + puVar3 = (undefined4 *)0x0; + } + else { + *puVar3 = *param_3; + puVar3[1] = 0; + puVar3[2] = 0; + puVar3[3] = 0; + puVar3[4] = *param_4; + } + puVar4 = *(uint **)(*(int *)(param_1 + 0x60) + (*param_2 % *(uint *)(param_1 + 0x68)) * 4); + do { + if (puVar4 == (uint *)0x0) { +LAB_004492f1: + if (puVar3 != (undefined4 *)0x0) { + operator_delete(puVar3); + } + return 0; + } + if (*puVar4 == *param_2) { + if ((puVar4 != (uint *)0x0) && (cVar1 = FUN_00449030(puVar4,puVar3), cVar1 != '\0')) { + return 1; + } + goto LAB_004492f1; + } + puVar4 = (uint *)puVar4[1]; + } while( true ); + } + } + return 0; +} + + + +// --- FUN_00449320 at 0x00449320 (size: 168) --- + +void FUN_00449320(int param_1) + +{ + int iVar1; + char cVar2; + int iVar3; + int local_10; + undefined *local_c; + + iVar1 = param_1; + if (param_1 != 0) { + iVar3 = 0; + if (DAT_0083a334 != 0) { + if (DAT_0083a33c == 0) { + iVar3 = 0; + } + else { + iVar3 = DAT_0083a33c + -8; + } + } + local_c = &DAT_0083a2c8; + if (iVar3 != 0) { + do { + local_10 = *(int *)(iVar3 + 0x10); + if (*(int *)(local_10 + 0x10) != *(int *)(param_1 + 0x10)) { + if (*(int *)(local_10 + 0x10) < *(int *)(param_1 + 0x10)) goto LAB_004493a6; +LAB_0044937b: + cVar2 = FUN_00449240(&local_10,¶m_1,¶m_1); + goto LAB_00449392; + } + if (*(double *)(local_10 + 0x18) <= *(double *)(param_1 + 0x18)) goto LAB_0044937b; +LAB_004493a6: + } while ((*(int *)(iVar3 + 0xc) != 0) && (iVar3 = *(int *)(iVar3 + 0xc) + -8, iVar3 != 0)); + } + cVar2 = FUN_00449130(¶m_1,¶m_1); +LAB_00449392: + if (cVar2 != '\0') { + *(int *)(iVar1 + 4) = *(int *)(iVar1 + 4) + 1; + } + } + return; +} + + + +// --- FUN_004493d0 at 0x004493D0 (size: 75) --- + +void FUN_004493d0(int param_1,int param_2) + +{ + int iVar1; + char cVar2; + + iVar1 = param_1; + if (param_1 == 0) { + return; + } + if (((param_2 != 0) || (cVar2 = FUN_00449130(¶m_1,¶m_1), cVar2 == '\0')) && + (cVar2 = FUN_00449240(¶m_2,¶m_1,¶m_1), cVar2 == '\0')) { + return; + } + *(int *)(iVar1 + 4) = *(int *)(iVar1 + 4) + 1; + return; +} + + + +// --- FUN_00449420 at 0x00449420 (size: 181) --- + +undefined4 __thiscall +FUN_00449420(int param_1,int *param_2,int param_3,undefined4 param_4,int param_5,int param_6) + +{ + int *piVar1; + int *piVar2; + int iVar3; + LONG LVar4; + uint uVar5; + int *piVar6; + undefined4 *puVar7; + uint local_8; + + local_8 = 0; + if (*(uint *)(param_1 + 0x70) != 0) { + puVar7 = *(undefined4 **)(param_1 + 0x68); + do { + piVar1 = (int *)*puVar7; + uVar5 = 0; + if (piVar1[9] != 0) { + piVar6 = (int *)piVar1[7]; + do { + piVar2 = (int *)*piVar6; + if (((*piVar2 == param_3) && (piVar2[2] == param_5)) && (piVar2[3] == param_6)) { + iVar3 = *param_2; + if (iVar3 != *piVar1) { + LVar4 = InterlockedDecrement((LONG *)(iVar3 + -0x10)); + if ((LVar4 == 0) && ((undefined4 *)(iVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar3 + -0x14))(1); + } + iVar3 = *piVar1; + *param_2 = iVar3; + InterlockedIncrement((LONG *)(iVar3 + -0x10)); + } + return 1; + } + uVar5 = uVar5 + 1; + piVar6 = piVar6 + 1; + } while (uVar5 < (uint)piVar1[9]); + } + local_8 = local_8 + 1; + puVar7 = puVar7 + 1; + } while (local_8 < *(uint *)(param_1 + 0x70)); + } + return 0; +} + + + +// --- FUN_004494e0 at 0x004494E0 (size: 546) --- + +void __fastcall FUN_004494e0(int param_1) + +{ + byte *pbVar1; + uint uVar2; + int iVar3; + bool bVar4; + bool bVar5; + char cVar6; + byte bVar7; + byte bVar8; + undefined1 uVar9; + uint uVar10; + byte bVar11; + int iVar12; + undefined4 *puVar13; + char local_1a; + undefined1 local_19; + undefined1 local_17; + undefined1 local_16; + undefined1 local_15; + uint local_14; + uint local_10; + float local_c; + + puVar13 = (undefined4 *)(param_1 + 0xa8); + for (iVar12 = 0x10e; iVar12 != 0; iVar12 = iVar12 + -1) { + *puVar13 = 0xffffffff; + puVar13 = puVar13 + 1; + } + local_19 = 0; + local_1a = '\0'; + bVar5 = false; + local_17 = 0; + local_16 = 0; + local_15 = 0; + local_c = 1.0; + local_10 = 0; + cVar6 = '\0'; + if (*(int *)(param_1 + 0x80) != 0) { + do { + pbVar1 = *(byte **)(*(int *)(param_1 + 0x78) + local_10 * 4); + iVar12 = *(int *)(pbVar1 + 0xc); + if ((((*pbVar1 & 0x82) != 0) || (iVar12 == 1)) || (iVar12 == 2)) { + local_19 = 1; + } + if ((iVar12 == 1) || (iVar12 == 2)) { + local_1a = '\x01'; + } + if ((iVar12 == 4) || (iVar12 == 5)) { + bVar5 = true; + } + if ((iVar12 == 7) || (iVar12 == 8)) { + local_17 = 1; + } + if (iVar12 == 10) { + local_16 = 1; + } + if ((pbVar1[4] & 3) != 0) { + local_15 = 1; + } + if (*(float *)(pbVar1 + 0x88) < local_c) { + local_c = *(float *)(pbVar1 + 0x88); + } + cVar6 = FUN_00413a70(); + if (cVar6 != '\0') { + local_14 = 0; + do { + uVar10 = *(uint *)(pbVar1 + 8); + bVar7 = (byte)local_14 & 1; + uVar2 = *(uint *)(pbVar1 + 4); + bVar11 = (byte)(local_14 >> 2) & 1; + bVar8 = (byte)(local_14 >> 1) & 1; + bVar4 = true; + if ((uVar2 != 0) && + (((((uVar2 & 1) != 0 && (bVar8 != 1)) || (((uVar2 & 2) != 0 && (bVar11 != 1)))) || + ((((uVar2 & 4) != 0 && (bVar7 != 1)) || ((uVar2 & 8) != 0)))))) { + bVar4 = false; + } + if (((uVar10 == 0) || + ((((uVar10 & 1) == 0 || (bVar8 != 1)) && + ((((uVar10 & 2) == 0 || (bVar11 != 1)) && (((uVar10 & 4) == 0 || (bVar7 != 1)))))))) + && (bVar4)) { + iVar3 = (local_14 + 0x38 + iVar12 * 8) * 3; + uVar10 = 0; + do { + if (*(char *)(iVar3 + param_1 + uVar10) == -1) { + *(undefined1 *)(iVar3 + uVar10 + param_1) = (undefined1)local_10; + break; + } + uVar10 = uVar10 + 1; + } while (uVar10 < 3); + } + local_14 = local_14 + 1; + } while (local_14 < 8); + } + local_10 = local_10 + 1; + cVar6 = local_1a; + } while (local_10 < *(uint *)(param_1 + 0x80)); + } + *(undefined1 *)(param_1 + 0x9d) = local_19; + *(char *)(param_1 + 0x9e) = cVar6; + if ((cVar6 == '\0') || (!bVar5)) { + uVar9 = 0; + } + else { + uVar9 = 1; + } + *(undefined1 *)(param_1 + 0x9f) = uVar9; + *(undefined1 *)(param_1 + 0xa0) = local_17; + *(undefined1 *)(param_1 + 0xa1) = local_16; + *(undefined1 *)(param_1 + 0xa2) = local_15; + *(float *)(param_1 + 0xa4) = local_c; + *(undefined1 *)(param_1 + 0x9c) = 1; + return; +} + + + +// --- FUN_00449710 at 0x00449710 (size: 199) --- + +void __fastcall FUN_00449710(int param_1) + +{ + int iVar1; + undefined4 uVar2; + int *piVar3; + uint uVar4; + uint uVar5; + undefined4 uVar6; + + uVar4 = 0; + if (*(int *)(param_1 + 0x70) != 0) { + do { + iVar1 = *(int *)(*(int *)(param_1 + 0x68) + uVar4 * 4); + if ((*(int *)(iVar1 + 8) == 3000) && (iVar1 = **(int **)(iVar1 + 0x10), iVar1 != DAT_0083a9d8) + ) { + uVar6 = 0; + uVar2 = FUN_004220b0(iVar1,0); + FUN_0041a4e0(uVar2,uVar6); + } + uVar4 = uVar4 + 1; + } while (uVar4 < *(uint *)(param_1 + 0x70)); + } + uVar4 = 0; + if (*(int *)(param_1 + 0x80) != 0) { + do { + piVar3 = (int *)(*(int *)(param_1 + 0x78) + uVar4 * 4); + if ((*piVar3 != 0) && (uVar5 = 0, *(int *)(*piVar3 + 0x24) != 0)) { + do { + iVar1 = *(int *)(*(int *)(*(int *)(*piVar3 + 0x1c) + uVar5 * 4) + 8); + if (iVar1 != DAT_0083a9d8) { + uVar6 = 0; + uVar2 = FUN_004220b0(iVar1,0); + FUN_0041a4e0(uVar2,uVar6); + } + piVar3 = (int *)(*(int *)(param_1 + 0x78) + uVar4 * 4); + uVar5 = uVar5 + 1; + } while (uVar5 < *(uint *)(*(int *)(*(int *)(param_1 + 0x78) + uVar4 * 4) + 0x24)); + } + uVar4 = uVar4 + 1; + } while (uVar4 < *(uint *)(param_1 + 0x80)); + } + return; +} + + + +// --- FUN_004497e0 at 0x004497E0 (size: 155) --- + +undefined4 * __fastcall FUN_004497e0(undefined4 *param_1) + +{ + int iVar1; + undefined4 *puVar2; + + FUN_00415460(DAT_0083a9d8); + *param_1 = &PTR_LAB_0079c0b8; + FUN_00450480(); + param_1[0x1e] = 0; + param_1[0x1f] = 0; + param_1[0x20] = 0; + param_1[0x21] = 0; + param_1[0x22] = 0; + param_1[0x23] = 0; + param_1[0x24] = 0; + param_1[0x25] = 0; + param_1[0x26] = 0; + *(undefined1 *)(param_1 + 0xc) = 0; + *(undefined1 *)(param_1 + 0x27) = 0; + *(undefined1 *)((int)param_1 + 0x9d) = 0; + *(undefined1 *)((int)param_1 + 0x9e) = 0; + *(undefined1 *)((int)param_1 + 0x9f) = 0; + *(undefined1 *)(param_1 + 0x28) = 0; + *(undefined1 *)((int)param_1 + 0xa1) = 0; + *(undefined1 *)((int)param_1 + 0xa2) = 0; + param_1[0x29] = 0x3f800000; + puVar2 = param_1 + 0x2a; + for (iVar1 = 0x10e; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar2 = 0xffffffff; + puVar2 = puVar2 + 1; + } + return param_1; +} + + + +// --- FUN_00449890 at 0x00449890 (size: 169) --- + +undefined1 __fastcall FUN_00449890(int param_1) + +{ + int *piVar1; + undefined4 *puVar2; + char cVar3; + uint uVar4; + undefined1 local_1; + + local_1 = 1; + cVar3 = FUN_00413a70(); + if (cVar3 != '\0') { + uVar4 = 0; + if (*(int *)(param_1 + 0x80) != 0) { + do { + if (*(int *)(*(int *)(param_1 + 0x78) + uVar4 * 4) == 0) { + return 0; + } + cVar3 = FUN_0044a380(); + if (cVar3 == '\0') { + local_1 = 0; + } + uVar4 = uVar4 + 1; + } while (uVar4 < *(uint *)(param_1 + 0x80)); + } + FUN_00407a40(); + uVar4 = 0; + if (*(int *)(param_1 + 0x98) != 0) { + do { + puVar2 = *(undefined4 **)(*(int *)(param_1 + 0x90) + 4 + uVar4 * 8); + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + *(undefined4 *)(*(int *)(param_1 + 0x90) + 4 + uVar4 * 8) = 0; + } + uVar4 = uVar4 + 1; + } while (uVar4 < *(uint *)(param_1 + 0x98)); + } + FUN_005d8570(); + } + return local_1; +} + + + +// --- FUN_00449970 at 0x00449970 (size: 237) --- + +void __fastcall FUN_00449970(int param_1) + +{ + int *piVar1; + void *pvVar2; + undefined4 *puVar3; + int iVar4; + uint uVar5; + + FUN_00449890(); + uVar5 = 0; + if (*(int *)(param_1 + 0x80) != 0) { + do { + pvVar2 = *(void **)(*(int *)(param_1 + 0x78) + uVar5 * 4); + if (pvVar2 != (void *)0x0) { + FUN_0044a8c0(); + operator_delete(pvVar2); + } + uVar5 = uVar5 + 1; + } while (uVar5 < *(uint *)(param_1 + 0x80)); + } + *(undefined4 *)(param_1 + 0x80) = 0; + if ((*(uint *)(param_1 + 0x7c) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)(param_1 + 0x78)); + *(undefined4 *)(param_1 + 0x78) = 0; + *(undefined4 *)(param_1 + 0x7c) = 0; + } + else if (*(int *)(param_1 + 0x78) != 0) { + iVar4 = (*(uint *)(param_1 + 0x7c) & 0x7fffffff) - 1; + while (-1 < iVar4) { + iVar4 = iVar4 + -1; + *(undefined4 *)(*(int *)(param_1 + 0x78) + 4 + iVar4 * 4) = 0; + } + } + (**(code **)(*(int *)(param_1 + 0x38) + 0x3c))(); + FUN_00407a40(); + uVar5 = 0; + if (*(int *)(param_1 + 0x98) != 0) { + do { + puVar3 = *(undefined4 **)(*(int *)(param_1 + 0x90) + 4 + uVar5 * 8); + if (puVar3 != (undefined4 *)0x0) { + piVar1 = puVar3 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar3)(1); + } + *(undefined4 *)(*(int *)(param_1 + 0x90) + 4 + uVar5 * 8) = 0; + } + uVar5 = uVar5 + 1; + } while (uVar5 < *(uint *)(param_1 + 0x98)); + } + FUN_005d8570(); + return; +} + + + +// --- FUN_00449cf0 at 0x00449CF0 (size: 85) --- + +void __fastcall FUN_00449cf0(int param_1) + +{ + int iVar1; + undefined4 *puVar2; + + FUN_00449970(); + *(undefined1 *)(param_1 + 0x30) = 0; + *(undefined1 *)(param_1 + 0x9c) = 0; + *(undefined1 *)(param_1 + 0x9d) = 0; + *(undefined1 *)(param_1 + 0x9e) = 0; + *(undefined1 *)(param_1 + 0x9f) = 0; + *(undefined1 *)(param_1 + 0xa0) = 0; + *(undefined1 *)(param_1 + 0xa1) = 0; + *(undefined1 *)(param_1 + 0xa2) = 0; + *(undefined4 *)(param_1 + 0xa4) = 0x3f800000; + puVar2 = (undefined4 *)(param_1 + 0xa8); + for (iVar1 = 0x10e; iVar1 != 0; iVar1 = iVar1 + -1) { + *puVar2 = 0xffffffff; + puVar2 = puVar2 + 1; + } + return; +} + + + +// --- FUN_00449e50 at 0x00449E50 (size: 127) --- + +void __fastcall FUN_00449e50(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_0079c0b8; + FUN_00449cf0(); + if ((param_1[0x25] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0x24]); + } + if (((param_1[0x22] & 0x80000000) == 0x80000000) && (param_1[0x21] != 0)) { + FUN_00407920(3); + } + if ((param_1[0x1f] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0x1e]); + } + FUN_004505f0(); + FUN_004154b0(); + return; +} + + + +// --- FUN_0044a200 at 0x0044A200 (size: 283) --- + +undefined4 __thiscall +FUN_0044a200(int param_1,undefined4 *param_2,undefined4 param_3,undefined4 *param_4, + undefined4 param_5,undefined4 param_6) + +{ + char *_Str1; + undefined4 *puVar1; + int iVar2; + LONG LVar3; + undefined4 *puVar4; + uint uVar5; + char *pcVar6; + + _Str1 = (char *)*param_2; + InterlockedIncrement((LONG *)(_Str1 + -0x10)); + if ((*(int *)(_Str1 + -4) != 0) && (*_Str1 == '$')) { + pcVar6 = _Str1; + FUN_00401280(1); + *pcVar6 = '$'; + pcVar6[1] = '\0'; + FUN_00435720(1,0,pcVar6); + uVar5 = 0; + if (*(int *)(param_1 + 0x70) != 0) { + do { + puVar1 = *(undefined4 **)(*(int *)(param_1 + 0x68) + uVar5 * 4); + iVar2 = _stricmp(_Str1,(char *)*puVar1); + if ((iVar2 == 0) && (param_4 == (undefined4 *)puVar1[2])) { + puVar4 = (undefined4 *)FUN_005df0f5(0x10); + *puVar4 = param_3; + puVar4[1] = param_4; + puVar4[2] = param_5; + puVar4[3] = param_6; + param_4 = puVar4; + FUN_0044a770(¶m_4,puVar1[9]); + LVar3 = InterlockedDecrement((LONG *)(_Str1 + -0x10)); + if ((LVar3 == 0) && (_Str1 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(_Str1 + -0x14))(1); + } + return 1; + } + uVar5 = uVar5 + 1; + } while (uVar5 < *(uint *)(param_1 + 0x70)); + } + } + LVar3 = InterlockedDecrement((LONG *)(_Str1 + -0x10)); + if ((LVar3 == 0) && (_Str1 + -0x14 != (char *)0x0)) { + (*(code *)**(undefined4 **)(_Str1 + -0x14))(1); + } + return 0; +} + + + +// --- FUN_0044a320 at 0x0044A320 (size: 30) --- + +void * __thiscall FUN_0044a320(void *param_1,byte param_2) + +{ + FUN_00449e50(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0044a340 at 0x0044A340 (size: 49) --- + +undefined4 __fastcall FUN_0044a340(int param_1) + +{ + undefined1 uVar1; + char cVar2; + uint uVar3; + undefined1 uVar4; + uint uVar5; + + uVar5 = 0; + uVar4 = 1; + uVar3 = 0; + uVar1 = 1; + if (*(int *)(param_1 + 0x24) != 0) { + do { + uVar4 = uVar1; + cVar2 = FUN_00448460(); + if (cVar2 == '\0') { + uVar4 = 0; + } + uVar3 = *(uint *)(param_1 + 0x24); + uVar5 = uVar5 + 1; + uVar1 = uVar4; + } while (uVar5 < uVar3); + } + return CONCAT31((int3)(uVar3 >> 8),uVar4); +} + + + +// --- FUN_0044a380 at 0x0044A380 (size: 47) --- + +undefined4 __fastcall FUN_0044a380(int param_1) + +{ + undefined1 uVar1; + char cVar2; + uint uVar3; + undefined1 uVar4; + uint uVar5; + + uVar5 = 0; + uVar4 = 1; + uVar3 = 0; + uVar1 = 1; + if (*(int *)(param_1 + 0x24) != 0) { + do { + uVar4 = uVar1; + cVar2 = FUN_00447f60(); + if (cVar2 == '\0') { + uVar4 = 0; + } + uVar3 = *(uint *)(param_1 + 0x24); + uVar5 = uVar5 + 1; + uVar1 = uVar4; + } while (uVar5 < uVar3); + } + return CONCAT31((int3)(uVar3 >> 8),uVar4); +} + + + +// --- FUN_0044a3f0 at 0x0044A3F0 (size: 87) --- + +void __fastcall FUN_0044a3f0(int param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + FUN_00406f90(); + FUN_00406f90(); + puVar2 = (undefined4 *)(*(int *)(param_1 + 8) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)(param_1 + 8) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(*(int *)(param_1 + 4) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)(param_1 + 4) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return; +} + + + +// --- FUN_0044a450 at 0x0044A450 (size: 151) --- + +undefined4 * __thiscall FUN_0044a450(undefined4 *param_1,undefined4 *param_2) + +{ + int iVar1; + LONG LVar2; + + *param_1 = *param_2; + iVar1 = param_1[1]; + if (iVar1 != param_2[1]) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = param_2[1]; + param_1[1] = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + iVar1 = param_1[2]; + if (iVar1 != param_2[2]) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = param_2[2]; + param_1[2] = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + FUN_004070d0(param_2 + 3); + FUN_004070d0(param_2 + 6); + return param_1; +} + + + +// --- FUN_0044a4f0 at 0x0044A4F0 (size: 270) --- + +void __fastcall FUN_0044a4f0(int param_1) + +{ + void *pvVar1; + int iVar2; + uint uVar3; + + uVar3 = 0; + if (*(int *)(param_1 + 0x24) != 0) { + do { + FUN_00447f60(); + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 0x24)); + } + uVar3 = 0; + if (*(int *)(param_1 + 0x24) != 0) { + do { + pvVar1 = *(void **)(*(int *)(param_1 + 0x1c) + uVar3 * 4); + if (pvVar1 != (void *)0x0) { + FUN_00448390(); + operator_delete(pvVar1); + } + *(undefined4 *)(*(int *)(param_1 + 0x1c) + uVar3 * 4) = 0; + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 0x24)); + } + *(undefined4 *)(param_1 + 0x24) = 0; + if ((*(uint *)(param_1 + 0x20) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)(param_1 + 0x1c)); + *(undefined4 *)(param_1 + 0x1c) = 0; + *(undefined4 *)(param_1 + 0x20) = 0; + } + else if (*(int *)(param_1 + 0x1c) != 0) { + iVar2 = (*(uint *)(param_1 + 0x20) & 0x7fffffff) - 1; + while (-1 < iVar2) { + iVar2 = iVar2 + -1; + *(undefined4 *)(*(int *)(param_1 + 0x1c) + 4 + iVar2 * 4) = 0; + } + } + uVar3 = 0; + if (*(int *)(param_1 + 0x30) != 0) { + do { + operator_delete(*(void **)(*(int *)(param_1 + 0x28) + uVar3 * 4)); + *(undefined4 *)(*(int *)(param_1 + 0x28) + uVar3 * 4) = 0; + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 0x30)); + } + *(undefined4 *)(param_1 + 0x30) = 0; + if ((*(uint *)(param_1 + 0x2c) & 0x80000000) != 0x80000000) { + if (*(int *)(param_1 + 0x28) != 0) { + iVar2 = (*(uint *)(param_1 + 0x2c) & 0x7fffffff) - 1; + while (-1 < iVar2) { + iVar2 = iVar2 + -1; + *(undefined4 *)(*(int *)(param_1 + 0x28) + 4 + iVar2 * 4) = 0; + } + } + return; + } + operator_delete__(*(void **)(param_1 + 0x28)); + *(undefined4 *)(param_1 + 0x28) = 0; + *(undefined4 *)(param_1 + 0x2c) = 0; + return; +} + + + +// --- FUN_0044a600 at 0x0044A600 (size: 184) --- + +void * __thiscall FUN_0044a600(void *param_1,byte param_2) + +{ + LONG LVar1; + undefined4 *puVar2; + int iVar3; + int local_4; + + if ((param_2 & 2) == 0) { + FUN_0044a3f0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; + } + local_4 = *(int *)((int)param_1 + -4); + if (-1 < local_4 + -1) { + iVar3 = (int)param_1 + local_4 * 0x24 + 0xc; + do { + FUN_00406f90(); + FUN_00406f90(); + puVar2 = (undefined4 *)(*(int *)(iVar3 + -0x28) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)(iVar3 + -0x28) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(*(int *)(iVar3 + -0x2c) + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*(int *)(iVar3 + -0x2c) + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + local_4 = local_4 + -1; + iVar3 = iVar3 + -0x24; + } while (local_4 != 0); + } + if ((param_2 & 1) != 0) { + operator_delete__((void *)((int)param_1 + -4)); + } + return (void *)((int)param_1 + -4); +} + + + +// --- FUN_0044a6c0 at 0x0044A6C0 (size: 169) --- + +void __fastcall FUN_0044a6c0(int *param_1) + +{ + uint uVar1; + undefined1 local_24 [4]; + undefined *local_20; + undefined *local_1c; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) != 0x80000000) { + if ((*param_1 != 0) && (uVar1 = param_1[1] & 0x7fffffff, -1 < (int)(uVar1 - 1))) { + do { + local_20 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + local_1c = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + FUN_00406d60(); + FUN_00406d60(); + FUN_0044a450(local_24); + FUN_0044a3f0(); + uVar1 = uVar1 - 1; + } while (uVar1 != 0); + } + return; + } + if (*param_1 != 0) { + FUN_0044a600(3); + } + *param_1 = 0; + param_1[1] = 0; + return; +} + + + +// --- FUN_0044a770 at 0x0044A770 (size: 108) --- + +uint __thiscall FUN_0044a770(int *param_1,undefined4 *param_2,uint param_3) + +{ + int iVar1; + uint in_EAX; + undefined4 uVar2; + undefined4 *puVar3; + + if ((uint)param_1[2] < param_3) { +LAB_0044a7d5: + return in_EAX & 0xffffff00; + } + if ((param_1[1] & 0x7fffffffU) <= (uint)param_1[2]) { + uVar2 = FUN_00453850((param_1[1] & 0x7fffffffU) + 1); + in_EAX = FUN_004180a0(uVar2); + if ((char)in_EAX == '\0') goto LAB_0044a7d5; + } + if (param_1[2] != 0) { + iVar1 = *param_1; + for (puVar3 = (undefined4 *)(iVar1 + -4 + param_1[2] * 4); + (undefined4 *)(iVar1 + param_3 * 4) <= puVar3; puVar3 = puVar3 + -1) { + puVar3[1] = *puVar3; + } + } + iVar1 = *param_1; + *(undefined4 *)(iVar1 + param_3 * 4) = *param_2; + param_1[2] = param_1[2] + 1; + return CONCAT31((int3)((uint)iVar1 >> 8),1); +} + + + +// --- FUN_0044a7e0 at 0x0044A7E0 (size: 213) --- + +undefined4 __thiscall FUN_0044a7e0(int *param_1,uint param_2) + +{ + uint *puVar1; + uint uVar2; + uint *puVar3; + int iVar4; + + uVar2 = param_2; + if ((uint)param_1[2] <= param_2) { + if (param_2 <= (param_1[1] & 0x7fffffffU)) { + return 1; + } + if (param_2 == 0) { + FUN_0044a6c0(); + return 1; + } + puVar3 = (uint *)thunk_FUN_005df0f5(param_2 * 0x24 + 4); + if (puVar3 != (uint *)0x0) { + puVar1 = puVar3 + 1; + *puVar3 = param_2; + FUN_00401000(puVar1,0x24,param_2,&LAB_0044a3b0); + if (puVar1 != (uint *)0x0) { + if (*param_1 != 0) { + param_2 = param_1[2]; + if (-1 < (int)(param_2 + -1)) { + iVar4 = (param_2 + -1) * 0x24; + do { + FUN_0044a450(*param_1 + iVar4); + iVar4 = iVar4 + -0x24; + param_2 = param_2 + -1; + } while (param_2 != 0); + } + if (((param_1[1] & 0x80000000U) == 0x80000000) && (*param_1 != 0)) { + FUN_0044a600(3); + } + } + *param_1 = (int)puVar1; + param_1[1] = uVar2 | 0x80000000; + return 1; + } + } + } + return 0; +} + + + +// --- FUN_0044a8c0 at 0x0044A8C0 (size: 97) --- + +void __fastcall FUN_0044a8c0(int param_1) + +{ + FUN_0044a4f0(); + if ((*(uint *)(param_1 + 0x2c) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)(param_1 + 0x28)); + } + if ((*(uint *)(param_1 + 0x20) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)(param_1 + 0x1c)); + } + if (((*(uint *)(param_1 + 0x14) & 0x80000000) == 0x80000000) && (*(int *)(param_1 + 0x10) != 0)) { + FUN_0044a600(3); + } + return; +} + + + +// --- FUN_0044a930 at 0x0044A930 (size: 269) --- + +void __fastcall FUN_0044a930(undefined4 *param_1) + +{ + undefined4 uVar1; + undefined4 *puVar2; + + *param_1 = 0; + param_1[1] = 0; + param_1[2] = 0; + param_1[3] = 0; + FUN_0044a6c0(); + param_1[0xd] = 2; + param_1[0x12] = 2; + param_1[0xe] = 1; + param_1[0xf] = 1; + param_1[0x10] = 4; + *(undefined1 *)(param_1 + 0x11) = 1; + *(undefined1 *)(param_1 + 0x13) = 0; + puVar2 = (undefined4 *)FUN_005b2280(0x3f666666); + param_1[0x14] = *puVar2; + param_1[0x15] = puVar2[1]; + param_1[0x16] = puVar2[2]; + param_1[0x17] = puVar2[3]; + param_1[0x18] = puVar2[4]; + param_1[0x19] = puVar2[5]; + param_1[0x1a] = puVar2[6]; + param_1[0x1b] = puVar2[7]; + param_1[0x1c] = puVar2[8]; + param_1[0x1d] = puVar2[9]; + param_1[0x1e] = puVar2[10]; + param_1[0x1f] = DAT_00819228; + param_1[0x20] = DAT_0081922c; + param_1[0x21] = DAT_00819230; + param_1[0x22] = DAT_00819234; + param_1[0x23] = DAT_00819228; + param_1[0x24] = DAT_0081922c; + param_1[0x25] = DAT_00819230; + uVar1 = DAT_00819234; + param_1[0x28] = 0; + param_1[0x26] = uVar1; + param_1[0x32] = DAT_00819228; + param_1[0x33] = DAT_0081922c; + param_1[0x34] = DAT_00819230; + param_1[0x35] = DAT_00819234; + return; +} + + + +// --- FUN_0044aa40 at 0x0044AA40 (size: 62) --- + +int __fastcall FUN_0044aa40(int param_1) + +{ + *(undefined4 *)(param_1 + 0x10) = 0; + *(undefined4 *)(param_1 + 0x14) = 0; + *(undefined4 *)(param_1 + 0x18) = 0; + *(undefined4 *)(param_1 + 0x1c) = 0; + *(undefined4 *)(param_1 + 0x20) = 0; + *(undefined4 *)(param_1 + 0x24) = 0; + *(undefined4 *)(param_1 + 0x28) = 0; + *(undefined4 *)(param_1 + 0x2c) = 0; + *(undefined4 *)(param_1 + 0x30) = 0; + FUN_005b2250(); + FUN_005b2250(); + FUN_0044a930(); + return param_1; +} + + + +// --- FUN_0044aa80 at 0x0044AA80 (size: 1233) --- + +undefined4 __thiscall FUN_0044aa80(undefined4 *param_1,undefined4 param_2,undefined4 *param_3) + +{ + int *piVar1; + int iVar2; + char cVar3; + undefined4 uVar4; + LONG LVar5; + undefined4 *puVar6; + uint uVar7; + int iVar8; + uint uVar9; + int *piVar10; + uint uVar11; + uint local_20; + uint uStack_1c; + undefined1 auStack_18 [12]; + undefined1 auStack_c [12]; + + FUN_0044a4f0(); + *param_3 = *param_1; + param_3[1] = param_1[1]; + param_3[2] = param_1[2]; + param_3[3] = param_1[3]; + FUN_0044a6c0(); + if ((char)param_2 == '\0') { + iVar8 = 0; + local_20 = 0; + if (param_1[6] != 0) { + do { + if ((uint)param_3[6] < (param_3[5] & 0x7fffffff)) { +LAB_0044ab2b: + param_3[6] = param_3[6] + 1; + } + else { + uVar4 = FUN_00453850((param_3[5] & 0x7fffffff) + 1); + cVar3 = FUN_0044a7e0(uVar4); + if (cVar3 != '\0') goto LAB_0044ab2b; + } + *(undefined4 *)(iVar8 + param_3[4]) = *(undefined4 *)(iVar8 + param_1[4]); + piVar10 = (int *)(param_1[4] + 4 + iVar8); + piVar1 = (int *)(param_3[4] + 4 + iVar8); + iVar2 = *piVar1; + if (iVar2 != *piVar10) { + LVar5 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar2 = *piVar10; + *piVar1 = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + } + piVar10 = (int *)(param_1[4] + 8 + iVar8); + piVar1 = (int *)(param_3[4] + 8 + iVar8); + iVar2 = *piVar1; + if (iVar2 != *piVar10) { + LVar5 = InterlockedDecrement((LONG *)(iVar2 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(iVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar2 + -0x14))(1); + } + iVar2 = *piVar10; + *piVar1 = iVar2; + InterlockedIncrement((LONG *)(iVar2 + -0x10)); + } + uVar4 = FUN_004073f0(auStack_18); + FUN_004070d0(uVar4); + FUN_00406f90(); + uVar4 = FUN_004073f0(auStack_c); + FUN_004070d0(uVar4); + FUN_00406f90(); + local_20 = local_20 + 1; + iVar8 = iVar8 + 0x24; + } while (local_20 < (uint)param_1[6]); + } + } + param_3[0xd] = param_1[0xd]; + param_3[0xe] = param_1[0xe]; + param_3[0xf] = param_1[0xf]; + param_3[0x10] = param_1[0x10]; + *(undefined1 *)(param_3 + 0x11) = *(undefined1 *)(param_1 + 0x11); + param_3[0x12] = param_1[0x12]; + *(undefined1 *)(param_3 + 0x13) = *(undefined1 *)(param_1 + 0x13); + param_3[0x14] = param_1[0x14]; + param_3[0x15] = param_1[0x15]; + param_3[0x16] = param_1[0x16]; + param_3[0x17] = param_1[0x17]; + param_3[0x18] = param_1[0x18]; + param_3[0x19] = param_1[0x19]; + param_3[0x1a] = param_1[0x1a]; + param_3[0x1b] = param_1[0x1b]; + param_3[0x1c] = param_1[0x1c]; + param_3[0x1d] = param_1[0x1d]; + param_3[0x1e] = param_1[0x1e]; + param_3[0x1f] = param_1[0x1f]; + param_3[0x20] = param_1[0x20]; + param_3[0x21] = param_1[0x21]; + param_3[0x22] = param_1[0x22]; + param_3[0x23] = param_1[0x23]; + param_3[0x24] = param_1[0x24]; + param_3[0x25] = param_1[0x25]; + param_3[0x26] = param_1[0x26]; + param_3[0x27] = param_1[0x27]; + param_3[0x28] = param_1[0x28]; + param_3[0x29] = param_1[0x29]; + param_3[0x2a] = param_1[0x2a]; + param_3[0x2b] = param_1[0x2b]; + param_3[0x2c] = param_1[0x2c]; + param_3[0x2d] = param_1[0x2d]; + param_3[0x2e] = param_1[0x2e]; + param_3[0x2f] = param_1[0x2f]; + param_3[0x30] = param_1[0x30]; + param_3[0x31] = param_1[0x31]; + param_3[0x32] = param_1[0x32]; + param_3[0x33] = param_1[0x33]; + param_3[0x34] = param_1[0x34]; + param_3[0x35] = param_1[0x35]; + FUN_0044dcb0(); + uVar9 = 0; + if (param_1[9] != 0) { + do { + uVar4 = param_3[9]; + local_20 = FUN_004483f0(param_2); + FUN_0044a770(&local_20,uVar4); + uVar9 = uVar9 + 1; + } while (uVar9 < (uint)param_1[9]); + } + piVar10 = param_3 + 10; + param_3[0xc] = 0; + if ((param_3[0xb] & 0x80000000) == 0x80000000) { + operator_delete__((void *)*piVar10); + *piVar10 = 0; + param_3[0xb] = 0; + } + else if (*piVar10 != 0) { + iVar8 = (param_3[0xb] & 0x7fffffff) - 1; + while (-1 < iVar8) { + iVar8 = iVar8 + -1; + *(undefined4 *)(*piVar10 + 4 + iVar8 * 4) = 0; + } + } + local_20 = 0; + if (param_1[0xc] != 0) { + do { + uVar9 = param_3[0xc]; + uVar4 = (**(code **)(**(int **)(param_1[10] + local_20 * 4) + 0x10))(); + if (uVar9 <= (uint)param_3[0xc]) { + if ((param_3[0xb] & 0x7fffffff) <= (uint)param_3[0xc]) { + uVar7 = (param_3[0xb] & 0x7fffffff) + 1; + if (uVar7 < 9) { + uVar7 = 8; + } + else if (uVar7 < 0x4001) { + iVar8 = 0x1f; + if (uVar7 != 0) { + for (; uVar7 >> iVar8 == 0; iVar8 = iVar8 + -1) { + } + } + uVar11 = 1 << ((byte)iVar8 & 0x1f); + uStack_1c = uVar7; + if (uVar11 < uVar7) { + uVar7 = uVar11 * 2; + } + } + else if ((uVar7 & 0x3fff) != 0) { + uVar7 = uVar7 + (0x4000 - (uVar7 & 0x3fff)); + } + cVar3 = FUN_004180a0(uVar7); + if (cVar3 == '\0') goto LAB_0044af34; + } + if (param_3[0xc] != 0) { + iVar8 = param_3[10]; + for (puVar6 = (undefined4 *)(iVar8 + -4 + param_3[0xc] * 4); + (undefined4 *)(iVar8 + uVar9 * 4) <= puVar6; puVar6 = puVar6 + -1) { + puVar6[1] = *puVar6; + } + } + *(undefined4 *)(param_3[10] + uVar9 * 4) = uVar4; + param_3[0xc] = param_3[0xc] + 1; + } +LAB_0044af34: + local_20 = local_20 + 1; + } while (local_20 < (uint)param_1[0xc]); + } + return 1; +} + + + +// --- FUN_0044af60 at 0x0044AF60 (size: 1661) --- + +void __thiscall FUN_0044af60(undefined4 *param_1,int param_2) + +{ + char cVar1; + undefined4 *puVar2; + int *piVar3; + undefined4 uVar4; + uint *puVar5; + uint uVar6; + undefined1 *puVar7; + byte *pbVar8; + char *pcVar9; + byte bVar10; + int iVar11; + uint uVar12; + undefined4 *puVar13; + int iVar14; + uint uVar15; + undefined4 uVar16; + uint local_c; + uint local_8; + uint uStack_4; + + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *param_1 = *puVar2; + } + else { + *puVar2 = *param_1; + } + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + param_1[1] = *puVar2; + } + else { + *puVar2 = param_1[1]; + } + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + param_1[2] = *puVar2; + } + else { + *puVar2 = param_1[2]; + } + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + param_1[3] = *puVar2; + } + else { + *puVar2 = param_1[3]; + } + } + iVar11 = param_1[6]; + FUN_0040ad10(4); + piVar3 = (int *)FUN_0040acf0(4); + if (piVar3 != (int *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + iVar11 = *piVar3; + } + else { + *piVar3 = iVar11; + } + } + if (iVar11 != 0) { + iVar14 = 0; + do { + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + if ((param_1[5] & 0x7fffffff) <= (uint)param_1[6]) { + uVar4 = FUN_00453850((param_1[5] & 0x7fffffff) + 1); + cVar1 = FUN_0044a7e0(uVar4); + if (cVar1 == '\0') goto LAB_0044b0bc; + } + param_1[6] = param_1[6] + 1; + } +LAB_0044b0bc: + puVar13 = (undefined4 *)(param_1[4] + iVar14); + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *puVar13 = *puVar2; + } + else { + *puVar2 = *puVar13; + } + } + FUN_00444900(puVar13 + 3,param_2); + FUN_00444900(puVar13 + 6,param_2); + iVar14 = iVar14 + 0x24; + iVar11 = iVar11 + -1; + } while (iVar11 != 0); + } + uVar12 = param_1[9]; + FUN_0040ad10(4); + puVar5 = (uint *)FUN_0040acf0(4); + if (puVar5 != (uint *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + uVar12 = *puVar5; + } + else { + *puVar5 = uVar12; + } + } + uVar15 = 0; + if (uVar12 != 0) { + do { + if ((~*(byte *)(param_2 + 4) & 1) == 0) { + uVar6 = *(uint *)(param_1[7] + uVar15 * 4); + } + else { + iVar11 = FUN_005df0f5(0x48); + if (iVar11 == 0) { + uVar6 = 0; + } + else { + uVar6 = FUN_00448350(); + } + } + FUN_004484e0(param_2); + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + local_8 = uVar6; + FUN_0044a770(&local_8,param_1[9]); + } + uVar15 = uVar15 + 1; + } while (uVar15 < uVar12); + } + uVar12 = param_1[0xc]; + local_8 = uVar12; + FUN_0040ad10(4); + puVar5 = (uint *)FUN_0040acf0(4); + if (puVar5 != (uint *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + uVar12 = *puVar5; + local_8 = uVar12; + } + else { + *puVar5 = uVar12; + } + } + local_c = 0; + if (uVar12 != 0) { + do { + if ((~*(byte *)(param_2 + 4) & 1) == 0) { + piVar3 = *(int **)(param_1[10] + local_c * 4); + } + else { + uVar16 = 1; + uVar4 = FUN_0040a8d0(1); + puVar7 = (undefined1 *)FUN_0040ac70(uVar4,uVar16); + switch(*puVar7) { + case 1: + iVar11 = FUN_005df0f5(0x60); + if (iVar11 == 0) { +LAB_0044b288: + piVar3 = (int *)0x0; + } + else { + piVar3 = (int *)FUN_004507e0(); + } + break; + case 2: + iVar11 = FUN_005df0f5(0x34); + if (iVar11 == 0) goto LAB_0044b288; + piVar3 = (int *)FUN_004508b0(); + break; + case 3: + iVar11 = FUN_005df0f5(0x60); + if (iVar11 == 0) goto LAB_0044b288; + piVar3 = (int *)FUN_00450950(); + break; + case 4: + iVar11 = FUN_005df0f5(0x48); + if (iVar11 == 0) goto LAB_0044b288; + piVar3 = (int *)FUN_00450ac0(); + break; + default: + goto switchD_0044b236_default; + } + } + (**(code **)(*piVar3 + 0x1c))(param_2); + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + uVar12 = param_1[0xc]; + if (uVar12 <= (uint)param_1[0xc]) { + if ((param_1[0xb] & 0x7fffffff) <= (uint)param_1[0xc]) { + uVar15 = (param_1[0xb] & 0x7fffffff) + 1; + if (uVar15 < 9) { + uVar15 = 8; + } + else if (uVar15 < 0x4001) { + iVar11 = 0x1f; + if (uVar15 != 0) { + for (; uVar15 >> iVar11 == 0; iVar11 = iVar11 + -1) { + } + } + uVar6 = 1 << ((byte)iVar11 & 0x1f); + uStack_4 = uVar15; + if (uVar6 < uVar15) { + uVar15 = uVar6 * 2; + } + } + else if ((uVar15 & 0x3fff) != 0) { + uVar15 = uVar15 + (0x4000 - (uVar15 & 0x3fff)); + } + cVar1 = FUN_004180a0(uVar15); + if (cVar1 == '\0') goto LAB_0044b36b; + } + if (param_1[0xc] != 0) { + iVar11 = param_1[10]; + for (puVar2 = (undefined4 *)(iVar11 + -4 + param_1[0xc] * 4); + (undefined4 *)(iVar11 + uVar12 * 4) <= puVar2; puVar2 = puVar2 + -1) { + puVar2[1] = *puVar2; + } + } + *(int **)(param_1[10] + uVar12 * 4) = piVar3; + param_1[0xc] = param_1[0xc] + 1; + } + } +LAB_0044b36b: + local_c = local_c + 1; + } while (local_c < local_8); + } + bVar10 = *(byte *)(param_1 + 0xd); + FUN_0040ad10(1); + pbVar8 = (byte *)FUN_0040acf0(1); + if (pbVar8 != (byte *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + bVar10 = *pbVar8; + } + else { + *pbVar8 = bVar10; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + param_1[0xd] = (uint)bVar10; + } + bVar10 = *(byte *)(param_1 + 0xe); + FUN_0040ad10(1); + pbVar8 = (byte *)FUN_0040acf0(1); + if (pbVar8 != (byte *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + bVar10 = *pbVar8; + } + else { + *pbVar8 = bVar10; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + param_1[0xe] = (uint)bVar10; + } + bVar10 = *(byte *)(param_1 + 0xf); + FUN_0040ad10(1); + pbVar8 = (byte *)FUN_0040acf0(1); + if (pbVar8 != (byte *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + bVar10 = *pbVar8; + } + else { + *pbVar8 = bVar10; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + param_1[0xf] = (uint)bVar10; + } + bVar10 = *(byte *)(param_1 + 0x10); + FUN_0040ad10(1); + pbVar8 = (byte *)FUN_0040acf0(1); + if (pbVar8 != (byte *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + bVar10 = *pbVar8; + } + else { + *pbVar8 = bVar10; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + param_1[0x10] = (uint)bVar10; + } + cVar1 = *(char *)(param_1 + 0x11); + FUN_0040ad10(1); + pcVar9 = (char *)FUN_0040acf0(1); + if (pcVar9 != (char *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + cVar1 = *pcVar9; + } + else { + *pcVar9 = cVar1; + } + } + if ((((*(byte *)(param_2 + 4) & 5) == 0) && (cVar1 != '\0')) && (cVar1 != '\x01')) { + FUN_0040aa50(); + } + *(bool *)(param_1 + 0x11) = cVar1 != '\0'; + bVar10 = *(byte *)(param_1 + 0x12); + FUN_0040ad10(1); + pbVar8 = (byte *)FUN_0040acf0(1); + if (pbVar8 != (byte *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + bVar10 = *pbVar8; + } + else { + *pbVar8 = bVar10; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + param_1[0x12] = (uint)bVar10; + } + cVar1 = *(char *)(param_1 + 0x13); + FUN_0040ad10(1); + pcVar9 = (char *)FUN_0040acf0(1); + if (pcVar9 != (char *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + cVar1 = *pcVar9; + } + else { + *pcVar9 = cVar1; + } + } + if ((((*(byte *)(param_2 + 4) & 5) == 0) && (cVar1 != '\0')) && (cVar1 != '\x01')) { + FUN_0040aa50(); + } + *(bool *)(param_1 + 0x13) = cVar1 != '\0'; + FUN_005b22c0(param_2); + FUN_0065c3f0(param_2); + FUN_0065c3f0(param_2); + FUN_005b22c0(param_2); + FUN_0065c3f0(param_2); +switchD_0044b236_default: + return; +} + + + +// --- FUN_0044b5f0 at 0x0044B5F0 (size: 109) --- + +uint FUN_0044b5f0(undefined4 param_1) + +{ + char cVar1; + uint uVar2; + + uVar2 = FUN_005df0f5(0xd8); + if (uVar2 != 0) { + *(undefined4 *)(uVar2 + 0x10) = 0; + *(undefined4 *)(uVar2 + 0x14) = 0; + *(undefined4 *)(uVar2 + 0x18) = 0; + *(undefined4 *)(uVar2 + 0x1c) = 0; + *(undefined4 *)(uVar2 + 0x20) = 0; + *(undefined4 *)(uVar2 + 0x24) = 0; + *(undefined4 *)(uVar2 + 0x28) = 0; + *(undefined4 *)(uVar2 + 0x2c) = 0; + *(undefined4 *)(uVar2 + 0x30) = 0; + FUN_005b2250(); + FUN_005b2250(); + FUN_0044a930(); + cVar1 = FUN_0044aa80(param_1,uVar2); + return -(uint)(cVar1 != '\0') & uVar2; + } + return 0; +} + + + +// --- FUN_0044b660 at 0x0044B660 (size: 29) --- + +void FUN_0044b660(undefined4 param_1) + +{ + undefined4 uVar1; + + uVar1 = FUN_004220b0(param_1,0x2e); + FUN_00415430(uVar1); + return; +} + + + +// --- FUN_0044b680 at 0x0044B680 (size: 62) --- + +undefined4 FUN_0044b680(undefined4 param_1) + +{ + int iVar1; + undefined4 uVar2; + + iVar1 = FUN_0041c280(param_1); + if (iVar1 == 0x2e) { + uVar2 = 0x2e; + } + else { + if (iVar1 != 0x2f) { + return 0; + } + uVar2 = 0x2f; + } + uVar2 = FUN_004220b0(param_1,uVar2); + uVar2 = FUN_00415430(uVar2); + return uVar2; +} + + + +// --- FUN_0044b6c0 at 0x0044B6C0 (size: 117) --- + +void __fastcall FUN_0044b6c0(int *param_1) + +{ + int iVar1; + undefined4 *puVar2; + int iVar3; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) == 0x80000000) { + if (*param_1 != 0) { + operator_delete__((void *)(*param_1 + -4)); + } + *param_1 = 0; + param_1[1] = 0; + return; + } + if ((*param_1 != 0) && (iVar3 = (param_1[1] & 0x7fffffffU) - 1, -1 < iVar3)) { + puVar2 = (undefined4 *)FUN_0050a140(); + do { + iVar3 = iVar3 + -1; + iVar1 = *param_1; + *(undefined4 *)(iVar1 + 8 + iVar3 * 8) = *puVar2; + *(undefined4 *)(iVar1 + 0xc + iVar3 * 8) = puVar2[1]; + } while (-1 < iVar3); + } + return; +} + + + +// --- FUN_0044b740 at 0x0044B740 (size: 193) --- + +undefined4 __thiscall FUN_0044b740(int *param_1,uint param_2) + +{ + uint *puVar1; + int iVar2; + uint *puVar3; + int iVar4; + + if ((uint)param_1[2] <= param_2) { + if (param_2 <= (param_1[1] & 0x7fffffffU)) { + return 1; + } + if (param_2 == 0) { + FUN_0044b6c0(); + return 1; + } + puVar3 = (uint *)thunk_FUN_005df0f5(param_2 * 8 + 4); + if (puVar3 != (uint *)0x0) { + puVar1 = puVar3 + 1; + *puVar3 = param_2; + FUN_00401000(puVar1,8,param_2,FUN_0050a140); + if (puVar1 != (uint *)0x0) { + if (*param_1 != 0) { + iVar4 = param_1[2] + -1; + while (-1 < iVar4) { + iVar4 = iVar4 + -1; + iVar2 = *param_1; + puVar3[iVar4 * 2 + 3] = *(uint *)(iVar2 + 8 + iVar4 * 8); + puVar3[iVar4 * 2 + 4] = *(uint *)(iVar2 + 0xc + iVar4 * 8); + } + if (((param_1[1] & 0x80000000U) == 0x80000000) && (*param_1 != 0)) { + operator_delete__((void *)(*param_1 + -4)); + } + } + *param_1 = (int)puVar1; + param_1[1] = param_2 | 0x80000000; + return 1; + } + } + } + return 0; +} + + + +// --- FUN_0044b810 at 0x0044B810 (size: 13) --- + +undefined1 FUN_0044b810(void) + +{ + FUN_0044b6c0(); + return 1; +} + + + +// --- FUN_0044b820 at 0x0044B820 (size: 68) --- + +void FUN_0044b820(void) + +{ + int *piVar1; + uint uVar2; + + uVar2 = 0; + if (DAT_0083b1d8 != 0) { + do { + piVar1 = *(int **)(DAT_0083b1d0 + 4 + uVar2 * 8); + if (piVar1 != (int *)0x0) { + (**(code **)(*piVar1 + 0x14))(); + *(undefined4 *)(DAT_0083b1d0 + 4 + uVar2 * 8) = 0; + } + uVar2 = uVar2 + 1; + } while (uVar2 < DAT_0083b1d8); + } + FUN_0044b6c0(); + return; +} + + + +// --- FUN_0044b870 at 0x0044B870 (size: 211) --- + +int FUN_0044b870(int param_1) + +{ + char cVar1; + uint uVar2; + int iVar3; + undefined4 uVar4; + + if (param_1 == DAT_0083b1cc) { + return 0; + } + uVar2 = 0; + if (DAT_0083b1d8 != 0) { + do { + if (*(int *)(DAT_0083b1d0 + uVar2 * 8) == param_1) { + return *(int *)(DAT_0083b1d0 + 4 + uVar2 * 8); + } + uVar2 = uVar2 + 1; + } while (uVar2 < DAT_0083b1d8); + } + iVar3 = FUN_0041c280(param_1); + if (iVar3 == 0x2e) { + uVar4 = 0x2e; + } + else { + if (iVar3 != 0x2f) { + return 0; + } + uVar4 = 0x2f; + } + uVar4 = FUN_004220b0(param_1,uVar4); + iVar3 = FUN_00415430(uVar4); + if (iVar3 != 0) { + if ((DAT_0083b1d4 & 0x7fffffff) <= DAT_0083b1d8) { + uVar4 = FUN_00453850((DAT_0083b1d4 & 0x7fffffff) + 1); + cVar1 = FUN_0044b740(uVar4); + if (cVar1 == '\0') { + return iVar3; + } + } + *(int *)(DAT_0083b1d0 + DAT_0083b1d8 * 8) = param_1; + *(int *)(DAT_0083b1d0 + 4 + DAT_0083b1d8 * 8) = iVar3; + DAT_0083b1d8 = DAT_0083b1d8 + 1; + return iVar3; + } + return 0; +} + + + +// --- FUN_0044b9f0 at 0x0044B9F0 (size: 28) --- + +bool FUN_0044b9f0(void) + +{ + char cVar1; + + cVar1 = (**(code **)(*(int *)(DAT_00837bac + 4) + 0x44))(0x69466948,1); + return cVar1 == '\0'; +} + + + +// --- FUN_0044ba10 at 0x0044BA10 (size: 34) --- + +bool __fastcall FUN_0044ba10(int *param_1) + +{ + char cVar1; + + cVar1 = (**(code **)(*param_1 + 0x2c))(); + if (cVar1 != '\0') { + cVar1 = (**(code **)(*param_1 + 0x28))(); + return cVar1 != '\0'; + } + return false; +} + + + +// --- FUN_0044ba40 at 0x0044BA40 (size: 122) --- + +undefined4 FUN_0044ba40(undefined4 param_1) + +{ + char cVar1; + undefined4 local_34; + + FUN_0043d7d0(param_1); + cVar1 = FUN_00413a70(); + if ((((cVar1 != '\0') && (DAT_0086734c != 0)) && (DAT_00819248 != '\0')) && ((local_34 & 4) == 0)) + { + if (((local_34 & 2) != 0) && ((local_34 & 1) != 0)) { + return *(undefined4 *)(DAT_00870340 + 0x6c); + } + if ((local_34 & 2) != 0) { + return *(undefined4 *)(DAT_00870340 + 0x70); + } + if ((local_34 & 1) != 0) { + param_1 = *(undefined4 *)(DAT_00870340 + 0x68); + } + } + return param_1; +} + + + +// --- FUN_0044bac0 at 0x0044BAC0 (size: 91) --- + +void __fastcall FUN_0044bac0(int param_1) + +{ + int *piVar1; + int iVar2; + int iVar3; + undefined4 local_4; + + local_4 = 0; + if (*(int *)(param_1 + 0x84) != 0) { + iVar3 = 0; + do { + iVar2 = 6; + do { + piVar1 = *(int **)(iVar3 + 8 + *(int *)(param_1 + 0x7c)); + if (piVar1 != (int *)0x0) { + (**(code **)(*piVar1 + 0x14))(); + *(undefined4 *)(iVar3 + 8 + *(int *)(param_1 + 0x7c)) = 0; + } + iVar3 = iVar3 + 0xc; + iVar2 = iVar2 + -1; + } while (iVar2 != 0); + local_4 = local_4 + 1; + } while (local_4 < *(uint *)(param_1 + 0x84)); + } + return; +} + + + +// --- FUN_0044bb20 at 0x0044BB20 (size: 23) --- + +undefined1 FUN_0044bb20(void) + +{ + char cVar1; + + cVar1 = FUN_00413a70(); + if (cVar1 != '\0') { + FUN_0044bac0(); + } + return 1; +} + + + +// --- FUN_0044bb40 at 0x0044BB40 (size: 218) --- + +undefined1 __fastcall FUN_0044bb40(int param_1) + +{ + int iVar1; + undefined4 uVar2; + int iVar3; + int iVar4; + bool bVar5; + undefined1 local_19; + undefined4 local_18; + undefined4 local_14; + + local_19 = 1; + if (*(int *)(param_1 + 0x58) != 5) { + if (*(int *)(param_1 + 0x84) == 0) { + return 0; + } + local_14 = 0; + iVar1 = 0; + do { + local_18 = 6; + do { + iVar4 = *(int *)(param_1 + 0x7c) + iVar1; + if (*(int *)(*(int *)(param_1 + 0x7c) + 4 + iVar1) != DAT_0083b230) { + iVar3 = *(int *)(param_1 + 0x58); + if ((iVar3 == 2) || (iVar3 == 4)) { + if (*(int **)(iVar4 + 8) != (int *)0x0) { + (**(code **)(**(int **)(iVar4 + 8) + 0x14))(); + *(undefined4 *)(iVar4 + 8) = 0; + } + uVar2 = FUN_004220b0(*(undefined4 *)(iVar4 + 4),0xc); + iVar3 = FUN_00415430(uVar2); + *(int *)(iVar4 + 8) = iVar3; + bVar5 = iVar3 == 0; + } + else { + bVar5 = iVar3 == 3; + } + if (bVar5) { + local_19 = 0; + } + } + iVar1 = iVar1 + 0xc; + local_18 = local_18 + -1; + } while (local_18 != 0); + local_14 = local_14 + 1; + } while (local_14 < *(uint *)(param_1 + 0x84)); + } + return local_19; +} + + + +// --- FUN_0044bc30 at 0x0044BC30 (size: 836) --- + +undefined4 __fastcall FUN_0044bc30(int *param_1) + +{ + int *piVar1; + undefined4 uVar2; + char cVar3; + undefined4 uVar4; + int *piVar5; + int iVar6; + undefined4 uVar7; + undefined4 unaff_EBX; + uint uVar8; + int iVar9; + undefined4 unaff_EBP; + uint uVar10; + undefined4 unaff_EDI; + int iVar11; + int iStack_14; + + FUN_00446be0(CONCAT31((uint3)((uint)param_1[0x19] >> 9),~(byte)((uint)param_1[0x19] >> 1)) & + 0xffffff01); + iVar11 = param_1[0x16]; + if ((iVar11 != 5) && ((param_1[0x21] == 0 || (param_1[0x21] == 0)))) { + return 0; + } + if (iVar11 == 2) { + iVar11 = *(int *)(param_1[0x1f] + 8); + if (iVar11 != 0) { + uVar7 = *(undefined4 *)(iVar11 + 0xa0); + uVar2 = *(undefined4 *)(iVar11 + 0xa4); + uVar4 = FUN_0044ba40(*(undefined4 *)(iVar11 + 0xdc)); + piVar5 = (int *)(**(code **)(*DAT_00870340 + 0x14))(); + if (piVar5 != (int *)0x0) { + cVar3 = (**(code **)(*piVar5 + 0x58))(uVar7,uVar2,param_1[0x21],uVar4,2); + if (cVar3 != '\0') { + uVar10 = 0; + if (param_1[0x21] != 0) { + iVar11 = 0; + uVar7 = unaff_EBX; + do { + iVar9 = *(int *)(iVar11 + 8 + param_1[0x1f]); + if (iVar9 == 0) { + (**(code **)(*piVar5 + 0x14))(); + return 0; + } + iVar6 = (**(code **)(*piVar5 + 100))(uVar10,0); + if ((iVar6 == 0) || (piVar1 = (int *)(iVar6 + -0x30), piVar1 == (int *)0x0)) + goto LAB_0044bda5; + cVar3 = (**(code **)(*piVar1 + 0x68))(iVar9); + if (cVar3 == '\0') { + (**(code **)(*piVar1 + 0x14))(); + goto LAB_0044bda5; + } + (**(code **)(*piVar1 + 0x14))(); + uVar10 = uVar10 + 1; + iVar11 = iVar11 + 0x48; + } while (uVar10 < (uint)param_1[0x21]); + } + cVar3 = (**(code **)(*param_1 + 0x58))(uVar7,unaff_EDI,param_1[0x21],unaff_EBP,0); + if (cVar3 != '\0') { + cVar3 = (**(code **)(*param_1 + 0x60))(piVar5); + if (cVar3 == '\0') { + (**(code **)(*piVar5 + 0x14))(); + return 0; + } + (**(code **)(*piVar5 + 0x14))(); + FUN_0044bac0(); + return 1; + } + } +LAB_0044bda5: + (**(code **)(*piVar5 + 0x14))(); + return 0; + } + } + } + else if (iVar11 == 4) { + iVar11 = *(int *)(param_1[0x1f] + 8); + if ((iVar11 != 0) && (iVar9 = *(int *)(iVar11 + 0xa0), iVar9 == *(int *)(iVar11 + 0xa4))) { + uVar7 = FUN_0044ba40(*(undefined4 *)(iVar11 + 0xdc)); + piVar5 = (int *)(**(code **)(*DAT_00870340 + 0x14))(); + if (piVar5 != (int *)0x0) { + cVar3 = (**(code **)(*piVar5 + 0x5c))(iVar9,param_1[0x21],uVar7,2); + if (cVar3 != '\0') { + uVar10 = 0; + if (param_1[0x21] != 0) { + iVar11 = 0; + do { + uVar8 = 0; + iVar9 = iVar11; + do { + if (*(int *)(iVar11 + 8 + param_1[0x1f]) == 0) goto LAB_0044bf33; + iVar6 = (**(code **)(*piVar5 + 100))(uVar10,uVar8); + if ((iVar6 == 0) || (piVar1 = (int *)(iVar6 + -0x30), piVar1 == (int *)0x0)) { +LAB_0044bf13: + (**(code **)(*piVar5 + 0x14))(); + return 0; + } + cVar3 = (**(code **)(*piVar1 + 0x68))(iVar9); + if (cVar3 == '\0') { + (**(code **)(*piVar1 + 0x14))(); + goto LAB_0044bf13; + } + (**(code **)(*piVar1 + 0x14))(); + uVar8 = uVar8 + 1; + iVar11 = iVar11 + 0xc; + } while (uVar8 < 6); + uVar10 = uVar10 + 1; + iVar11 = iVar9 + 0x48; + iVar9 = iStack_14; + uVar7 = unaff_EDI; + } while (uVar10 < (uint)param_1[0x21]); + } + cVar3 = (**(code **)(*param_1 + 0x5c))(iVar9,param_1[0x21],uVar7,0); + if (cVar3 != '\0') { + cVar3 = (**(code **)(*param_1 + 0x60))(piVar5); + if (cVar3 != '\0') { + (**(code **)(*piVar5 + 0x14))(); + FUN_0044bac0(); + return 1; + } +LAB_0044bf33: + (**(code **)(*piVar5 + 0x14))(); + return 0; + } + } + (**(code **)(*piVar5 + 0x14))(); + return 0; + } + } + } + else if (iVar11 == 5) { + FUN_0044bac0(); + return 1; + } + return 0; +} + + + +// --- FUN_0044bf80 at 0x0044BF80 (size: 54) --- + +bool FUN_0044bf80(void) + +{ + char cVar1; + + cVar1 = FUN_00413a70(); + if (cVar1 == '\0') { + return true; + } + if (DAT_0086734c != 0) { + cVar1 = FUN_0044bb40(); + if (cVar1 != '\0') { + cVar1 = FUN_0044bc30(); + return cVar1 != '\0'; + } + } + return false; +} + + + +// --- FUN_0044bfc0 at 0x0044BFC0 (size: 107) --- + +int * __thiscall FUN_0044bfc0(int *param_1,int param_2) + +{ + int iVar1; + LONG LVar2; + int iVar3; + int *piVar4; + + param_2 = param_2 - (int)param_1; + iVar3 = 6; + piVar4 = param_1; + do { + iVar1 = *piVar4; + if (iVar1 != *(int *)(param_2 + (int)piVar4)) { + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *(int *)(param_2 + (int)piVar4); + *piVar4 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + piVar4[1] = *(int *)(param_2 + 4 + (int)piVar4); + piVar4[2] = *(int *)(param_2 + 8 + (int)piVar4); + piVar4 = piVar4 + 3; + iVar3 = iVar3 + -1; + } while (iVar3 != 0); + return param_1; +} + + + +// --- FUN_0044c030 at 0x0044C030 (size: 67) --- + +undefined4 * __fastcall FUN_0044c030(undefined4 *param_1) + +{ + LONG *lpAddend; + undefined4 *puVar1; + int iVar2; + + iVar2 = 6; + puVar1 = param_1; + do { + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *puVar1 = PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + puVar1[1] = DAT_0083b230; + puVar1[2] = 0; + puVar1 = puVar1 + 3; + iVar2 = iVar2 + -1; + } while (iVar2 != 0); + return param_1; +} + + + +// --- FUN_0044c080 at 0x0044C080 (size: 81) --- + +void __fastcall FUN_0044c080(int param_1) + +{ + int iVar1; + LONG LVar2; + undefined4 *puVar3; + int *piVar4; + int local_4; + + local_4 = 6; + piVar4 = (int *)(param_1 + 0x48); + do { + if ((int *)piVar4[-1] != (int *)0x0) { + (**(code **)(*(int *)piVar4[-1] + 0x14))(); + piVar4[-1] = 0; + } + iVar1 = piVar4[-3]; + puVar3 = (undefined4 *)(iVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + local_4 = local_4 + -1; + piVar4 = piVar4 + -3; + } while (local_4 != 0); + return; +} + + + +// --- FUN_0044c0e0 at 0x0044C0E0 (size: 74) --- + +void __fastcall FUN_0044c0e0(int *param_1) + +{ + int iVar1; + int iVar2; + + if (((param_1[1] & 0x80000000U) == 0x80000000) && (iVar1 = *param_1, iVar1 != 0)) { + iVar2 = *(int *)(iVar1 + -4); + if (-1 < iVar2 + -1) { + do { + FUN_0044c080(); + iVar2 = iVar2 + -1; + } while (iVar2 != 0); + } + operator_delete__((void *)(iVar1 + -4)); + } + return; +} + + + +// --- FUN_0044c130 at 0x0044C130 (size: 167) --- + +void __fastcall FUN_0044c130(int *param_1) + +{ + int iVar1; + uint uVar2; + undefined4 uVar3; + int iVar4; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) != 0x80000000) { + if ((*param_1 != 0) && (uVar2 = param_1[1] & 0x7fffffff, -1 < (int)(uVar2 - 1))) { + do { + uVar3 = FUN_0044c030(); + FUN_0044bfc0(uVar3); + FUN_0044c080(); + uVar2 = uVar2 - 1; + } while (uVar2 != 0); + } + return; + } + iVar1 = *param_1; + if (iVar1 != 0) { + iVar4 = *(int *)(iVar1 + -4); + if (-1 < iVar4 + -1) { + do { + FUN_0044c080(); + iVar4 = iVar4 + -1; + } while (iVar4 != 0); + } + operator_delete__((void *)(iVar1 + -4)); + } + *param_1 = 0; + param_1[1] = 0; + return; +} + + + +// --- FUN_0044c1e0 at 0x0044C1E0 (size: 267) --- + +undefined4 __thiscall FUN_0044c1e0(int *param_1,uint param_2) + +{ + uint *puVar1; + uint uVar2; + uint *puVar3; + int iVar4; + + uVar2 = param_2; + if ((uint)param_1[2] <= param_2) { + if (param_2 <= (param_1[1] & 0x7fffffffU)) { + return 1; + } + if (param_2 == 0) { + FUN_0044c130(); + return 1; + } + puVar3 = (uint *)thunk_FUN_005df0f5(param_2 * 0x48 + 4); + if (puVar3 != (uint *)0x0) { + puVar1 = puVar3 + 1; + *puVar3 = param_2; + FUN_00401000(puVar1,0x48,param_2,FUN_0044c030); + if (puVar1 != (uint *)0x0) { + if (*param_1 != 0) { + param_2 = param_1[2]; + if (-1 < (int)(param_2 + -1)) { + iVar4 = (param_2 + -1) * 0x48; + do { + FUN_0044bfc0(*param_1 + iVar4); + iVar4 = iVar4 + -0x48; + param_2 = param_2 + -1; + } while (param_2 != 0); + } + if (((param_1[1] & 0x80000000U) == 0x80000000) && (iVar4 = *param_1, iVar4 != 0)) { + param_2 = *(int *)(iVar4 + -4); + if (-1 < (int)(param_2 + -1)) { + do { + FUN_0044c080(); + param_2 = param_2 + -1; + } while (param_2 != 0); + } + operator_delete__((void *)(iVar4 + -4)); + } + } + *param_1 = (int)puVar1; + param_1[1] = uVar2 | 0x80000000; + return 1; + } + } + } + return 0; +} + + + +// --- FUN_0044c2f0 at 0x0044C2F0 (size: 173) --- + +int __thiscall FUN_0044c2f0(int param_1,uint *param_2) + +{ + char cVar1; + undefined4 uVar2; + uint uVar3; + uint uVar4; + + if ((*(uint *)(param_1 + 4) & 0x7fffffff) < (param_2[1] & 0x7fffffff)) { + *(undefined4 *)(param_1 + 8) = 0; + cVar1 = FUN_0044c1e0(param_2[1] & 0x7fffffff); + if (cVar1 == '\0') { + return param_1; + } + } + uVar3 = *param_2; + uVar4 = uVar3 + param_2[2] * 0x48; + for (; uVar3 < uVar4; uVar3 = uVar3 + 0x48) { + FUN_0044bfc0(uVar3); + } + uVar4 = param_2[2]; + if (uVar4 < *(uint *)(param_1 + 8)) { + do { + uVar2 = FUN_0044c030(); + FUN_0044bfc0(uVar2); + FUN_0044c080(); + uVar4 = uVar4 + 1; + } while (uVar4 < *(uint *)(param_1 + 8)); + } + *(uint *)(param_1 + 8) = param_2[2]; + return param_1; +} + + + +// --- FUN_0044c3a0 at 0x0044C3A0 (size: 134) --- + +undefined1 __thiscall FUN_0044c3a0(int param_1,uint param_2,char param_3) + +{ + char cVar1; + uint uVar2; + undefined4 uVar3; + + if ((*(uint *)(param_1 + 4) & 0x7fffffff) < param_2) { + uVar2 = param_2; + if (param_3 == '\0') { + uVar2 = FUN_00453850(param_2); + } + cVar1 = FUN_0044c1e0(uVar2); + if (cVar1 == '\0') { + return 0; + } + } + else { + uVar2 = param_2; + if (param_2 < *(uint *)(param_1 + 8)) { + do { + uVar3 = FUN_0044c030(); + FUN_0044bfc0(uVar3); + FUN_0044c080(); + uVar2 = uVar2 + 1; + } while (uVar2 < *(uint *)(param_1 + 8)); + } + } + *(uint *)(param_1 + 8) = param_2; + return 1; +} + + + +// --- FUN_0044c430 at 0x0044C430 (size: 112) --- + +undefined4 * __fastcall FUN_0044c430(undefined4 *param_1) + +{ + FUN_00415460(DAT_0083b230); + FUN_00447220(); + *param_1 = &PTR_LAB_0079c1a8; + param_1[0xc] = &PTR_LAB_0079c198; + param_1[0x1b] = 0; + param_1[0x1c] = 0; + param_1[0x1d] = 0; + *(undefined1 *)(param_1 + 0x1e) = 1; + param_1[0x1f] = 0; + param_1[0x20] = 0; + param_1[0x21] = 0; + param_1[0x16] = 1; + param_1[0x17] = 0; + param_1[0x18] = 0; + param_1[0x19] = 0; + *(undefined1 *)(param_1 + 0x1a) = 0; + FUN_0044c130(); + param_1[0x22] = 0; + param_1[0x23] = 0; + param_1[0x24] = 0; + return param_1; +} + + + +// --- FUN_0044c4c0 at 0x0044C4C0 (size: 35) --- + +void FUN_0044c4c0(void) + +{ + char cVar1; + + cVar1 = FUN_00413a70(); + if (cVar1 != '\0') { + FUN_0044bac0(); + } + FUN_0044bac0(); + FUN_0044c130(); + return; +} + + + +// --- FUN_0044c4f0 at 0x0044C4F0 (size: 88) --- + +void __fastcall FUN_0044c4f0(int param_1) + +{ + char cVar1; + + cVar1 = FUN_00413a70(); + if (cVar1 != '\0') { + FUN_0044bac0(); + } + FUN_0044bac0(); + FUN_0044c130(); + *(undefined4 *)(param_1 + 0x58) = 1; + *(undefined4 *)(param_1 + 0x5c) = 0; + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined4 *)(param_1 + 100) = 0; + *(undefined1 *)(param_1 + 0x68) = 0; + FUN_0044c130(); + *(undefined4 *)(param_1 + 0x88) = 0; + *(undefined4 *)(param_1 + 0x8c) = 0; + *(undefined4 *)(param_1 + 0x90) = 0; + return; +} + + + +// --- FUN_0044c550 at 0x0044C550 (size: 252) --- + +undefined4 __fastcall FUN_0044c550(int param_1) + +{ + uint uVar1; + char cVar2; + int iVar3; + uint uVar4; + int iVar5; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + if (*(char *)(param_1 + 0x68) != '\0') { + return 1; + } + *(undefined1 *)(param_1 + 0x68) = 1; + if (DAT_0086734c == 0) { + return 0; + } + switch(DAT_0081ffac) { + case 0: + cVar2 = FUN_0044b9f0(); + if (cVar2 == '\0') { + return 1; + } + case 1: + uVar4 = 1; + break; + case 2: + uVar4 = 2; + break; + case 3: + uVar4 = 3; + break; + case 4: + uVar4 = 4; + break; + default: + goto switchD_0044c588_default; + } + uVar1 = *(uint *)(param_1 + 0x84); + if (1 < uVar1) { + if (uVar1 <= uVar4) { + uVar4 = uVar1 - 1; + } + iVar3 = uVar1 - uVar4; + local_c = 0; + local_8 = 0; + local_4 = 0; + FUN_0044c3a0(iVar3,1); + if (iVar3 != 0) { + iVar5 = uVar4 * 0x48; + do { + FUN_0044bfc0(*(int *)(param_1 + 0x7c) + iVar5); + iVar5 = iVar5 + 0x48; + iVar3 = iVar3 + -1; + } while (iVar3 != 0); + } + FUN_0044bac0(); + FUN_0044c130(); + FUN_0044c2f0(&local_c); + FUN_0044c0e0(); + return 1; + } +switchD_0044c588_default: + return 1; +} + + + +// --- FUN_0044c6a0 at 0x0044C6A0 (size: 30) --- + +void * __thiscall FUN_0044c6a0(void *param_1,byte param_2) + +{ + FUN_0044c6c0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0044c6c0 at 0x0044C6C0 (size: 77) --- + +void __fastcall FUN_0044c6c0(undefined4 *param_1) + +{ + char cVar1; + + *param_1 = &PTR_LAB_0079c1a8; + param_1[0xc] = &PTR_LAB_0079c198; + cVar1 = FUN_00413a70(); + if (cVar1 != '\0') { + FUN_0044bac0(); + } + FUN_0044bac0(); + FUN_0044c130(); + FUN_0044c0e0(); + FUN_00446f00(); + FUN_004154b0(); + return; +} + + + +// --- FUN_0044c710 at 0x0044C710 (size: 354) --- + +undefined4 __thiscall FUN_0044c710(int param_1,int param_2) + +{ + int iVar1; + int iVar2; + int iVar3; + int *piVar4; + undefined4 uVar5; + LONG LVar6; + int iVar7; + undefined4 local_c; + undefined4 local_8; + + if (param_2 == 0) { + iVar7 = 0; + } + else { + iVar7 = param_2 + 0x30; + } + uVar5 = FUN_00446b90(iVar7); + if ((char)uVar5 == '\0') { + return uVar5; + } + *(undefined4 *)(param_2 + 0x58) = *(undefined4 *)(param_1 + 0x58); + *(undefined4 *)(param_2 + 0x5c) = *(undefined4 *)(param_1 + 0x5c); + *(undefined4 *)(param_2 + 0x60) = *(undefined4 *)(param_1 + 0x60); + *(undefined4 *)(param_2 + 100) = *(undefined4 *)(param_1 + 100); + *(undefined1 *)(param_2 + 0x68) = *(undefined1 *)(param_1 + 0x68); + uVar5 = *(undefined4 *)(param_1 + 0x84); + FUN_0044bac0(); + FUN_0044c130(); + FUN_0044c3a0(uVar5,1); + iVar7 = 0; + local_8 = 0; + if (*(int *)(param_1 + 0x84) != 0) { + do { + local_c = 6; + do { + iVar1 = *(int *)(param_1 + 0x7c); + iVar2 = *(int *)(param_2 + 0x7c); + iVar3 = *(int *)(iVar2 + iVar7); + if (iVar3 != *(int *)(iVar1 + iVar7)) { + LVar6 = InterlockedDecrement((LONG *)(iVar3 + -0x10)); + if ((LVar6 == 0) && ((undefined4 *)(iVar3 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar3 + -0x14))(1); + } + iVar1 = *(int *)(iVar1 + iVar7); + *(int *)(iVar2 + iVar7) = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + *(undefined4 *)(iVar7 + 4 + *(int *)(param_2 + 0x7c)) = + *(undefined4 *)(iVar7 + 4 + *(int *)(param_1 + 0x7c)); + *(undefined4 *)(iVar7 + 8 + *(int *)(param_2 + 0x7c)) = + *(undefined4 *)(iVar7 + 8 + *(int *)(param_1 + 0x7c)); + piVar4 = *(int **)(iVar7 + 8 + *(int *)(param_1 + 0x7c)); + if (piVar4 != (int *)0x0) { + (**(code **)(*piVar4 + 0x10))(); + } + iVar7 = iVar7 + 0xc; + local_c = local_c + -1; + } while (local_c != 0); + local_8 = local_8 + 1; + } while (local_8 < *(uint *)(param_1 + 0x84)); + } + *(undefined4 *)(param_2 + 0x88) = *(undefined4 *)(param_1 + 0x88); + *(undefined4 *)(param_2 + 0x8c) = *(undefined4 *)(param_1 + 0x8c); + uVar5 = *(undefined4 *)(param_1 + 0x90); + *(undefined4 *)(param_2 + 0x90) = uVar5; + return CONCAT31((int3)((uint)uVar5 >> 8),1); +} + + + +// --- FUN_0044c880 at 0x0044C880 (size: 155) --- + +void __fastcall FUN_0044c880(int param_1) + +{ + int iVar1; + char cVar2; + undefined4 uVar3; + undefined4 uVar4; + int iVar5; + uint uVar6; + int local_14; + + cVar2 = FUN_00413a70(); + if (cVar2 != '\0') { + FUN_0044c550(); + } + uVar6 = 0; + if (*(int *)(param_1 + 0x84) != 0) { + do { + iVar5 = uVar6 * 0x48; + local_14 = 6; + do { + iVar1 = *(int *)(*(int *)(param_1 + 0x7c) + 4 + iVar5); + if (iVar1 != DAT_0083b230) { + uVar4 = 0; + if ((uVar6 == 0) && (1 < *(uint *)(param_1 + 0x84))) { + uVar4 = 4; + } + uVar3 = FUN_004220b0(iVar1,0); + FUN_0041a4e0(uVar3,uVar4); + } + iVar5 = iVar5 + 0xc; + local_14 = local_14 + -1; + } while (local_14 != 0); + uVar6 = uVar6 + 1; + } while (uVar6 < *(uint *)(param_1 + 0x84)); + } + return; +} + + + +// --- FUN_0044c920 at 0x0044C920 (size: 30) --- + +bool FUN_0044c920(void) + +{ + char cVar1; + + cVar1 = FUN_00413a70(); + if (cVar1 == '\0') { + return true; + } + cVar1 = FUN_0044c550(); + return cVar1 != '\0'; +} + + + +// --- FUN_0044ca60 at 0x0044CA60 (size: 41) --- + +void __fastcall FUN_0044ca60(int param_1) + +{ + *(undefined4 *)(param_1 + 4) = 0; + *(undefined4 *)(param_1 + 8) = 0; + *(undefined1 *)(param_1 + 0xc) = 2; + *(undefined4 *)(param_1 + 0x10) = 0; + *(undefined1 *)(param_1 + 0x14) = 0; + *(undefined1 *)(param_1 + 0x15) = 0; + *(undefined1 *)(param_1 + 0x16) = 0; + *(undefined1 *)(param_1 + 0x17) = 0; + *(undefined1 *)(param_1 + 0x18) = 1; + *(undefined4 *)(param_1 + 0x1c) = 0; + *(undefined4 *)(param_1 + 0x20) = 0; + *(undefined1 *)(param_1 + 0x24) = 0; + return; +} + + + +// --- FUN_0044ca90 at 0x0044CA90 (size: 34) --- + +void __fastcall FUN_0044ca90(int param_1) + +{ + if (*(void **)(param_1 + 0x10) != (void *)0x0) { + operator_delete__(*(void **)(param_1 + 0x10)); + *(undefined4 *)(param_1 + 0x10) = 0; + } + *(undefined4 *)(param_1 + 4) = 0; + *(undefined4 *)(param_1 + 8) = 0; + return; +} + + + +// --- FUN_0044cac0 at 0x0044CAC0 (size: 93) --- + +undefined4 __thiscall +FUN_0044cac0(int param_1,int param_2,char param_3,undefined1 param_4,undefined1 param_5, + undefined1 param_6) + +{ + undefined4 uVar1; + + *(undefined1 *)(param_1 + 0x14) = param_4; + *(int *)(param_1 + 8) = param_2; + *(int *)(param_1 + 4) = param_2; + *(char *)(param_1 + 0xc) = param_3; + *(undefined1 *)(param_1 + 0x15) = param_5; + if (param_3 == '\x02') { + param_2 = param_2 * 2; + } + else { + param_2 = param_2 * 4; + } + uVar1 = thunk_FUN_005df0f5(param_2); + *(undefined4 *)(param_1 + 0x10) = uVar1; + *(undefined1 *)(param_1 + 0x16) = 0; + *(undefined1 *)(param_1 + 0x17) = 0; + *(undefined4 *)(param_1 + 0x1c) = 0; + *(undefined4 *)(param_1 + 0x20) = 0; + *(undefined1 *)(param_1 + 0x24) = 0; + *(undefined1 *)(param_1 + 0x18) = param_6; + return 1; +} + + + +// --- FUN_0044cb20 at 0x0044CB20 (size: 66) --- + +void __fastcall FUN_0044cb20(int param_1) + +{ + if (*(void **)(param_1 + 0x10) != (void *)0x0) { + operator_delete__(*(void **)(param_1 + 0x10)); + *(undefined4 *)(param_1 + 0x10) = 0; + } + *(undefined4 *)(param_1 + 4) = 0; + *(undefined4 *)(param_1 + 8) = 0; + *(undefined4 *)(param_1 + 0x10) = 0; + *(undefined1 *)(param_1 + 0x14) = 0; + *(undefined1 *)(param_1 + 0x15) = 0; + *(undefined1 *)(param_1 + 0x16) = 0; + *(undefined1 *)(param_1 + 0x17) = 0; + *(undefined4 *)(param_1 + 0x1c) = 0; + *(undefined4 *)(param_1 + 0x20) = 0; + *(undefined1 *)(param_1 + 0x24) = 0; + *(undefined1 *)(param_1 + 0xc) = 2; + *(undefined1 *)(param_1 + 0x18) = 1; + return; +} + + + +// --- FUN_0044cb70 at 0x0044CB70 (size: 8) --- + +undefined4 __fastcall FUN_0044cb70(int param_1) + +{ + *(undefined1 *)(param_1 + 0x16) = 1; + return *(undefined4 *)(param_1 + 0x10); +} + + + +// --- FUN_0044cb80 at 0x0044CB80 (size: 13) --- + +void __fastcall FUN_0044cb80(int param_1) + +{ + *(undefined1 *)(param_1 + 0x16) = 0; + *(undefined1 *)(param_1 + 0x17) = 1; + *(undefined1 *)(param_1 + 0x24) = 1; + return; +} + + + +// --- FUN_0044cb90 at 0x0044CB90 (size: 149) --- + +void __fastcall FUN_0044cb90(int param_1) + +{ + int iVar1; + uint *puVar2; + uint uVar3; + + if ((*(char *)(param_1 + 0x24) != '\0') && (*(char *)(param_1 + 0x18) != '\0')) { + puVar2 = *(uint **)(param_1 + 0x10); + *(undefined4 *)(param_1 + 0x20) = 0; + *(undefined4 *)(param_1 + 0x1c) = 0; + if ((puVar2 != (uint *)0x0) && (iVar1 = *(int *)(param_1 + 4), iVar1 != 0)) { + uVar3 = 0; + *(undefined4 *)(param_1 + 0x1c) = 0xffffffff; + *(undefined4 *)(param_1 + 0x20) = 0; + if (*(char *)(param_1 + 0xc) == '\x02') { + if (iVar1 != 0) { + do { + if ((uint)(ushort)*puVar2 < *(uint *)(param_1 + 0x1c)) { + *(uint *)(param_1 + 0x1c) = (uint)(ushort)*puVar2; + } + if (*(uint *)(param_1 + 0x20) < (uint)(ushort)*puVar2) { + *(uint *)(param_1 + 0x20) = (uint)(ushort)*puVar2; + } + uVar3 = uVar3 + 1; + puVar2 = (uint *)((int)puVar2 + 2); + } while (uVar3 < *(uint *)(param_1 + 4)); + *(undefined1 *)(param_1 + 0x24) = 0; + return; + } + } + else if (iVar1 != 0) { + do { + if (*puVar2 < *(uint *)(param_1 + 0x1c)) { + *(uint *)(param_1 + 0x1c) = *puVar2; + } + if (*(uint *)(param_1 + 0x20) < *puVar2) { + *(uint *)(param_1 + 0x20) = *puVar2; + } + uVar3 = uVar3 + 1; + puVar2 = puVar2 + 1; + } while (uVar3 < *(uint *)(param_1 + 4)); + } + *(undefined1 *)(param_1 + 0x24) = 0; + } + } + return; +} + + + +// --- FUN_0044cc30 at 0x0044CC30 (size: 36) --- + +undefined4 * __thiscall FUN_0044cc30(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_FUN_0079c26c; + FUN_0044ca90(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0044cc60 at 0x0044CC60 (size: 88) --- + +undefined4 * FUN_0044cc60(void) + +{ + undefined4 *puVar1; + + if (DAT_0086734c != 0) { + /* WARNING: Could not recover jumptable at 0x0044cc75. Too many branches */ + /* WARNING: Treating indirect jump as call */ + puVar1 = (undefined4 *)(**(code **)(*DAT_00870340 + 0x18))(); + return puVar1; + } + puVar1 = (undefined4 *)FUN_005df0f5(0x28); + if (puVar1 != (undefined4 *)0x0) { + puVar1[1] = 0; + puVar1[2] = 0; + puVar1[4] = 0; + *(undefined1 *)(puVar1 + 5) = 0; + *(undefined1 *)((int)puVar1 + 0x15) = 0; + *(undefined1 *)((int)puVar1 + 0x16) = 0; + *(undefined1 *)((int)puVar1 + 0x17) = 0; + puVar1[7] = 0; + puVar1[8] = 0; + *(undefined1 *)(puVar1 + 9) = 0; + *puVar1 = &PTR_FUN_0079c26c; + *(undefined1 *)(puVar1 + 3) = 2; + *(undefined1 *)(puVar1 + 6) = 1; + return puVar1; + } + return (undefined4 *)0x0; +} + + + +// --- FUN_0044ccc0 at 0x0044CCC0 (size: 145) --- + +undefined1 __thiscall FUN_0044ccc0(int *param_1,int param_2) + +{ + char cVar1; + uint uVar2; + uint uVar3; + undefined4 *puVar4; + undefined4 *puVar5; + + cVar1 = (**(code **)(*param_1 + 4)) + (*(undefined4 *)(param_2 + 8),*(undefined1 *)(param_2 + 0xc), + *(undefined1 *)(param_2 + 0x14),*(undefined1 *)(param_2 + 0x15), + *(undefined1 *)(param_2 + 0x18)); + if (cVar1 == '\0') { + return 0; + } + if (*(uint *)(param_2 + 4) <= (uint)param_1[2]) { + param_1[1] = *(uint *)(param_2 + 4); + *(undefined1 *)(param_1 + 9) = 1; + *(undefined1 *)((int)param_1 + 0x17) = 1; + } + *(undefined1 *)((int)param_1 + 0x16) = 1; + if ((undefined4 *)param_1[4] == (undefined4 *)0x0) { + (**(code **)(*param_1 + 8))(); + return 0; + } + uVar2 = (uint)*(byte *)(param_1 + 3) * param_1[2]; + puVar4 = *(undefined4 **)(param_2 + 0x10); + puVar5 = (undefined4 *)param_1[4]; + for (uVar3 = uVar2 >> 2; uVar3 != 0; uVar3 = uVar3 - 1) { + *puVar5 = *puVar4; + puVar4 = puVar4 + 1; + puVar5 = puVar5 + 1; + } + for (uVar2 = uVar2 & 3; uVar2 != 0; uVar2 = uVar2 - 1) { + *(undefined1 *)puVar5 = *(undefined1 *)puVar4; + puVar4 = (undefined4 *)((int)puVar4 + 1); + puVar5 = (undefined4 *)((int)puVar5 + 1); + } + *(undefined1 *)((int)param_1 + 0x16) = 0; + *(undefined1 *)((int)param_1 + 0x17) = 1; + *(undefined1 *)(param_1 + 9) = 1; + return 1; +} + + + +// --- FUN_0044cd60 at 0x0044CD60 (size: 140) --- + +void __thiscall FUN_0044cd60(int *param_1,int param_2) + +{ + char cVar1; + int *piVar2; + + FUN_0040ad10(4); + piVar2 = (int *)FUN_0040acf0(4); + if (piVar2 != (int *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + param_1[2] = *piVar2; + } + else { + *piVar2 = param_1[2]; + } + } + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + cVar1 = (**(code **)(*param_1 + 4))(param_1[2],2,1,1,1); + if (cVar1 == '\0') goto LAB_0044cdbc; + } + *(undefined1 *)((int)param_1 + 0x16) = 1; + if (param_1[4] != 0) { + FUN_00401590(param_1[4],(uint)*(byte *)(param_1 + 3) * param_1[1],param_2); + *(undefined1 *)((int)param_1 + 0x17) = 1; + *(undefined1 *)(param_1 + 9) = 1; + *(undefined1 *)((int)param_1 + 0x16) = 0; + return; + } +LAB_0044cdbc: + FUN_0040aa50(); + return; +} + + + +// --- FUN_0044cdf0 at 0x0044CDF0 (size: 107) --- + +undefined4 * __fastcall FUN_0044cdf0(undefined4 param_1) + +{ + char cVar1; + undefined4 *puVar2; + + puVar2 = (undefined4 *)FUN_005df0f5(0x28); + if (puVar2 == (undefined4 *)0x0) { + puVar2 = (undefined4 *)0x0; + } + else { + *puVar2 = &PTR_FUN_0079c26c; + puVar2[1] = 0; + puVar2[2] = 0; + *(undefined1 *)(puVar2 + 3) = 2; + puVar2[4] = 0; + *(undefined1 *)(puVar2 + 5) = 0; + *(undefined1 *)((int)puVar2 + 0x15) = 0; + *(undefined1 *)((int)puVar2 + 0x16) = 0; + *(undefined1 *)((int)puVar2 + 0x17) = 0; + *(undefined1 *)(puVar2 + 6) = 1; + puVar2[7] = 0; + puVar2[8] = 0; + *(undefined1 *)(puVar2 + 9) = 0; + } + cVar1 = FUN_0044ccc0(param_1); + if (cVar1 == '\0') { + if (puVar2 != (undefined4 *)0x0) { + (**(code **)*puVar2)(1); + } + return (undefined4 *)0x0; + } + return puVar2; +} + + + +// --- FUN_0044ce60 at 0x0044CE60 (size: 83) --- + +undefined4 * __fastcall FUN_0044ce60(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_00793b3c; + param_1[1] = 0; + param_1[2] = 0; + FUN_00406d60(); + param_1[6] = 0; + param_1[7] = 0; + param_1[8] = 0; + *param_1 = &PTR_LAB_0079aa94; + param_1[9] = &PTR_LAB_0079aa90; + param_1[0xc] = &PTR_LAB_00795430; + param_1[0xf] = 0; + param_1[0xd] = param_1 + 0x10; + param_1[0xe] = 8; + *(undefined1 *)(param_1 + 0x20) = 1; + return param_1; +} + + + +// --- FUN_0044cec0 at 0x0044CEC0 (size: 676) --- + +undefined4 __thiscall FUN_0044cec0(int *param_1,int *param_2) + +{ + bool bVar1; + undefined1 uVar2; + char cVar3; + LONG LVar4; + int iVar5; + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined4 extraout_ECX_01; + undefined4 extraout_ECX_02; + undefined4 uVar6; + undefined4 extraout_ECX_03; + undefined4 *puVar7; + uint uVar8; + undefined2 local_98 [2]; + int local_94; + undefined1 auStack_90 [12]; + undefined **appuStack_84 [13]; + void *pvStack_50; + uint uStack_4c; + + if (param_2 == (int *)0x0) { + return 0; + } + FUN_00401340("IndexArray"); + uVar2 = FUN_0065cc50(&local_94); + puVar7 = (undefined4 *)(local_94 + -0x14); + local_98[0] = CONCAT11(local_98[0]._1_1_,uVar2); + LVar4 = InterlockedDecrement((LONG *)(local_94 + -0x10)); + if ((LVar4 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + } + if ((char)local_98[0] == '\0') { + FUN_00401340("BinaryIndexArray"); + uVar2 = FUN_0065cc50(&local_94); + puVar7 = (undefined4 *)(local_94 + -0x14); + local_98[0] = CONCAT11(local_98[0]._1_1_,uVar2); + LVar4 = InterlockedDecrement((LONG *)(local_94 + -0x10)); + uVar6 = extraout_ECX; + if ((LVar4 == 0) && (puVar7 != (undefined4 *)0x0)) { + (**(code **)*puVar7)(1); + uVar6 = extraout_ECX_00; + } + if ((char)local_98[0] == '\0') { + FUN_00401340("unable to parse indices"); + FUN_0065d620(param_2,uVar6); + return 0; + } + bVar1 = false; + } + else { + bVar1 = true; + } + FUN_0044ce60(); + if (bVar1) { + iVar5 = FUN_0065ca40(); + param_1[2] = iVar5; + } + else { + FUN_00406d60(); + iVar5 = FUN_0065ca90(); + uVar6 = extraout_ECX_01; + if ((iVar5 == 0) || (cVar3 = FUN_00444f00(auStack_90), uVar6 = extraout_ECX_02, cVar3 == '\0')) + { + FUN_00401340("corrupt index data"); + FUN_0065d620(param_2,uVar6); + FUN_00406f90(); + FUN_004466a0(); + return 0; + } + FUN_00446770(auStack_90); + FUN_004449f0(param_1 + 2,appuStack_84); + FUN_00406f90(); + } + if (param_1[2] != 0) { + cVar3 = (**(code **)(*param_1 + 4))(param_1[2],2,1,1,1); + if ((cVar3 == '\0') || (*(undefined1 *)((int)param_1 + 0x16) = 1, param_1[4] == 0)) { +LAB_0044d0a9: + FUN_004466a0(); + return 0; + } + uVar8 = 0; + if (bVar1) { + if (param_1[1] != 0) { + do { + local_94 = 0; + (**(code **)(*param_2 + 0xc))(uVar8); + cVar3 = FUN_00448290(&local_94); + if (cVar3 == '\0') { + uVar6 = extraout_ECX_03; + FUN_00401340("unable to parse indices"); + FUN_0065d620(param_2,uVar6); + *(undefined1 *)((int)param_1 + 0x16) = 0; + *(undefined1 *)((int)param_1 + 0x17) = 1; + *(undefined1 *)(param_1 + 9) = 1; + goto LAB_0044d0a9; + } + *(undefined2 *)(param_1[4] + uVar8 * 2) = (undefined2)local_94; + uVar8 = uVar8 + 1; + } while (uVar8 < (uint)param_1[1]); + } + } + else if (param_1[1] != 0) { + do { + FUN_004019e0(local_98,appuStack_84); + *(undefined2 *)(param_1[4] + uVar8 * 2) = local_98[0]; + uVar8 = uVar8 + 1; + } while (uVar8 < (uint)param_1[1]); + } + *(undefined1 *)((int)param_1 + 0x16) = 0; + *(undefined1 *)((int)param_1 + 0x17) = 1; + *(undefined1 *)(param_1 + 9) = 1; + } + FUN_0065e850(); + appuStack_84[0] = &PTR_LAB_0079aa94; + if ((uStack_4c & 0x80000000) == 0x80000000) { + operator_delete__(pvStack_50); + } + FUN_0040b060(); + return 1; +} + + + +// --- FUN_0044d180 at 0x0044D180 (size: 195) --- + +void __fastcall FUN_0044d180(int param_1) + +{ + undefined *puVar1; + undefined *puVar2; + LONG LVar3; + LONG *pLVar4; + + puVar2 = PTR_DAT_00818344; + pLVar4 = (LONG *)(PTR_DAT_00818344 + -0x10); + InterlockedIncrement(pLVar4); + puVar1 = *(undefined **)(param_1 + 0x30); + if (puVar1 != puVar2) { + LVar3 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + *(undefined **)(param_1 + 0x30) = puVar2; + InterlockedIncrement(pLVar4); + } + LVar3 = InterlockedDecrement((LONG *)(puVar2 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar2 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar2 + -0x14))(1); + } + *(undefined4 *)(param_1 + 0x34) = DAT_0083c150; + puVar1 = *(undefined **)(param_1 + 0x38); + if (puVar1 != PTR_DAT_00818344) { + LVar3 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + pLVar4 = (LONG *)(PTR_DAT_00818344 + -0x10); + *(undefined **)(param_1 + 0x38) = PTR_DAT_00818344; + InterlockedIncrement(pLVar4); + } + *(undefined4 *)(param_1 + 0x3c) = 2; + *(undefined1 *)(param_1 + 0x4c) = 1; + *(undefined1 *)(param_1 + 0x4d) = 0; + *(undefined4 *)(param_1 + 0x50) = 0; + *(undefined4 *)(param_1 + 0x60) = 0; + *(undefined1 *)(param_1 + 100) = 1; + return; +} + + + +// --- FUN_0044d2d0 at 0x0044D2D0 (size: 151) --- + +undefined4 __fastcall FUN_0044d2d0(int param_1) + +{ + int *piVar1; + int iVar2; + uint uVar3; + + if (*(int **)(param_1 + 0x60) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x60) + 0x14))(); + *(undefined4 *)(param_1 + 0x60) = 0; + } + if (*(int **)(param_1 + 0x50) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x50) + 0x14))(); + *(undefined4 *)(param_1 + 0x50) = 0; + } + if (*(int *)(param_1 + 0x5c) != 0) { + uVar3 = 0; + do { + piVar1 = *(int **)(*(int *)(param_1 + 0x54) + uVar3 * 4); + if (piVar1 != (int *)0x0) { + (**(code **)(*piVar1 + 0x14))(); + *(undefined4 *)(*(int *)(param_1 + 0x54) + uVar3 * 4) = 0; + } + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 0x5c)); + } + *(undefined4 *)(param_1 + 0x5c) = 0; + if ((*(uint *)(param_1 + 0x58) & 0x80000000) != 0x80000000) { + if (*(int *)(param_1 + 0x54) != 0) { + iVar2 = (*(uint *)(param_1 + 0x58) & 0x7fffffff) - 1; + while (-1 < iVar2) { + iVar2 = iVar2 + -1; + *(undefined4 *)(*(int *)(param_1 + 0x54) + 4 + iVar2 * 4) = 0; + } + } + return 1; + } + operator_delete__(*(void **)(param_1 + 0x54)); + *(undefined4 *)(param_1 + 0x54) = 0; + *(undefined4 *)(param_1 + 0x58) = 0; + return 1; +} + + + +// --- FUN_0044d410 at 0x0044D410 (size: 174) --- + +void __fastcall FUN_0044d410(int param_1) + +{ + int *piVar1; + LONG LVar2; + int iVar3; + uint uVar4; + undefined4 *puVar5; + + FUN_0044d2d0(); + if (*(int **)(param_1 + 0x60) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x60) + 0x14))(); + *(undefined4 *)(param_1 + 0x60) = 0; + } + uVar4 = 0; + if (*(int *)(param_1 + 0x48) != 0) { + do { + piVar1 = *(int **)(*(int *)(param_1 + 0x40) + uVar4 * 4); + if (piVar1 != (int *)0x0) { + puVar5 = (undefined4 *)(*piVar1 + -0x14); + LVar2 = InterlockedDecrement((LONG *)(*piVar1 + -0x10)); + if ((LVar2 == 0) && (puVar5 != (undefined4 *)0x0)) { + (**(code **)*puVar5)(1); + } + operator_delete(piVar1); + } + *(undefined4 *)(*(int *)(param_1 + 0x40) + uVar4 * 4) = 0; + uVar4 = uVar4 + 1; + } while (uVar4 < *(uint *)(param_1 + 0x48)); + } + *(undefined4 *)(param_1 + 0x48) = 0; + if ((*(uint *)(param_1 + 0x44) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)(param_1 + 0x40)); + *(undefined4 *)(param_1 + 0x40) = 0; + *(undefined4 *)(param_1 + 0x44) = 0; + return; + } + if (*(int *)(param_1 + 0x40) != 0) { + iVar3 = (*(uint *)(param_1 + 0x44) & 0x7fffffff) - 1; + while (-1 < iVar3) { + iVar3 = iVar3 + -1; + *(undefined4 *)(*(int *)(param_1 + 0x40) + 4 + iVar3 * 4) = 0; + } + } + return; +} + + + +// --- FUN_0044d790 at 0x0044D790 (size: 16) --- + +void FUN_0044d790(void) + +{ + FUN_0044d410(); + FUN_0044d180(); + return; +} + + + +// --- FUN_0044da30 at 0x0044DA30 (size: 144) --- + +void __fastcall FUN_0044da30(undefined4 *param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + *param_1 = &PTR_LAB_0079c2e0; + FUN_0044d410(); + if ((param_1[0x16] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0x15]); + } + if ((param_1[0x11] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0x10]); + } + puVar2 = (undefined4 *)(param_1[0xe] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0xe] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(param_1[0xc] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[0xc] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_004154b0(); + return; +} + + + +// --- FUN_0044dac0 at 0x0044DAC0 (size: 30) --- + +void * __thiscall FUN_0044dac0(void *param_1,byte param_2) + +{ + FUN_0044da30(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0044dae0 at 0x0044DAE0 (size: 101) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +uint __thiscall FUN_0044dae0(undefined4 *param_1,float *param_2) + +{ + float *pfVar1; + uint uVar2; + + uVar2 = 0; + if (param_1[2] != 0) { + pfVar1 = (float *)*param_1; + do { + if (ABS(*pfVar1 - *param_2) < _DAT_0079c33c != (ABS(*pfVar1 - *param_2) == _DAT_0079c33c)) { + if (ABS(pfVar1[1] - param_2[1]) < _DAT_0079c33c != + (ABS(pfVar1[1] - param_2[1]) == _DAT_0079c33c)) { + if (ABS(pfVar1[2] - param_2[2]) < _DAT_0079c33c != + (ABS(pfVar1[2] - param_2[2]) == _DAT_0079c33c)) { + return uVar2; + } + } + } + uVar2 = uVar2 + 1; + pfVar1 = pfVar1 + 3; + } while (uVar2 < (uint)param_1[2]); + } + return 0xffffffff; +} + + + +// --- FUN_0044db50 at 0x0044DB50 (size: 119) --- + +void __thiscall FUN_0044db50(int param_1,int param_2) + +{ + undefined2 *puVar1; + uint uVar2; + + uVar2 = 0; + do { + FUN_0040ad10(2); + puVar1 = (undefined2 *)FUN_0040acf0(2); + if (puVar1 != (undefined2 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined2 *)(param_1 + uVar2 * 2) = *puVar1; + } + else { + *puVar1 = *(undefined2 *)(param_1 + uVar2 * 2); + } + } + FUN_0040ad10(2); + puVar1 = (undefined2 *)FUN_0040acf0(2); + if (puVar1 != (undefined2 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined2 *)(param_1 + 6 + uVar2 * 2) = *puVar1; + } + else { + *puVar1 = *(undefined2 *)(param_1 + 6 + uVar2 * 2); + } + } + uVar2 = uVar2 + 1; + } while (uVar2 < 3); + return; +} + + + +// --- FUN_0044dbd0 at 0x0044DBD0 (size: 119) --- + +void __thiscall FUN_0044dbd0(int param_1,int param_2) + +{ + undefined2 *puVar1; + uint uVar2; + + uVar2 = 0; + do { + FUN_0040ad10(2); + puVar1 = (undefined2 *)FUN_0040acf0(2); + if (puVar1 != (undefined2 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined2 *)(param_1 + uVar2 * 2) = *puVar1; + } + else { + *puVar1 = *(undefined2 *)(param_1 + uVar2 * 2); + } + } + FUN_0040ad10(2); + puVar1 = (undefined2 *)FUN_0040acf0(2); + if (puVar1 != (undefined2 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined2 *)(param_1 + 4 + uVar2 * 2) = *puVar1; + } + else { + *puVar1 = *(undefined2 *)(param_1 + 4 + uVar2 * 2); + } + } + uVar2 = uVar2 + 1; + } while (uVar2 < 2); + return; +} + + + +// --- FUN_0044dc50 at 0x0044DC50 (size: 92) --- + +void __fastcall FUN_0044dc50(int *param_1) + +{ + int iVar1; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + *param_1 = 0; + param_1[1] = 0; + return; + } + if (*param_1 != 0) { + iVar1 = (param_1[1] & 0x7fffffffU) - 1; + while (-1 < iVar1) { + iVar1 = iVar1 + -1; + *(int **)(*param_1 + 4 + iVar1 * 4) = param_1; + } + } + return; +} + + + +// --- FUN_0044dcb0 at 0x0044DCB0 (size: 83) --- + +void __fastcall FUN_0044dcb0(int *param_1) + +{ + int iVar1; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) != 0x80000000) { + if (*param_1 != 0) { + iVar1 = (param_1[1] & 0x7fffffffU) - 1; + while (-1 < iVar1) { + iVar1 = iVar1 + -1; + *(undefined4 *)(*param_1 + 4 + iVar1 * 4) = 0; + } + } + return; + } + operator_delete__((void *)*param_1); + *param_1 = 0; + param_1[1] = 0; + return; +} + + + +// --- FUN_0044dd10 at 0x0044DD10 (size: 148) --- + +undefined4 __thiscall FUN_0044dd10(int *param_1,uint param_2) + +{ + int iVar1; + int iVar2; + + if (param_2 < (uint)param_1[2]) { + return 0; + } + if ((param_1[1] & 0x7fffffffU) < param_2) { + if (param_2 == 0) { + FUN_0044dc50(); + return 1; + } + iVar1 = thunk_FUN_005df0f5(param_2 * 4); + if (iVar1 == 0) { + return 0; + } + if (*param_1 != 0) { + iVar2 = param_1[2] + -1; + while (-1 < iVar2) { + iVar2 = iVar2 + -1; + *(undefined4 *)(iVar1 + 4 + iVar2 * 4) = *(undefined4 *)(*param_1 + 4 + iVar2 * 4); + } + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + } + } + *param_1 = iVar1; + param_1[1] = param_2 | 0x80000000; + } + return 1; +} + + + +// --- FUN_0044ddb0 at 0x0044DDB0 (size: 91) --- + +undefined1 __thiscall FUN_0044ddb0(int *param_1,uint param_2,undefined4 param_3) + +{ + char cVar1; + uint uVar2; + + if ((param_1[1] & 0x7fffffffU) < param_2) { + uVar2 = param_2; + if ((char)param_3 == '\0') { + uVar2 = FUN_00453850(param_2); + } + cVar1 = FUN_0044dd10(uVar2); + if (cVar1 == '\0') { + return 0; + } + } + else { + uVar2 = param_2; + if (param_2 < (uint)param_1[2]) { + do { + *(undefined4 *)(*param_1 + uVar2 * 4) = param_3; + uVar2 = uVar2 + 1; + } while (uVar2 < (uint)param_1[2]); + } + } + param_1[2] = param_2; + return 1; +} + + + +// --- FUN_0044de10 at 0x0044DE10 (size: 203) --- + +undefined4 __thiscall FUN_0044de10(int *param_1,uint param_2) + +{ + undefined4 *puVar1; + uint uVar2; + int iVar3; + int iVar4; + undefined4 *puVar5; + + uVar2 = param_2; + if (param_2 < (uint)param_1[2]) { + return 0; + } + if ((param_1[1] & 0x7fffffffU) < param_2) { + if (param_2 == 0) { + FUN_004cd4c0(); + return 1; + } + iVar3 = thunk_FUN_005df0f5(param_2 * 0xc); + if (iVar3 == 0) { + return 0; + } + FUN_00401000(iVar3,0xc,param_2,FUN_0050a140); + if (*param_1 != 0) { + param_2 = param_1[2]; + if (-1 < (int)(param_2 + -1)) { + iVar4 = (param_2 + -1) * 0xc; + do { + puVar5 = (undefined4 *)(*param_1 + iVar4); + puVar1 = (undefined4 *)(iVar4 + iVar3); + *puVar1 = *puVar5; + puVar1[1] = puVar5[1]; + puVar1[2] = puVar5[2]; + iVar4 = iVar4 + -0xc; + param_2 = param_2 + -1; + } while (param_2 != 0); + } + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + } + } + *param_1 = iVar3; + param_1[1] = uVar2 | 0x80000000; + } + return 1; +} + + + +// --- FUN_0044def0 at 0x0044DEF0 (size: 82) --- + +void __fastcall FUN_0044def0(int *param_1) + +{ + int iVar1; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) != 0x80000000) { + if (*param_1 != 0) { + iVar1 = (param_1[1] & 0x7fffffffU) - 1; + while (-1 < iVar1) { + iVar1 = iVar1 + -1; + *(undefined2 *)(*param_1 + 2 + iVar1 * 2) = 0; + } + } + return; + } + operator_delete__((void *)*param_1); + *param_1 = 0; + param_1[1] = 0; + return; +} + + + +// --- FUN_0044df50 at 0x0044DF50 (size: 40) --- + +void __fastcall FUN_0044df50(undefined4 *param_1) + +{ + param_1[1] = 1; + *param_1 = &PTR_FUN_0079c340; + param_1[2] = 0; + param_1[3] = 0; + param_1[4] = 0; + param_1[5] = 0; + param_1[6] = 0; + param_1[7] = 0xffffffff; + return; +} + + + +// --- FUN_0044df80 at 0x0044DF80 (size: 189) --- + +void __fastcall FUN_0044df80(undefined4 *param_1) + +{ + int *piVar1; + undefined4 *puVar2; + int iVar3; + uint uVar4; + + puVar2 = (undefined4 *)param_1[6]; + *param_1 = &PTR_FUN_0079c340; + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + param_1[6] = 0; + } + uVar4 = 0; + if (param_1[5] != 0) { + do { + puVar2 = *(undefined4 **)(param_1[3] + uVar4 * 4); + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + *(undefined4 *)(param_1[3] + uVar4 * 4) = 0; + } + uVar4 = uVar4 + 1; + } while (uVar4 < (uint)param_1[5]); + } + param_1[5] = 0; + if ((param_1[4] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[3]); + param_1[3] = 0; + param_1[4] = 0; + } + else if (param_1[3] != 0) { + iVar3 = (param_1[4] & 0x7fffffff) - 1; + while (-1 < iVar3) { + iVar3 = iVar3 + -1; + *(undefined4 *)(param_1[3] + 4 + iVar3 * 4) = 0; + } + } + param_1[2] = 0; + if ((param_1[4] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[3]); + } + *param_1 = &PTR_LAB_00796c4c; + return; +} + + + +// --- FUN_0044e050 at 0x0044E050 (size: 102) --- + +void __fastcall FUN_0044e050(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_0079c344; + if ((param_1[9] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[8]); + } + if ((param_1[6] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[5]); + } + if ((param_1[3] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[2]); + } + *param_1 = &PTR_LAB_00796c4c; + return; +} + + + +// --- FUN_0044e0c0 at 0x0044E0C0 (size: 206) --- + +void __thiscall FUN_0044e0c0(int *param_1,int param_2) + +{ + undefined1 *puVar1; + uint *puVar2; + uint uVar3; + undefined1 *puVar4; + undefined2 *puVar5; + uint uVar6; + uint uVar7; + + uVar7 = param_1[2]; + FUN_0040ad10(4); + puVar2 = (uint *)FUN_0040acf0(4); + uVar6 = 0; + if (puVar2 != (uint *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + uVar7 = *puVar2; + } + else { + *puVar2 = uVar7; + } + } + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + uVar3 = FUN_0040a8f0(); + if (uVar3 < uVar7) { + FUN_0040aa50(); + return; + } + param_1[2] = 0; + FUN_0044ddb0(uVar7,1); + } + if (param_1[2] != 0) { + do { + puVar1 = (undefined1 *)(*param_1 + uVar6 * 4); + FUN_0040ad10(1); + puVar4 = (undefined1 *)FUN_0040acf0(1); + if (puVar4 != (undefined1 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *puVar1 = *puVar4; + } + else { + *puVar4 = *puVar1; + } + } + FUN_0040ad10(2); + puVar5 = (undefined2 *)FUN_0040acf0(2); + if (puVar5 != (undefined2 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined2 *)(puVar1 + 2) = *puVar5; + } + else { + *puVar5 = *(undefined2 *)(puVar1 + 2); + } + } + uVar6 = uVar6 + 1; + } while (uVar6 < (uint)param_1[2]); + } + return; +} + + + +// --- FUN_0044e190 at 0x0044E190 (size: 150) --- + +undefined4 __thiscall FUN_0044e190(int *param_1,uint param_2) + +{ + int iVar1; + int iVar2; + + if (param_2 < (uint)param_1[2]) { + return 0; + } + if ((param_1[1] & 0x7fffffffU) < param_2) { + if (param_2 == 0) { + FUN_0044def0(); + return 1; + } + iVar1 = thunk_FUN_005df0f5(param_2 * 2); + if (iVar1 == 0) { + return 0; + } + if (*param_1 != 0) { + iVar2 = param_1[2] + -1; + while (-1 < iVar2) { + iVar2 = iVar2 + -1; + *(undefined2 *)(iVar1 + 2 + iVar2 * 2) = *(undefined2 *)(*param_1 + 2 + iVar2 * 2); + } + if ((param_1[1] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)*param_1); + } + } + *param_1 = iVar1; + param_1[1] = param_2 | 0x80000000; + } + return 1; +} + + + +// --- FUN_0044e230 at 0x0044E230 (size: 139) --- + +undefined1 __thiscall FUN_0044e230(int *param_1,uint param_2,char param_3) + +{ + char cVar1; + uint uVar2; + int iVar3; + undefined4 *puVar4; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + if ((param_1[1] & 0x7fffffffU) < param_2) { + uVar2 = param_2; + if (param_3 == '\0') { + uVar2 = FUN_00453850(param_2); + } + cVar1 = FUN_004f6680(uVar2); + if (cVar1 == '\0') { + return 0; + } + } + else if (param_2 < (uint)param_1[2]) { + iVar3 = param_2 * 0xc; + uVar2 = param_2; + do { + puVar4 = (undefined4 *)(*param_1 + iVar3); + *puVar4 = local_c; + puVar4[1] = local_8; + puVar4[2] = local_4; + uVar2 = uVar2 + 1; + iVar3 = iVar3 + 0xc; + } while (uVar2 < (uint)param_1[2]); + } + param_1[2] = param_2; + return 1; +} + + + +// --- FUN_0044e2c0 at 0x0044E2C0 (size: 135) --- + +int * __thiscall FUN_0044e2c0(int *param_1,undefined4 *param_2) + +{ + undefined2 *puVar1; + char cVar2; + undefined2 *puVar3; + uint uVar4; + undefined2 *puVar5; + + if ((param_1[1] & 0x7fffffffU) < (param_2[1] & 0x7fffffff)) { + param_1[2] = 0; + cVar2 = FUN_0044e190(param_2[1] & 0x7fffffff); + if (cVar2 == '\0') { + return param_1; + } + } + puVar3 = (undefined2 *)*param_2; + puVar1 = puVar3 + param_2[2]; + puVar5 = (undefined2 *)*param_1; + for (; puVar3 < puVar1; puVar3 = puVar3 + 1) { + *puVar5 = *puVar3; + puVar5 = puVar5 + 1; + } + uVar4 = param_2[2]; + if (uVar4 < (uint)param_1[2]) { + do { + *(undefined2 *)(*param_1 + uVar4 * 2) = 0; + uVar4 = uVar4 + 1; + } while (uVar4 < (uint)param_1[2]); + } + param_1[2] = param_2[2]; + return param_1; +} + + + +// --- FUN_0044e350 at 0x0044E350 (size: 30) --- + +void * __thiscall FUN_0044e350(void *param_1,byte param_2) + +{ + FUN_0044df80(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0044e370 at 0x0044E370 (size: 30) --- + +void * __thiscall FUN_0044e370(void *param_1,byte param_2) + +{ + FUN_0044e050(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_0044e390 at 0x0044E390 (size: 140) --- + +void __thiscall FUN_0044e390(int param_1,int param_2) + +{ + uint *puVar1; + uint uVar2; + uint uVar3; + + uVar3 = *(uint *)(param_1 + 8); + FUN_0040ad10(4); + puVar1 = (uint *)FUN_0040acf0(4); + if (puVar1 != (uint *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + uVar3 = *puVar1; + } + else { + *puVar1 = uVar3; + } + } + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + uVar2 = FUN_0040a8f0(); + if (uVar2 < uVar3) { + FUN_0040aa50(); + return; + } + *(undefined4 *)(param_1 + 8) = 0; + FUN_0044e230(uVar3,1); + } + uVar3 = 0; + if (*(int *)(param_1 + 8) != 0) { + do { + FUN_0044db50(param_2); + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 8)); + } + return; +} + + + +// --- FUN_0044e420 at 0x0044E420 (size: 137) --- + +void __thiscall FUN_0044e420(int param_1,int param_2) + +{ + uint *puVar1; + uint uVar2; + uint uVar3; + + uVar3 = *(uint *)(param_1 + 8); + FUN_0040ad10(4); + puVar1 = (uint *)FUN_0040acf0(4); + if (puVar1 != (uint *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + uVar3 = *puVar1; + } + else { + *puVar1 = uVar3; + } + } + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + uVar2 = FUN_0040a8f0(); + if (uVar2 < uVar3) { + FUN_0040aa50(); + return; + } + *(undefined4 *)(param_1 + 8) = 0; + FUN_005d8710(uVar3,1); + } + uVar3 = 0; + if (*(int *)(param_1 + 8) != 0) { + do { + FUN_0044dbd0(param_2); + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 8)); + } + return; +} + + + +// --- FUN_0044e4b0 at 0x0044E4B0 (size: 142) --- + +void * __thiscall FUN_0044e4b0(void *param_1,byte param_2) + +{ + uint *puVar1; + int iVar2; + undefined4 *puVar3; + + if ((param_2 & 2) == 0) { + if ((*(uint *)((int)param_1 + 8) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)((int)param_1 + 4)); + } + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; + } + iVar2 = *(int *)((int)param_1 + -4); + if (-1 < iVar2 + -1) { + puVar3 = (undefined4 *)((int)param_1 + iVar2 * 0x10 + 4); + do { + puVar1 = puVar3 + -3; + puVar3 = puVar3 + -4; + if ((*puVar1 & 0x80000000) == 0x80000000) { + operator_delete__((void *)*puVar3); + } + iVar2 = iVar2 + -1; + } while (iVar2 != 0); + } + if ((param_2 & 1) != 0) { + operator_delete__((void *)((int)param_1 + -4)); + } + return (void *)((int)param_1 + -4); +} + + + +// --- FUN_0044e540 at 0x0044E540 (size: 129) --- + +void __fastcall FUN_0044e540(int *param_1) + +{ + uint uVar1; + int iVar2; + undefined4 local_10; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + param_1[2] = 0; + if ((param_1[1] & 0x80000000U) != 0x80000000) { + if (*param_1 != 0) { + uVar1 = param_1[1] & 0x7fffffff; + if (-1 < (int)(uVar1 - 1)) { + local_c = 0; + local_8 = 0; + local_4 = 0; + iVar2 = (uVar1 - 1) * 0x10; + do { + *(undefined4 *)(*param_1 + iVar2) = local_10; + FUN_0044e2c0(&local_c); + iVar2 = iVar2 + -0x10; + uVar1 = uVar1 - 1; + } while (uVar1 != 0); + } + } + return; + } + if (*param_1 != 0) { + FUN_0044e4b0(3); + } + *param_1 = 0; + param_1[1] = 0; + return; +} + + + +// --- FUN_0044e5d0 at 0x0044E5D0 (size: 64) --- + +void __thiscall FUN_0044e5d0(int param_1,int param_2) + +{ + char cVar1; + uint uVar2; + undefined4 uVar3; + + *(int *)(param_2 + 4) = *(int *)(param_2 + 4) + 1; + uVar2 = *(uint *)(param_1 + 0x10) & 0x7fffffff; + if (uVar2 <= *(uint *)(param_1 + 0x14)) { + uVar3 = FUN_00453850(uVar2 + 1); + cVar1 = FUN_004180a0(uVar3); + if (cVar1 == '\0') { + return; + } + } + *(int *)(*(int *)(param_1 + 0xc) + *(int *)(param_1 + 0x14) * 4) = param_2; + *(int *)(param_1 + 0x14) = *(int *)(param_1 + 0x14) + 1; + return; +} + + + +// --- FUN_0044e610 at 0x0044E610 (size: 452) --- + +undefined4 __thiscall FUN_0044e610(int param_1,int param_2,undefined4 param_3) + +{ + char cVar1; + int *piVar2; + int iVar3; + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined4 extraout_ECX_01; + undefined4 *puVar4; + undefined4 uVar5; + + if (param_2 == 0) { + return 0; + } + FUN_0065cf90(param_2); + piVar2 = (int *)FUN_0065c810(); + do { + if (piVar2 == (int *)0x0) { + FUN_0065cae0(); + return 1; + } + cVar1 = FUN_0065cc50(&DAT_0083c1ec); + if (cVar1 == '\0') { + cVar1 = FUN_0065cc50(&DAT_0083c204); + if (cVar1 == '\0') { + uVar5 = extraout_ECX_00; + FUN_00401340("Unrecognized keyword in mesh file"); + FUN_0065d670(piVar2,uVar5); + } + else { + iVar3 = FUN_005df0f5(0x34); + if (iVar3 == 0) { + puVar4 = (undefined4 *)0x0; + } + else { + puVar4 = (undefined4 *)FUN_0044f2c0(); + } + puVar4[3] = param_3; + cVar1 = FUN_0044f570(piVar2); + if (cVar1 == '\0') { + uVar5 = extraout_ECX_01; + FUN_00401340("Error parsing mesh batch"); + FUN_0065d620(piVar2,uVar5); + iVar3 = puVar4[1]; + puVar4[1] = iVar3 + -1; + if (iVar3 + -1 == 0) { + (**(code **)*puVar4)(1); + FUN_0065cae0(); + return 0; + } + goto LAB_0044e785; + } + FUN_0044e5d0(puVar4); + piVar2 = puVar4 + 1; + *piVar2 = *piVar2 + -1; + if (*piVar2 == 0) { + (**(code **)*puVar4)(1); + } + } + } + else { + *(undefined4 *)(param_1 + 8) = 0; + iVar3 = FUN_0065ca40(); + if (iVar3 == 0) { +LAB_0044e785: + FUN_0065cae0(); + return 0; + } + puVar4 = &DAT_0083c1f0; + (**(code **)(*piVar2 + 0xc))(0,&DAT_0083c1f0); + cVar1 = FUN_0065cc50(puVar4); + if (cVar1 == '\0') { + puVar4 = &DAT_0083c1f4; + (**(code **)(*piVar2 + 0xc))(0,&DAT_0083c1f4); + cVar1 = FUN_0065cc50(puVar4); + if (cVar1 == '\0') { + puVar4 = &DAT_0083c1f8; + (**(code **)(*piVar2 + 0xc))(0,&DAT_0083c1f8); + cVar1 = FUN_0065cc50(puVar4); + if (cVar1 == '\0') { + uVar5 = extraout_ECX; + FUN_00401340("Unrecognized mesh fragment type"); + FUN_0065d620(piVar2,uVar5); + goto LAB_0044e785; + } + *(undefined4 *)(param_1 + 8) = 4; + } + else { + *(undefined4 *)(param_1 + 8) = 2; + } + } + else { + *(undefined4 *)(param_1 + 8) = 1; + } + } + piVar2 = (int *)FUN_0065cb10(); + } while( true ); +} + + + +// --- FUN_0044e7e0 at 0x0044E7E0 (size: 388) --- + +/* WARNING: Removing unreachable block (ram,0x0044e934) */ +/* WARNING: Removing unreachable block (ram,0x0044e82c) */ +/* WARNING: Removing unreachable block (ram,0x0044e830) */ +/* WARNING: Removing unreachable block (ram,0x0044e83f) */ +/* WARNING: Removing unreachable block (ram,0x0044e850) */ +/* WARNING: Removing unreachable block (ram,0x0044e857) */ +/* WARNING: Removing unreachable block (ram,0x0044e85f) */ +/* WARNING: Removing unreachable block (ram,0x0044e8a6) */ +/* WARNING: Removing unreachable block (ram,0x0044e8b5) */ +/* WARNING: Removing unreachable block (ram,0x0044e8ca) */ +/* WARNING: Removing unreachable block (ram,0x0044e86b) */ +/* WARNING: Removing unreachable block (ram,0x0044e87c) */ +/* WARNING: Removing unreachable block (ram,0x0044e895) */ +/* WARNING: Removing unreachable block (ram,0x0044e8d5) */ +/* WARNING: Removing unreachable block (ram,0x0044e951) */ +/* WARNING: Removing unreachable block (ram,0x0044e8fa) */ +/* WARNING: Removing unreachable block (ram,0x0044e900) */ + +void __fastcall FUN_0044e7e0(int param_1) + +{ + if (*(int *)(param_1 + 0x18) == 0) { + FUN_005c0220(param_1 + 0xc); + *(undefined4 *)(param_1 + 0x14) = 0; + FUN_004180a0(*(undefined4 *)(param_1 + 0x14)); + *(undefined4 *)(param_1 + 0x14) = *(undefined4 *)(param_1 + 0x14); + } + return; +} + + + +// --- FUN_0044e970 at 0x0044E970 (size: 829) --- + +int * __thiscall FUN_0044e970(int param_1,int *param_2) + +{ + undefined2 *puVar1; + undefined2 *puVar2; + ushort uVar3; + ushort uVar4; + int iVar5; + int iVar6; + char cVar7; + int *piVar8; + uint uVar9; + uint uVar10; + ushort *puVar11; + uint uVar12; + int iVar13; + ushort *puVar14; + int iVar15; + uint uVar16; + int *piVar17; + uint local_2c; + uint local_28; + ushort local_20; + int local_18; + uint local_14; + int *local_c; + + iVar13 = param_2[2]; + iVar15 = 0; + piVar8 = param_2; + if (iVar13 != 0) { + piVar17 = (int *)*param_2; + do { + uVar12 = *(uint *)(*(int *)(*(int *)(*(int *)(*(int *)(*piVar17 + 0xc) + 0x40) + 8) + + *(int *)(*piVar17 + 0x18) * 4) + 4); + piVar8 = (int *)(uVar12 * -0x55555555); + iVar15 = iVar15 + uVar12 / 3; + piVar17 = piVar17 + 4; + iVar13 = iVar13 + -1; + } while (iVar13 != 0); + if (iVar15 != 0) { + FUN_004f6680(iVar15); + piVar8 = (int *)FUN_00459e20(iVar15 * 3); + local_c = (int *)0x0; + if (param_2[2] != 0) { + local_18 = 0; + do { + iVar13 = *(int *)(*param_2 + local_18); + iVar15 = *param_2 + local_18; + iVar13 = *(int *)(*(int *)(*(int *)(*(int *)(iVar13 + 0xc) + 0x40) + 8) + + *(int *)(iVar13 + 0x18) * 4); + puVar14 = *(ushort **)(iVar13 + 0x10); + for (uVar12 = *(uint *)(iVar13 + 4) / 3; uVar12 != 0; uVar12 = uVar12 - 1) { + iVar13 = *(int *)(param_1 + 0x18); + iVar5 = *(int *)(iVar13 + 0x1c); + uVar9 = *(uint *)(iVar13 + 0x18) & 0x7fffffff; + if (*(uint *)(iVar13 + 0x1c) < uVar9) { +LAB_0044eaa8: + *(int *)(iVar13 + 0x1c) = *(int *)(iVar13 + 0x1c) + 1; + } + else { + uVar9 = uVar9 + 1; + if (uVar9 < 9) { + uVar9 = 8; + } + else if (uVar9 < 0x4001) { + iVar6 = 0x1f; + if (uVar9 != 0) { + for (; uVar9 >> iVar6 == 0; iVar6 = iVar6 + -1) { + } + } + uVar10 = 1 << ((byte)iVar6 & 0x1f); + if (uVar10 < uVar9) { + uVar9 = uVar10 * 2; + } + } + else if ((uVar9 & 0x3fff) != 0) { + uVar9 = uVar9 + (0x4000 - (uVar9 & 0x3fff)); + } + cVar7 = FUN_004f6680(uVar9); + if (cVar7 != '\0') goto LAB_0044eaa8; + } + puVar1 = (undefined2 *)(*(int *)(*(int *)(param_1 + 0x18) + 0x14) + iVar5 * 0xc); + local_14 = 0; + do { + if (local_14 == 0) { + iVar13 = *(int *)(iVar15 + 4); + uVar3 = *(ushort *)(iVar13 + (uint)*puVar14 * 2); + uVar4 = puVar14[1]; +LAB_0044eb18: + local_2c = (uint)uVar3; + local_28 = (uint)*(ushort *)(iVar13 + (uint)uVar4 * 2); + } + else { + if (local_14 == 1) { + iVar13 = *(int *)(iVar15 + 4); + uVar3 = *(ushort *)(iVar13 + (uint)puVar14[1] * 2); + uVar4 = puVar14[2]; + goto LAB_0044eb18; + } + if (local_14 == 2) { + local_2c = (uint)*(ushort *)(*(int *)(iVar15 + 4) + (uint)puVar14[2] * 2); + local_28 = (uint)*(ushort *)(*(int *)(iVar15 + 4) + (uint)*puVar14 * 2); + } + } + iVar13 = *(int *)(param_1 + 0x18); + uVar9 = *(uint *)(iVar13 + 0x28); + uVar10 = 0; + local_20 = (ushort)iVar5; + if (uVar9 != 0) { + puVar11 = *(ushort **)(iVar13 + 0x20); + do { + if (((*puVar11 == local_28) && (puVar11[1] == local_2c)) && (puVar11[3] == 0xffff) + ) { + if (uVar10 != 0xffff) { + (*(ushort **)(iVar13 + 0x20))[uVar10 * 4 + 3] = local_20; + goto LAB_0044ec1f; + } + break; + } + uVar10 = uVar10 + 1; + puVar11 = puVar11 + 4; + } while (uVar10 < uVar9); + } + uVar10 = *(uint *)(iVar13 + 0x24) & 0x7fffffff; + if (*(uint *)(iVar13 + 0x28) < uVar10) { +LAB_0044ebdd: + *(int *)(iVar13 + 0x28) = *(int *)(iVar13 + 0x28) + 1; + } + else { + uVar10 = uVar10 + 1; + if (uVar10 < 9) { + uVar10 = 8; + } + else if (uVar10 < 0x4001) { + iVar6 = 0x1f; + if (uVar10 != 0) { + for (; uVar10 >> iVar6 == 0; iVar6 = iVar6 + -1) { + } + } + uVar16 = 1 << ((byte)iVar6 & 0x1f); + if (uVar16 < uVar10) { + uVar10 = uVar16 * 2; + } + } + else if ((uVar10 & 0x3fff) != 0) { + uVar10 = uVar10 + (0x4000 - (uVar10 & 0x3fff)); + } + cVar7 = FUN_00459e20(uVar10); + if (cVar7 != '\0') goto LAB_0044ebdd; + } + puVar2 = (undefined2 *)(*(int *)(*(int *)(param_1 + 0x18) + 0x20) + uVar9 * 8); + *puVar2 = (undefined2)local_2c; + puVar2[1] = (undefined2)local_28; + puVar2[2] = local_20; + puVar2[3] = 0xffff; + uVar10 = uVar9; +LAB_0044ec1f: + puVar1[local_14 + 3] = (short)uVar10; + local_14 = local_14 + 1; + } while (local_14 < 3); + *puVar1 = *(undefined2 *)(*(int *)(iVar15 + 4) + (uint)*puVar14 * 2); + puVar1[1] = *(undefined2 *)(*(int *)(iVar15 + 4) + (uint)puVar14[1] * 2); + puVar11 = puVar14 + 2; + puVar14 = puVar14 + 3; + puVar1[2] = *(undefined2 *)(*(int *)(iVar15 + 4) + (uint)*puVar11 * 2); + } + piVar8 = (int *)((int)local_c + 1); + local_18 = local_18 + 0x10; + local_c = piVar8; + } while (piVar8 < (int *)param_2[2]); + } + } + } + return piVar8; +} + + + +// --- FUN_0044ecb0 at 0x0044ECB0 (size: 221) --- + +undefined4 __thiscall FUN_0044ecb0(int *param_1,uint param_2) + +{ + uint *puVar1; + int iVar2; + uint uVar3; + uint *puVar4; + int iVar5; + + uVar3 = param_2; + if ((uint)param_1[2] <= param_2) { + if (param_2 <= (param_1[1] & 0x7fffffffU)) { + return 1; + } + if (param_2 == 0) { + FUN_0044e540(); + return 1; + } + puVar4 = (uint *)thunk_FUN_005df0f5(param_2 * 0x10 + 4); + if (puVar4 != (uint *)0x0) { + puVar1 = puVar4 + 1; + *puVar4 = param_2; + FUN_00401000(puVar1,0x10,param_2,&LAB_0044dee0); + if (puVar1 != (uint *)0x0) { + if (*param_1 != 0) { + param_2 = param_1[2]; + if (-1 < (int)(param_2 + -1)) { + iVar5 = (param_2 + -1) * 0x10; + do { + iVar2 = *param_1; + *(undefined4 *)(iVar5 + (int)puVar1) = *(undefined4 *)(iVar2 + iVar5); + FUN_0044e2c0(iVar2 + iVar5 + 4); + iVar5 = iVar5 + -0x10; + param_2 = param_2 + -1; + } while (param_2 != 0); + } + if (((param_1[1] & 0x80000000U) == 0x80000000) && (*param_1 != 0)) { + FUN_0044e4b0(3); + } + } + *param_1 = (int)puVar1; + param_1[1] = uVar3 | 0x80000000; + return 1; + } + } + } + return 0; +} + + + +// --- FUN_0044ed90 at 0x0044ED90 (size: 411) --- + +void __thiscall FUN_0044ed90(int param_1,uint param_2,undefined4 param_3) + +{ + int iVar1; + char cVar2; + undefined4 *puVar3; + uint *puVar4; + int iVar5; + undefined4 uVar6; + uint uVar7; + undefined4 uVar8; + char *pcVar9; + uint uVar10; + + iVar1 = param_2; + FUN_0040ad10(4); + puVar3 = (undefined4 *)FUN_0040acf0(4); + if (puVar3 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 8) = *puVar3; + } + else { + *puVar3 = *(undefined4 *)(param_1 + 8); + } + } + uVar10 = *(uint *)(param_1 + 0x14); + FUN_0040ad10(4); + puVar4 = (uint *)FUN_0040acf0(4); + if (puVar4 != (uint *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + uVar10 = *puVar4; + } + else { + *puVar4 = uVar10; + } + } + param_2 = uVar10; + uVar10 = 0; + if (param_2 != 0) { + do { + if ((~*(byte *)(iVar1 + 4) & 1) != 0) { + iVar5 = FUN_005df0f5(0x34); + if (iVar5 == 0) { + uVar6 = 0; + } + else { + uVar6 = FUN_0044f2c0(); + } + uVar7 = *(uint *)(param_1 + 0x10) & 0x7fffffff; + if (uVar7 <= *(uint *)(param_1 + 0x14)) { + uVar8 = FUN_00453850(uVar7 + 1); + cVar2 = FUN_004180a0(uVar8); + if (cVar2 == '\0') goto LAB_0044ee58; + } + *(undefined4 *)(*(int *)(param_1 + 0xc) + *(int *)(param_1 + 0x14) * 4) = uVar6; + *(int *)(param_1 + 0x14) = *(int *)(param_1 + 0x14) + 1; + } +LAB_0044ee58: + FUN_0044f450(iVar1,param_3); + uVar10 = uVar10 + 1; + } while (uVar10 < param_2); + } + cVar2 = *(int *)(param_1 + 0x18) != 0; + FUN_0040ad10(1); + pcVar9 = (char *)FUN_0040acf0(1); + if (pcVar9 != (char *)0x0) { + if ((*(byte *)(iVar1 + 4) & 1) == 0) { + cVar2 = *pcVar9; + } + else { + *pcVar9 = cVar2; + } + } + if ((*(byte *)(iVar1 + 4) & 5) == 0) { + if (cVar2 == '\0') { + return; + } + if (cVar2 != '\x01') { + FUN_0040aa50(); + } + } + if (cVar2 != '\0') { + if ((~*(byte *)(iVar1 + 4) & 1) != 0) { + puVar3 = (undefined4 *)FUN_005df0f5(0x2c); + if (puVar3 == (undefined4 *)0x0) { + puVar3 = (undefined4 *)0x0; + } + else { + puVar3[1] = 1; + *puVar3 = &PTR_FUN_0079c344; + puVar3[2] = 0; + puVar3[3] = 0; + puVar3[4] = 0; + puVar3[5] = 0; + puVar3[6] = 0; + puVar3[7] = 0; + puVar3[8] = 0; + puVar3[9] = 0; + puVar3[10] = 0; + } + *(undefined4 **)(param_1 + 0x18) = puVar3; + } + FUN_0044e0c0(iVar1); + FUN_0044e390(iVar1); + FUN_0044e420(iVar1); + } + return; +} + + + +// --- FUN_0044ef30 at 0x0044EF30 (size: 681) --- + +void __thiscall FUN_0044ef30(int param_1,int *param_2,int *param_3) + +{ + undefined4 *puVar1; + int *piVar2; + int iVar3; + int iVar4; + int iVar5; + char cVar6; + undefined4 uVar7; + int iVar8; + uint uVar9; + uint uVar10; + undefined4 *puVar11; + uint uVar12; + uint local_14; + undefined4 local_10; + + local_14 = 0; + if (*(int *)(param_1 + 0x14) != 0) { + do { + iVar8 = *(int *)(*(int *)(param_1 + 0xc) + local_14 * 4); + if (((*(int *)(iVar8 + 0x10) == -1) || + (iVar3 = *(int *)(*(int *)(*(int *)(*(int *)(iVar8 + 0xc) + 0x38) + 8) + 4 + + *(int *)(iVar8 + 0x10) * 8), iVar3 == 0)) || + ((*(char *)(iVar3 + 0x4c) != '\0' && (*(char *)(iVar3 + 0x4d) == '\0')))) { + iVar3 = *(int *)(*(int *)(*(int *)(*(int *)(iVar8 + 0xc) + 0x3c) + 8) + + *(int *)(iVar8 + 0x14) * 4); + if ((uint)param_3[2] < (param_3[1] & 0x7fffffffU)) { +LAB_0044efc4: + param_3[2] = param_3[2] + 1; + } + else { + uVar7 = FUN_00453850((param_3[1] & 0x7fffffffU) + 1); + cVar6 = FUN_0044ecb0(uVar7); + if (cVar6 != '\0') goto LAB_0044efc4; + } + piVar2 = (int *)(param_3[2] * 0x10 + -0x10 + *param_3); + *piVar2 = iVar8; + uVar10 = 0; + if (*(int *)(iVar3 + 0x7c) != 0) { + do { + puVar11 = (undefined4 *)(*(int *)(iVar3 + 0xc) * uVar10 + *(int *)(iVar3 + 0x80)); + iVar8 = FUN_0044dae0(puVar11); + if (iVar8 == -1) { + if ((uint)param_2[2] < (param_2[1] & 0x7fffffffU)) { +LAB_0044f084: + puVar1 = (undefined4 *)(*param_2 + param_2[2] * 0xc); + *puVar1 = *puVar11; + puVar1[1] = puVar11[1]; + puVar1[2] = puVar11[2]; + param_2[2] = param_2[2] + 1; + } + else { + uVar9 = (param_2[1] & 0x7fffffffU) + 1; + if (uVar9 < 9) { + uVar9 = 8; + } + else if (uVar9 < 0x4001) { + iVar8 = 0x1f; + if (uVar9 != 0) { + for (; uVar9 >> iVar8 == 0; iVar8 = iVar8 + -1) { + } + } + uVar12 = 1 << ((byte)iVar8 & 0x1f); + if (uVar12 < uVar9) { + uVar9 = uVar12 * 2; + } + } + else if ((uVar9 & 0x3fff) != 0) { + uVar9 = uVar9 + (0x4000 - (uVar9 & 0x3fff)); + } + cVar6 = FUN_0044de10(uVar9); + if (cVar6 != '\0') goto LAB_0044f084; + } + iVar4 = *(int *)(param_1 + 0x18); + iVar8 = *(int *)(iVar4 + 0x10); + local_10 = CONCAT31(local_10._1_3_,(undefined1)local_14); + uVar9 = *(uint *)(iVar4 + 0xc) & 0x7fffffff; + local_10 = CONCAT22((short)uVar10,(undefined2)local_10); + if (uVar9 <= *(uint *)(iVar4 + 0x10)) { + uVar9 = uVar9 + 1; + if (uVar9 < 9) { + uVar9 = 8; + } + else if (uVar9 < 0x4001) { + iVar5 = 0x1f; + if (uVar9 != 0) { + for (; uVar9 >> iVar5 == 0; iVar5 = iVar5 + -1) { + } + } + uVar12 = 1 << ((byte)iVar5 & 0x1f); + if (uVar12 < uVar9) { + uVar9 = uVar12 * 2; + } + } + else if ((uVar9 & 0x3fff) != 0) { + uVar9 = uVar9 + (0x4000 - (uVar9 & 0x3fff)); + } + cVar6 = FUN_0044dd10(uVar9); + if (cVar6 == '\0') goto LAB_0044f133; + } + *(undefined4 *)(*(int *)(iVar4 + 8) + *(int *)(iVar4 + 0x10) * 4) = local_10; + *(int *)(iVar4 + 0x10) = *(int *)(iVar4 + 0x10) + 1; + } +LAB_0044f133: + if ((uint)piVar2[3] < (piVar2[2] & 0x7fffffffU)) { +LAB_0044f19b: + *(short *)(piVar2[1] + piVar2[3] * 2) = (short)iVar8; + piVar2[3] = piVar2[3] + 1; + } + else { + uVar9 = (piVar2[2] & 0x7fffffffU) + 1; + if (uVar9 < 9) { + uVar9 = 8; + } + else if (uVar9 < 0x4001) { + iVar4 = 0x1f; + if (uVar9 != 0) { + for (; uVar9 >> iVar4 == 0; iVar4 = iVar4 + -1) { + } + } + uVar12 = 1 << ((byte)iVar4 & 0x1f); + if (uVar12 < uVar9) { + uVar9 = uVar12 * 2; + } + } + else if ((uVar9 & 0x3fff) != 0) { + uVar9 = uVar9 + (0x4000 - (uVar9 & 0x3fff)); + } + cVar6 = FUN_0044e190(uVar9); + if (cVar6 != '\0') goto LAB_0044f19b; + } + uVar10 = uVar10 + 1; + } while (uVar10 < *(uint *)(iVar3 + 0x7c)); + } + } + local_14 = local_14 + 1; + } while (local_14 < *(uint *)(param_1 + 0x14)); + } + return; +} + + + +// --- FUN_0044f1e0 at 0x0044F1E0 (size: 212) --- + +void __fastcall FUN_0044f1e0(int param_1) + +{ + int *piVar1; + undefined4 *puVar2; + int iStack_18; + uint uStack_14; + undefined4 uStack_10; + void *pvStack_c; + uint uStack_8; + undefined4 uStack_4; + + puVar2 = *(undefined4 **)(param_1 + 0x18); + if (puVar2 != (undefined4 *)0x0) { + piVar1 = puVar2 + 1; + *piVar1 = *piVar1 + -1; + if (*piVar1 == 0) { + (**(code **)*puVar2)(1); + } + *(undefined4 *)(param_1 + 0x18) = 0; + } + puVar2 = (undefined4 *)FUN_005df0f5(0x2c); + if (puVar2 == (undefined4 *)0x0) { + puVar2 = (undefined4 *)0x0; + } + else { + puVar2[1] = 1; + *puVar2 = &PTR_FUN_0079c344; + puVar2[2] = 0; + puVar2[3] = 0; + puVar2[4] = 0; + puVar2[5] = 0; + puVar2[6] = 0; + puVar2[7] = 0; + puVar2[8] = 0; + puVar2[9] = 0; + puVar2[10] = 0; + } + *(undefined4 **)(param_1 + 0x18) = puVar2; + iStack_18 = 0; + uStack_14 = 0; + uStack_10 = 0; + pvStack_c = (void *)0x0; + uStack_8 = 0; + uStack_4 = 0; + FUN_0044ef30(&pvStack_c,&iStack_18); + FUN_0044e970(&iStack_18); + if ((uStack_8 & 0x80000000) == 0x80000000) { + operator_delete__(pvStack_c); + } + if (((uStack_14 & 0x80000000) == 0x80000000) && (iStack_18 != 0)) { + FUN_0044e4b0(3); + } + return; +} + + + +// --- FUN_0044f2c0 at 0x0044F2C0 (size: 58) --- + +void __fastcall FUN_0044f2c0(undefined4 *param_1) + +{ + param_1[1] = 1; + *param_1 = &PTR_LAB_0079c38c; + param_1[2] = 0x7fffffff; + param_1[3] = 0; + param_1[4] = 0xffffffff; + param_1[5] = 0xffffffff; + param_1[6] = 0xffffffff; + param_1[7] = 0; + param_1[8] = 0; + param_1[9] = 0; + param_1[10] = 0; + param_1[0xb] = 0xffffffff; + param_1[0xc] = 0xffffffff; + return; +} + + + +// --- FUN_0044f330 at 0x0044F330 (size: 254) --- + +uint __thiscall +FUN_0044f330(int param_1,int *param_2,undefined4 param_3,int param_4,uint param_5,undefined4 param_6 + ,undefined4 param_7,undefined4 param_8,int *param_9) + +{ + undefined4 *puVar1; + int *piVar2; + uint uVar3; + undefined4 uVar4; + int iVar5; + undefined3 uVar6; + + *param_9 = 0; + if (param_4 == -1) { + piVar2 = (int *)FUN_00447e40(); + *param_9 = (int)piVar2; + uVar3 = (**(code **)(*piVar2 + 4))(param_5,param_6,param_7,param_8,0xffffffff); + if ((char)uVar3 == '\0') { + puVar1 = (undefined4 *)*param_9; + if (puVar1 != (undefined4 *)0x0) { + piVar2 = puVar1 + 1; + *piVar2 = *piVar2 + -1; + if (*piVar2 == 0) { + uVar3 = (**(code **)*puVar1)(1); + } + *param_9 = 0; + } + return uVar3 & 0xffffff00; + } + } + *(undefined4 *)(param_1 + 8) = param_3; + if (param_2 != (int *)0x0) { + (**(code **)(*param_2 + 0x10))(); + uVar4 = FUN_00445630(DAT_0083c4ac,param_2); + *(undefined4 *)(param_1 + 0x10) = uVar4; + } + if (param_4 == -1) { + param_4 = FUN_004456c0(*param_9); + } + *(int *)(param_1 + 0x14) = param_4; + *(undefined4 *)(param_1 + 0x1c) = 0; + *(undefined4 *)(param_1 + 0x20) = 0; + iVar5 = *(int *)(param_1 + 8) + -1; + uVar6 = (undefined3)((uint)iVar5 >> 8); + switch(iVar5) { + case 1: + *(uint *)(param_1 + 0x20) = param_5 >> 1; + return CONCAT31(uVar6,1); + case 2: + *(uint *)(param_1 + 0x20) = param_5 - 1; + return CONCAT31(uVar6,1); + case 3: + *(uint *)(param_1 + 0x20) = param_5 / 3; + return CONCAT31((int3)((ulonglong)param_5 * 0xaaaaaaab >> 8),1); + case 4: + case 5: + param_5 = param_5 - 2; + case 0: + *(uint *)(param_1 + 0x20) = param_5; + default: + return CONCAT31(uVar6,1); + } +} + + + +// --- FUN_0044f450 at 0x0044F450 (size: 283) --- + +void __thiscall FUN_0044f450(int param_1,int param_2,undefined4 param_3) + +{ + byte *pbVar1; + undefined4 *puVar2; + byte bVar3; + + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + *(undefined4 *)(param_1 + 0xc) = param_3; + } + bVar3 = *(byte *)(param_1 + 8); + FUN_0040ad10(1); + pbVar1 = (byte *)FUN_0040acf0(1); + if (pbVar1 != (byte *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + bVar3 = *pbVar1; + } + else { + *pbVar1 = bVar3; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + *(uint *)(param_1 + 8) = (uint)bVar3; + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x10) = *puVar2; + } + else { + *puVar2 = *(undefined4 *)(param_1 + 0x10); + } + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x14) = *puVar2; + } + else { + *puVar2 = *(undefined4 *)(param_1 + 0x14); + } + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x18) = *puVar2; + } + else { + *puVar2 = *(undefined4 *)(param_1 + 0x18); + } + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0x1c) = *puVar2; + } + else { + *puVar2 = *(undefined4 *)(param_1 + 0x1c); + } + } + FUN_0040ad10(4); + puVar2 = (undefined4 *)FUN_0040acf0(4); + if (puVar2 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *puVar2 = *(undefined4 *)(param_1 + 0x20); + return; + } + *(undefined4 *)(param_1 + 0x20) = *puVar2; + } + return; +} + + + +// --- FUN_0044f570 at 0x0044F570 (size: 846) --- + +undefined4 __thiscall FUN_0044f570(int param_1,undefined *param_2) + +{ + char cVar1; + int *piVar2; + int iVar3; + LONG LVar4; + undefined4 uVar5; + undefined4 extraout_ECX; + undefined4 extraout_ECX_00; + undefined4 extraout_ECX_01; + undefined4 extraout_ECX_02; + undefined4 extraout_ECX_03; + undefined4 extraout_ECX_04; + undefined4 *puVar6; + undefined1 auStack_10 [16]; + + if (param_2 != (undefined *)0x0) { + FUN_0065cf90(param_2); + piVar2 = (int *)FUN_0065c810(); + while (piVar2 != (int *)0x0) { + cVar1 = FUN_0065cc50(&DAT_0083c3b0); + if (cVar1 == '\0') { + cVar1 = FUN_0065cc50(&DAT_0083c3cc); + if (cVar1 == '\0') { + cVar1 = FUN_0065cc50(&DAT_0083c3d0); + if (cVar1 == '\0') { + cVar1 = FUN_0065cc50(&DAT_0083c3d4); + if (cVar1 == '\0') { + uVar5 = extraout_ECX_03; + FUN_00401340("Unrecognized keyword in mesh file"); + FUN_0065d670(piVar2,uVar5); + } + else { + puVar6 = (undefined4 *)FUN_0044cc60(); + uVar5 = (**(code **)(*piVar2 + 0xc))(0); + cVar1 = FUN_0044cec0(uVar5); + if (cVar1 == '\0') { + uVar5 = extraout_ECX_04; + FUN_00401340("Error loading index array"); + FUN_0065d620(piVar2,uVar5); + if (puVar6 != (undefined4 *)0x0) { + puVar6 = (undefined4 *)*puVar6; + goto LAB_0044f70b; + } + goto LAB_0044f70d; + } + uVar5 = FUN_00445740(puVar6); + *(undefined4 *)(param_1 + 0x18) = uVar5; + } + } + else { + puVar6 = (undefined4 *)FUN_00447e40(); + uVar5 = (**(code **)(*piVar2 + 0xc))(0); + cVar1 = FUN_005d9280(uVar5); + if (cVar1 == '\0') { + uVar5 = extraout_ECX_02; + FUN_00401340("Error loading vertex array"); + FUN_0065d620(piVar2,uVar5); + if (puVar6 != (undefined4 *)0x0) { + piVar2 = puVar6 + 1; + *piVar2 = *piVar2 + -1; + if (*piVar2 == 0) { + (**(code **)*puVar6)(1); + } + } + goto LAB_0044f70d; + } + uVar5 = FUN_004456c0(puVar6); + *(undefined4 *)(param_1 + 0x14) = uVar5; + } + } + else { + param_2 = PTR_DAT_00818344; + InterlockedIncrement((LONG *)(PTR_DAT_00818344 + -0x10)); + iVar3 = (**(code **)(*piVar2 + 0xc))(0); + uVar5 = extraout_ECX_00; + if (iVar3 != 0) { + FUN_00426020(¶m_2); + uVar5 = extraout_ECX_01; + } + iVar3 = DAT_0083c4ac; + if (*(int *)(param_2 + -4) == 1) { + FUN_00401340("Material file name is empty!"); + FUN_0065d670(piVar2,uVar5); + } + else { + piVar2 = (int *)FUN_006791f0(auStack_10,¶m_2,0x21); + iVar3 = *piVar2; + if (iVar3 == DAT_0083c4ac) { + puVar6 = (undefined4 *)(param_2 + -0x14); + LVar4 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar4 == 0) && (puVar6 != (undefined4 *)0x0)) { + puVar6 = (undefined4 *)*puVar6; +LAB_0044f70b: + (*(code *)*puVar6)(1); + } + goto LAB_0044f70d; + } + } + uVar5 = FUN_00445630(iVar3,0); + puVar6 = (undefined4 *)(param_2 + -0x14); + *(undefined4 *)(param_1 + 0x10) = uVar5; + LVar4 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar4 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + } + } + else { + iVar3 = (**(code **)(*piVar2 + 0xc))(0); + if (iVar3 == 0) goto LAB_0044f70d; + cVar1 = FUN_0065cc50(&DAT_0083c3b4); + if (cVar1 == '\0') { + cVar1 = FUN_0065cc50(&DAT_0083c3b8); + if (cVar1 == '\0') { + cVar1 = FUN_0065cc50(&DAT_0083c3bc); + if (cVar1 == '\0') { + cVar1 = FUN_0065cc50(&DAT_0083c3c0); + if (cVar1 == '\0') { + cVar1 = FUN_0065cc50(&DAT_0083c3c4); + if (cVar1 == '\0') { + cVar1 = FUN_0065cc50(&DAT_0083c3c8); + if (cVar1 == '\0') { + uVar5 = extraout_ECX; + FUN_00401340("Unrecognized primitives type"); + FUN_0065d620(iVar3,uVar5); + goto LAB_0044f70d; + } + *(undefined4 *)(param_1 + 8) = 6; + } + else { + *(undefined4 *)(param_1 + 8) = 5; + } + } + else { + *(undefined4 *)(param_1 + 8) = 4; + } + } + else { + *(undefined4 *)(param_1 + 8) = 3; + } + } + else { + *(undefined4 *)(param_1 + 8) = 2; + } + } + else { + *(undefined4 *)(param_1 + 8) = 1; + } + } + piVar2 = (int *)FUN_0065cb10(); + } + if ((*(int *)(param_1 + 0x14) != -1) && (*(int *)(param_1 + 8) != 0x7fffffff)) { + FUN_0065cae0(); + return 1; + } +LAB_0044f70d: + FUN_0065cae0(); + } + return 0; +} + + + +// --- FUN_0044f8d0 at 0x0044F8D0 (size: 72) --- + +void __thiscall FUN_0044f8d0(int param_1,undefined4 *param_2) + +{ + *(undefined4 *)(param_1 + 8) = *param_2; + *(undefined4 *)(param_1 + 0xc) = param_2[1]; + *(undefined4 *)(param_1 + 0x10) = param_2[2]; + *(undefined4 *)(param_1 + 0x14) = param_2[3]; + *(undefined4 *)(param_1 + 0x18) = param_2[4]; + *(undefined4 *)(param_1 + 0x1c) = param_2[5]; + *(undefined4 *)(param_1 + 0x20) = param_2[6]; + *(undefined4 *)(param_1 + 0x24) = param_2[7]; + *(undefined4 *)(param_1 + 0x28) = param_2[8]; + *(undefined4 *)(param_1 + 0x2c) = param_2[9]; + *(undefined4 *)(param_1 + 0x30) = param_2[10]; + return; +} + + + +// --- FUN_0044f920 at 0x0044F920 (size: 72) --- + +void __thiscall FUN_0044f920(int param_1,undefined4 *param_2) + +{ + *(undefined4 *)(param_1 + 0x34) = *param_2; + *(undefined4 *)(param_1 + 0x38) = param_2[1]; + *(undefined4 *)(param_1 + 0x3c) = param_2[2]; + *(undefined4 *)(param_1 + 0x40) = param_2[3]; + *(undefined4 *)(param_1 + 0x44) = param_2[4]; + *(undefined4 *)(param_1 + 0x48) = param_2[5]; + *(undefined4 *)(param_1 + 0x4c) = param_2[6]; + *(undefined4 *)(param_1 + 0x50) = param_2[7]; + *(undefined4 *)(param_1 + 0x54) = param_2[8]; + *(undefined4 *)(param_1 + 0x58) = param_2[9]; + *(undefined4 *)(param_1 + 0x5c) = param_2[10]; + return; +} + + + +// --- FUN_0044f970 at 0x0044F970 (size: 72) --- + +void __thiscall FUN_0044f970(int param_1,undefined4 *param_2) + +{ + *(undefined4 *)(param_1 + 0x50) = *param_2; + *(undefined4 *)(param_1 + 0x54) = param_2[1]; + *(undefined4 *)(param_1 + 0x58) = param_2[2]; + *(undefined4 *)(param_1 + 0x5c) = param_2[3]; + *(undefined4 *)(param_1 + 0x60) = param_2[4]; + *(undefined4 *)(param_1 + 100) = param_2[5]; + *(undefined4 *)(param_1 + 0x68) = param_2[6]; + *(undefined4 *)(param_1 + 0x6c) = param_2[7]; + *(undefined4 *)(param_1 + 0x70) = param_2[8]; + *(undefined4 *)(param_1 + 0x74) = param_2[9]; + *(undefined4 *)(param_1 + 0x78) = param_2[10]; + return; +} + + + +// --- FUN_0044f9c0 at 0x0044F9C0 (size: 105) --- + +void __thiscall FUN_0044f9c0(int param_1,undefined4 *param_2) + +{ + *(undefined4 *)(param_1 + 0x9c) = *param_2; + *(undefined4 *)(param_1 + 0xa0) = param_2[1]; + *(undefined4 *)(param_1 + 0xa4) = param_2[2]; + *(undefined4 *)(param_1 + 0xa8) = param_2[3]; + *(undefined4 *)(param_1 + 0xac) = param_2[4]; + *(undefined4 *)(param_1 + 0xb0) = param_2[5]; + *(undefined4 *)(param_1 + 0xb4) = param_2[6]; + *(undefined4 *)(param_1 + 0xb8) = param_2[7]; + *(undefined4 *)(param_1 + 0xbc) = param_2[8]; + *(undefined4 *)(param_1 + 0xc0) = param_2[9]; + *(undefined4 *)(param_1 + 0xc4) = param_2[10]; + return; +} + + + +// --- FUN_0044fa30 at 0x0044FA30 (size: 28) --- + +undefined1 __fastcall FUN_0044fa30(int param_1) + +{ + char cVar1; + + cVar1 = FUN_00413a70(); + if (cVar1 != '\0') { + FUN_0054d2e0(param_1 + 0x28); + } + return 1; +} + + + +// --- FUN_0044fa50 at 0x0044FA50 (size: 151) --- + +void __fastcall FUN_0044fa50(int *param_1) + +{ + undefined *puVar1; + LONG LVar2; + LONG *pLVar3; + + puVar1 = (undefined *)*param_1; + if (puVar1 != PTR_DAT_00818344) { + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + pLVar3 = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = (int)PTR_DAT_00818344; + InterlockedIncrement(pLVar3); + } + param_1[1] = 0; + param_1[2] = 0x7fffffff; + param_1[3] = 0; + param_1[4] = 0; + puVar1 = (undefined *)param_1[5]; + if (puVar1 != PTR_DAT_00818344) { + LVar2 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar2 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + pLVar3 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[5] = (int)PTR_DAT_00818344; + InterlockedIncrement(pLVar3); + } + param_1[10] = 0; + return; +} + + + +// --- FUN_0044faf0 at 0x0044FAF0 (size: 157) --- + +void __thiscall FUN_0044faf0(int param_1,int param_2,int param_3) + +{ + undefined4 *puVar1; + int iVar2; + undefined4 *puVar3; + int iVar4; + uint uVar5; + + if ((*(char *)(param_1 + 0x18) == '\0') && (uVar5 = 0, *(int *)(param_3 + 0x24) != 0)) { + do { + puVar3 = *(undefined4 **)(*(int *)(param_3 + 0x1c) + uVar5 * 4); + iVar2 = 0; + if ((uint)puVar3[2] < *(uint *)(param_2 + 0x80)) { + iVar2 = *(int *)(*(int *)(param_2 + 0x78) + puVar3[2] * 4); + } + iVar4 = 0; + if ((iVar2 != 0) && ((uint)puVar3[3] < *(uint *)(iVar2 + 0x24))) { + iVar4 = *(int *)(*(int *)(iVar2 + 0x1c) + puVar3[3] * 4); + } + switch(*puVar3) { + case 0: + puVar3 = *(undefined4 **)(param_1 + 0x10); + *(undefined4 *)(iVar2 + 0x7c) = *puVar3; + *(undefined4 *)(iVar2 + 0x80) = puVar3[1]; + *(undefined4 *)(iVar2 + 0x84) = puVar3[2]; + *(undefined4 *)(iVar2 + 0x88) = puVar3[3]; + break; + case 1: + puVar3 = (undefined4 *)(iVar2 + 0x8c); + goto LAB_0044fbb3; + case 2: + FUN_0044f9c0(*(undefined4 *)(param_1 + 0x10)); + break; + case 3: + puVar3 = (undefined4 *)(iVar2 + 200); +LAB_0044fbb3: + puVar1 = *(undefined4 **)(param_1 + 0x10); + *puVar3 = *puVar1; + puVar3[1] = puVar1[1]; + puVar3[2] = puVar1[2]; + puVar3[3] = puVar1[3]; + break; + case 4: + *(uint *)(iVar2 + 0x48) = (**(int **)(param_1 + 0x10) == 0) + 1; + break; + case 5: + *(uint *)(iVar2 + 0x40) = (uint)(**(int **)(param_1 + 0x10) == 0) * 4 + 4; + break; + case 6: + *(bool *)(iVar2 + 0x44) = **(int **)(param_1 + 0x10) != 0; + break; + case 7: + *(bool *)(iVar2 + 0x4c) = **(int **)(param_1 + 0x10) != 0; + break; + case 8: + FUN_0044f970(*(undefined4 *)(param_1 + 0x10)); + break; + case 9: + if (*(int *)(param_1 + 8) == 3000) { + FUN_00448140(param_1 + 0x14,**(undefined4 **)(param_1 + 0x10)); + } + else if (*(int *)(param_1 + 8) == 10000) { + FUN_00448200(**(undefined4 **)(param_1 + 0x10)); + } + break; + case 10: + *(uint *)(iVar4 + 0x14) = (uint)(**(int **)(param_1 + 0x10) == 0) * 2 + 1; + break; + case 0xb: + *(uint *)(iVar4 + 0x18) = (uint)(**(int **)(param_1 + 0x10) == 0) * 2 + 1; + break; + case 0x20: + FUN_0044f8d0(*(undefined4 *)(param_1 + 0x10)); + break; + case 0x21: + FUN_0044f920(*(undefined4 *)(param_1 + 0x10)); + break; + case 0x22: + FUN_0044f8d0(*(undefined4 *)(param_1 + 0x10)); + break; + case 0x23: + FUN_0044f8d0(*(undefined4 *)(param_1 + 0x10)); + break; + case 0x24: + FUN_0044f920(*(undefined4 *)(param_1 + 0x10)); + } + uVar5 = uVar5 + 1; + } while (uVar5 < *(uint *)(param_3 + 0x24)); + } + return; +} + + + +// --- FUN_0044fd50 at 0x0044FD50 (size: 93) --- + +undefined4 __fastcall FUN_0044fd50(int param_1) + +{ + char cVar1; + undefined4 uVar2; + int iVar3; + + cVar1 = FUN_00413a70(); + if (((cVar1 != '\0') && (*(int *)(param_1 + 8) == 3000)) && + (**(int **)(param_1 + 0x10) != DAT_0083c4cc)) { + uVar2 = FUN_004220b0(**(int **)(param_1 + 0x10),0x1e); + iVar3 = FUN_00415430(uVar2); + *(int *)(param_1 + 0x28) = iVar3; + if (iVar3 == 0) { + return 0; + } + FUN_00695670(iVar3); + } + return 1; +} + + + +// --- FUN_0044fdb0 at 0x0044FDB0 (size: 65) --- + +undefined4 * __fastcall FUN_0044fdb0(undefined4 *param_1) + +{ + LONG *pLVar1; + + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + pLVar1 = (LONG *)(PTR_DAT_00818344 + -0x10); + param_1[5] = PTR_DAT_00818344; + InterlockedIncrement(pLVar1); + param_1[7] = 0; + param_1[8] = 0; + param_1[9] = 0; + FUN_0044fa50(); + return param_1; +} + + + +// --- FUN_0044fe00 at 0x0044FE00 (size: 222) --- + +void __fastcall FUN_0044fe00(int *param_1) + +{ + undefined *puVar1; + char cVar2; + LONG LVar3; + int iVar4; + LONG *lpAddend; + uint uVar5; + + cVar2 = FUN_00413a70(); + if (cVar2 != '\0') { + FUN_0054d2e0(param_1 + 10); + } + puVar1 = (undefined *)*param_1; + if (puVar1 != PTR_DAT_00818344) { + LVar3 = InterlockedDecrement((LONG *)(puVar1 + -0x10)); + if ((LVar3 == 0) && ((undefined4 *)(puVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(puVar1 + -0x14))(1); + } + lpAddend = (LONG *)(PTR_DAT_00818344 + -0x10); + *param_1 = (int)PTR_DAT_00818344; + InterlockedIncrement(lpAddend); + } + operator_delete__((void *)param_1[4]); + uVar5 = 0; + param_1[4] = 0; + param_1[3] = 0; + if (param_1[9] != 0) { + do { + operator_delete(*(void **)(param_1[7] + uVar5 * 4)); + *(undefined4 *)(param_1[7] + uVar5 * 4) = 0; + uVar5 = uVar5 + 1; + } while (uVar5 < (uint)param_1[9]); + } + param_1[9] = 0; + if ((param_1[8] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)param_1[7]); + param_1[7] = 0; + param_1[8] = 0; + return; + } + if (param_1[7] != 0) { + iVar4 = (param_1[8] & 0x7fffffffU) - 1; + while (-1 < iVar4) { + iVar4 = iVar4 + -1; + *(undefined4 *)(param_1[7] + 4 + iVar4 * 4) = 0; + } + } + return; +} + + + +// --- FUN_0044fee0 at 0x0044FEE0 (size: 56) --- + +void __fastcall FUN_0044fee0(int param_1) + +{ + undefined4 uVar1; + undefined4 uVar2; + + if ((*(int *)(param_1 + 8) == 3000) && (**(int **)(param_1 + 0x10) != DAT_0083c4cc)) { + uVar2 = 0; + uVar1 = FUN_004220b0(**(int **)(param_1 + 0x10),0); + FUN_0041a4e0(uVar1,uVar2); + } + return; +} + + + +// --- FUN_0044ff20 at 0x0044FF20 (size: 102) --- + +void __fastcall FUN_0044ff20(int *param_1) + +{ + LONG LVar1; + undefined4 *puVar2; + + FUN_0044fe00(); + if ((param_1[8] & 0x80000000U) == 0x80000000) { + operator_delete__((void *)param_1[7]); + } + puVar2 = (undefined4 *)(param_1[5] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_1[5] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(*param_1 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(*param_1 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + return; +} + + + +// --- FUN_0044ff90 at 0x0044FF90 (size: 397) --- + +undefined4 __thiscall FUN_0044ff90(int *param_1,int *param_2) + +{ + int iVar1; + int *piVar2; + int *piVar3; + char cVar4; + LONG LVar5; + undefined4 *puVar6; + undefined4 uVar7; + uint uVar8; + uint uVar9; + undefined4 *puVar10; + + piVar3 = param_2; + iVar1 = *param_2; + if (iVar1 != *param_1) { + LVar5 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = *param_1; + *piVar3 = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + piVar3[1] = param_1[1]; + piVar3[2] = param_1[2]; + piVar3[3] = param_1[3]; + if (param_1[4] == 0) { +LAB_0045001b: + iVar1 = piVar3[5]; + if (iVar1 != param_1[5]) { + LVar5 = InterlockedDecrement((LONG *)(iVar1 + -0x10)); + if ((LVar5 == 0) && ((undefined4 *)(iVar1 + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(iVar1 + -0x14))(1); + } + iVar1 = param_1[5]; + piVar3[5] = iVar1; + InterlockedIncrement((LONG *)(iVar1 + -0x10)); + } + *(char *)(piVar3 + 6) = (char)param_1[6]; + param_2 = (int *)0x0; + if (param_1[9] != 0) { + do { + puVar6 = (undefined4 *)FUN_005df0f5(0x10); + if (puVar6 == (undefined4 *)0x0) { + return 0; + } + puVar10 = *(undefined4 **)(param_1[7] + (int)param_2 * 4); + *puVar6 = *puVar10; + puVar6[1] = puVar10[1]; + puVar6[2] = puVar10[2]; + puVar6[3] = puVar10[3]; + if ((uint)piVar3[9] < (piVar3[8] & 0x7fffffffU)) { +LAB_004500c2: + *(undefined4 **)(piVar3[7] + piVar3[9] * 4) = puVar6; + piVar3[9] = piVar3[9] + 1; + } + else { + uVar7 = FUN_00453850((piVar3[8] & 0x7fffffffU) + 1); + cVar4 = FUN_004180a0(uVar7); + if (cVar4 != '\0') goto LAB_004500c2; + } + param_2 = (int *)((int)param_2 + 1); + } while (param_2 < (uint)param_1[9]); + } + piVar2 = (int *)param_1[10]; + if (piVar2 != (int *)0x0) { + param_2 = (int *)piVar3[10]; + piVar3[10] = (int)piVar2; + (**(code **)(*piVar2 + 0x10))(); + FUN_00695670(piVar3[10]); + FUN_0054d2e0(¶m_2); + } + return 1; + } + if (param_1[3] != 0) { + puVar6 = (undefined4 *)thunk_FUN_005df0f5(param_1[3]); + piVar3[4] = (int)puVar6; + if (puVar6 != (undefined4 *)0x0) { + uVar9 = param_1[3]; + puVar10 = (undefined4 *)param_1[4]; + for (uVar8 = uVar9 >> 2; uVar8 != 0; uVar8 = uVar8 - 1) { + *puVar6 = *puVar10; + puVar10 = puVar10 + 1; + puVar6 = puVar6 + 1; + } + for (uVar9 = uVar9 & 3; uVar9 != 0; uVar9 = uVar9 - 1) { + *(undefined1 *)puVar6 = *(undefined1 *)puVar10; + puVar10 = (undefined4 *)((int)puVar10 + 1); + puVar6 = (undefined4 *)((int)puVar6 + 1); + } + goto LAB_0045001b; + } + } + return 0; +} + + + diff --git a/docs/research/decompiled/chunk_00450000.c b/docs/research/decompiled/chunk_00450000.c new file mode 100644 index 0000000..efef339 --- /dev/null +++ b/docs/research/decompiled/chunk_00450000.c @@ -0,0 +1,13095 @@ +// Decompiled from acclient.exe — chunk 0x00450000 +// Ghidra 12.0.4 + pyghidra headless + +// --- FUN_00450120 at 0x00450120 (size: 607) --- + +void __thiscall FUN_00450120(int param_1,uint param_2) + +{ + int iVar1; + char cVar2; + undefined4 *puVar3; + ushort *puVar4; + undefined4 uVar5; + undefined4 *puVar6; + uint *puVar7; + uint *puVar8; + uint uVar9; + uint uVar10; + ushort uVar11; + undefined4 *puVar12; + uint local_4; + + iVar1 = param_2; + FUN_0040ad10(4); + puVar3 = (undefined4 *)FUN_0040acf0(4); + if (puVar3 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 4) = *puVar3; + } + else { + *puVar3 = *(undefined4 *)(param_1 + 4); + } + } + uVar11 = *(ushort *)(param_1 + 8); + FUN_0040ad10(2); + puVar4 = (ushort *)FUN_0040acf0(2); + if (puVar4 != (ushort *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + uVar11 = *puVar4; + } + else { + *puVar4 = uVar11; + } + } + if ((*(byte *)(param_2 + 4) & 5) == 0) { + *(uint *)(param_1 + 8) = (uint)uVar11; + } + FUN_0040ad10(4); + puVar3 = (undefined4 *)FUN_0040acf0(4); + if (puVar3 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + *(undefined4 *)(param_1 + 0xc) = *puVar3; + } + else { + *puVar3 = *(undefined4 *)(param_1 + 0xc); + } + } + if ((~*(byte *)(param_2 + 4) & 1) != 0) { + uVar5 = thunk_FUN_005df0f5(*(undefined4 *)(param_1 + 0xc)); + *(undefined4 *)(param_1 + 0x10) = uVar5; + } + uVar10 = *(uint *)(param_1 + 0xc); + puVar3 = *(undefined4 **)(param_1 + 0x10); + puVar6 = (undefined4 *)FUN_0040acf0(uVar10); + if (puVar6 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + puVar12 = puVar6; + for (uVar9 = uVar10 >> 2; uVar9 != 0; uVar9 = uVar9 - 1) { + *puVar3 = *puVar12; + puVar12 = puVar12 + 1; + puVar3 = puVar3 + 1; + } + } + else { + puVar12 = puVar3; + puVar3 = puVar6; + for (uVar9 = uVar10 >> 2; uVar9 != 0; uVar9 = uVar9 - 1) { + *puVar3 = *puVar12; + puVar12 = puVar12 + 1; + puVar3 = puVar3 + 1; + } + } + for (uVar10 = uVar10 & 3; uVar10 != 0; uVar10 = uVar10 - 1) { + *(undefined1 *)puVar3 = *(undefined1 *)puVar12; + puVar12 = (undefined4 *)((int)puVar12 + 1); + puVar3 = (undefined4 *)((int)puVar3 + 1); + } + } + local_4 = *(uint *)(param_1 + 0x24); + FUN_0040ad10(4); + puVar7 = (uint *)FUN_0040acf0(4); + if (puVar7 != (uint *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + local_4 = *puVar7; + } + else { + *puVar7 = local_4; + } + } + FUN_00422250(param_1 + 0x18,param_2); + param_2 = 0; + if (local_4 != 0) { + do { + if ((~*(byte *)(iVar1 + 4) & 1) == 0) { + puVar7 = *(uint **)(*(int *)(param_1 + 0x1c) + param_2 * 4); + } + else { + puVar7 = (uint *)FUN_005df0f5(0x10); + } + uVar11 = (ushort)*puVar7; + FUN_0040ad10(2); + puVar4 = (ushort *)FUN_0040acf0(2); + if (puVar4 != (ushort *)0x0) { + if ((*(byte *)(iVar1 + 4) & 1) == 0) { + uVar11 = *puVar4; + } + else { + *puVar4 = uVar11; + } + } + if ((*(byte *)(iVar1 + 4) & 5) == 0) { + *puVar7 = (uint)uVar11; + } + uVar11 = (ushort)puVar7[1]; + FUN_0040ad10(2); + puVar4 = (ushort *)FUN_0040acf0(2); + if (puVar4 != (ushort *)0x0) { + if ((*(byte *)(iVar1 + 4) & 1) == 0) { + uVar11 = *puVar4; + } + else { + *puVar4 = uVar11; + } + } + if ((*(byte *)(iVar1 + 4) & 5) == 0) { + puVar7[1] = (uint)uVar11; + } + FUN_0040ad10(4); + puVar8 = (uint *)FUN_0040acf0(4); + if (puVar8 != (uint *)0x0) { + if ((*(byte *)(iVar1 + 4) & 1) == 0) { + puVar7[2] = *puVar8; + } + else { + *puVar8 = puVar7[2]; + } + } + FUN_0040ad10(4); + puVar8 = (uint *)FUN_0040acf0(4); + if (puVar8 != (uint *)0x0) { + if ((*(byte *)(iVar1 + 4) & 1) == 0) { + puVar7[3] = *puVar8; + } + else { + *puVar8 = puVar7[3]; + } + } + if ((~*(byte *)(iVar1 + 4) & 1) != 0) { + uVar10 = *(uint *)(param_1 + 0x20) & 0x7fffffff; + if (uVar10 <= *(uint *)(param_1 + 0x24)) { + uVar5 = FUN_00453850(uVar10 + 1); + cVar2 = FUN_004180a0(uVar5); + if (cVar2 == '\0') goto LAB_00450362; + } + *(uint **)(*(int *)(param_1 + 0x1c) + *(int *)(param_1 + 0x24) * 4) = puVar7; + *(int *)(param_1 + 0x24) = *(int *)(param_1 + 0x24) + 1; + } +LAB_00450362: + param_2 = param_2 + 1; + } while (param_2 < local_4); + } + return; +} + + + +// --- FUN_00450380 at 0x00450380 (size: 110) --- + +uint FUN_00450380(void) + +{ + char cVar1; + undefined4 *puVar2; + LONG *pLVar3; + + puVar2 = (undefined4 *)FUN_005df0f5(0x2c); + if (puVar2 != (undefined4 *)0x0) { + pLVar3 = (LONG *)(PTR_DAT_00818344 + -0x10); + *puVar2 = PTR_DAT_00818344; + InterlockedIncrement(pLVar3); + pLVar3 = (LONG *)(PTR_DAT_00818344 + -0x10); + puVar2[5] = PTR_DAT_00818344; + InterlockedIncrement(pLVar3); + puVar2[7] = 0; + puVar2[8] = 0; + puVar2[9] = 0; + FUN_0044fa50(); + cVar1 = FUN_0044ff90(puVar2); + return -(uint)(cVar1 != '\0') & (uint)puVar2; + } + return 0; +} + + + +// --- FUN_004503f0 at 0x004503F0 (size: 44) --- + +void __thiscall FUN_004503f0(int param_1,undefined4 param_2) + +{ + uint uVar1; + + uVar1 = 0; + if (*(int *)(param_1 + 0x38) != 0) { + do { + FUN_0044fee0(param_2); + uVar1 = uVar1 + 1; + } while (uVar1 < *(uint *)(param_1 + 0x38)); + } + return; +} + + + +// --- FUN_00450420 at 0x00450420 (size: 47) --- + +undefined4 __fastcall FUN_00450420(int param_1) + +{ + undefined1 uVar1; + char cVar2; + uint uVar3; + undefined1 uVar4; + uint uVar5; + + uVar5 = 0; + uVar4 = 1; + uVar3 = 0; + uVar1 = 1; + if (*(int *)(param_1 + 0x38) != 0) { + do { + uVar4 = uVar1; + cVar2 = FUN_0044fd50(); + if (cVar2 == '\0') { + uVar4 = 0; + } + uVar3 = *(uint *)(param_1 + 0x38); + uVar5 = uVar5 + 1; + uVar1 = uVar4; + } while (uVar5 < uVar3); + } + return CONCAT31((int3)(uVar3 >> 8),uVar4); +} + + + +// --- FUN_00450450 at 0x00450450 (size: 47) --- + +undefined4 __fastcall FUN_00450450(int param_1) + +{ + undefined1 uVar1; + char cVar2; + uint uVar3; + undefined1 uVar4; + uint uVar5; + + uVar5 = 0; + uVar4 = 1; + uVar3 = 0; + uVar1 = 1; + if (*(int *)(param_1 + 0x38) != 0) { + do { + uVar4 = uVar1; + cVar2 = FUN_0044fa30(); + if (cVar2 == '\0') { + uVar4 = 0; + } + uVar3 = *(uint *)(param_1 + 0x38); + uVar5 = uVar5 + 1; + uVar1 = uVar4; + } while (uVar5 < uVar3); + } + return CONCAT31((int3)(uVar3 >> 8),uVar4); +} + + + +// --- FUN_00450480 at 0x00450480 (size: 35) --- + +undefined4 * __fastcall FUN_00450480(undefined4 *param_1) + +{ + FUN_00415460(DAT_0083d2b8); + *param_1 = &PTR_LAB_0079c458; + param_1[0xc] = 0; + param_1[0xd] = 0; + param_1[0xe] = 0; + return param_1; +} + + + +// --- FUN_004504c0 at 0x004504C0 (size: 180) --- + +void __fastcall FUN_004504c0(int param_1) + +{ + void *pvVar1; + int iVar2; + uint uVar3; + + uVar3 = 0; + if (*(int *)(param_1 + 0x38) != 0) { + do { + FUN_0044fa30(); + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 0x38)); + } + uVar3 = 0; + if (*(int *)(param_1 + 0x38) != 0) { + do { + pvVar1 = *(void **)(*(int *)(param_1 + 0x30) + uVar3 * 4); + if (pvVar1 != (void *)0x0) { + FUN_0044ff20(); + operator_delete(pvVar1); + } + *(undefined4 *)(*(int *)(param_1 + 0x30) + uVar3 * 4) = 0; + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 0x38)); + } + *(undefined4 *)(param_1 + 0x38) = 0; + if ((*(uint *)(param_1 + 0x34) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)(param_1 + 0x30)); + *(undefined4 *)(param_1 + 0x30) = 0; + *(undefined4 *)(param_1 + 0x34) = 0; + return; + } + if (*(int *)(param_1 + 0x30) != 0) { + iVar2 = (*(uint *)(param_1 + 0x34) & 0x7fffffff) - 1; + while (-1 < iVar2) { + iVar2 = iVar2 + -1; + *(undefined4 *)(*(int *)(param_1 + 0x30) + 4 + iVar2 * 4) = 0; + } + } + return; +} + + + +// --- FUN_004505f0 at 0x004505F0 (size: 49) --- + +void __fastcall FUN_004505f0(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_0079c458; + FUN_004504c0(); + if ((param_1[0xd] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0xc]); + } + FUN_004154b0(); + return; +} + + + +// --- FUN_00450630 at 0x00450630 (size: 70) --- + +undefined4 * __thiscall FUN_00450630(undefined4 *param_1,byte param_2) + +{ + *param_1 = &PTR_LAB_0079c458; + FUN_004504c0(); + if ((param_1[0xd] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[0xc]); + } + FUN_004154b0(); + if ((param_2 & 1) != 0) { + operator_delete(param_1); + } + return param_1; +} + + + +// --- FUN_004507e0 at 0x004507E0 (size: 58) --- + +undefined4 * __fastcall FUN_004507e0(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_0079c4b4; + FUN_005b2250(); + FUN_005b2250(); + param_1[1] = 0; + FUN_005b1fe0(); + FUN_005b1fe0(); + return param_1; +} + + + +// --- FUN_004508b0 at 0x004508B0 (size: 39) --- + +undefined4 * __fastcall FUN_004508b0(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_0079c4dc; + FUN_005b2250(); + param_1[1] = 0; + FUN_005b1fe0(); + return param_1; +} + + + +// --- FUN_00450950 at 0x00450950 (size: 69) --- + +undefined4 * __fastcall FUN_00450950(undefined4 *param_1) + +{ + *param_1 = &PTR_LAB_0079c508; + FUN_005b2250(); + FUN_005b2250(); + param_1[1] = 0; + FUN_005b1fe0(); + param_1[3] = 0x3f800000; + FUN_005b1fe0(); + param_1[0xe] = 0x3f800000; + return param_1; +} + + + +// --- FUN_004509a0 at 0x004509A0 (size: 147) --- + +void __thiscall FUN_004509a0(int param_1,int param_2) + +{ + *(undefined4 *)(param_1 + 4) = *(undefined4 *)(param_2 + 4); + *(undefined4 *)(param_1 + 8) = *(undefined4 *)(param_2 + 8); + *(undefined4 *)(param_1 + 0xc) = *(undefined4 *)(param_2 + 0xc); + *(undefined4 *)(param_1 + 0x10) = *(undefined4 *)(param_2 + 0x10); + *(undefined4 *)(param_1 + 0x14) = *(undefined4 *)(param_2 + 0x14); + *(undefined4 *)(param_1 + 0x18) = *(undefined4 *)(param_2 + 0x18); + *(undefined4 *)(param_1 + 0x1c) = *(undefined4 *)(param_2 + 0x1c); + *(undefined4 *)(param_1 + 0x20) = *(undefined4 *)(param_2 + 0x20); + *(undefined4 *)(param_1 + 0x24) = *(undefined4 *)(param_2 + 0x24); + *(undefined4 *)(param_1 + 0x28) = *(undefined4 *)(param_2 + 0x28); + *(undefined4 *)(param_1 + 0x2c) = *(undefined4 *)(param_2 + 0x2c); + *(undefined4 *)(param_1 + 0x30) = *(undefined4 *)(param_2 + 0x30); + *(undefined4 *)(param_1 + 0x34) = *(undefined4 *)(param_2 + 0x34); + *(undefined4 *)(param_1 + 0x38) = *(undefined4 *)(param_2 + 0x38); + *(undefined4 *)(param_1 + 0x3c) = *(undefined4 *)(param_2 + 0x3c); + *(undefined4 *)(param_1 + 0x40) = *(undefined4 *)(param_2 + 0x40); + *(undefined4 *)(param_1 + 0x44) = *(undefined4 *)(param_2 + 0x44); + *(undefined4 *)(param_1 + 0x48) = *(undefined4 *)(param_2 + 0x48); + *(undefined4 *)(param_1 + 0x4c) = *(undefined4 *)(param_2 + 0x4c); + *(undefined4 *)(param_1 + 0x50) = *(undefined4 *)(param_2 + 0x50); + *(undefined4 *)(param_1 + 0x54) = *(undefined4 *)(param_2 + 0x54); + *(undefined4 *)(param_1 + 0x58) = *(undefined4 *)(param_2 + 0x58); + *(undefined4 *)(param_1 + 0x5c) = *(undefined4 *)(param_2 + 0x5c); + return; +} + + + +// --- FUN_00450ac0 at 0x00450AC0 (size: 67) --- + +void __fastcall FUN_00450ac0(undefined4 *param_1) + +{ + *param_1 = &PTR_FUN_0079c530; + param_1[1] = 0; + param_1[5] = 0; + param_1[4] = 0; + param_1[3] = 0; + param_1[9] = 0; + param_1[8] = 0; + param_1[6] = 0; + param_1[0xd] = 0; + param_1[0xb] = 0; + param_1[10] = 0; + param_1[0x10] = 0; + param_1[0xf] = 0; + param_1[0xe] = 0; + param_1[0x11] = 0x3f800000; + param_1[0xc] = 0x3f800000; + param_1[7] = 0x3f800000; + param_1[2] = 0x3f800000; + return; +} + + + +// --- FUN_00450cb0 at 0x00450CB0 (size: 109) --- + +void __thiscall FUN_00450cb0(undefined4 *param_1,int param_2) + +{ + undefined1 uVar1; + undefined1 *puVar2; + undefined4 *puVar3; + + uVar1 = (**(code **)*param_1)(); + FUN_0040ad10(1); + puVar2 = (undefined1 *)FUN_0040acf0(1); + if ((puVar2 != (undefined1 *)0x0) && ((*(byte *)(param_2 + 4) & 1) != 0)) { + *puVar2 = uVar1; + } + FUN_0040ad10(4); + puVar3 = (undefined4 *)FUN_0040acf0(4); + if (puVar3 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + param_1[1] = *puVar3; + } + else { + *puVar3 = param_1[1]; + } + } + FUN_005b22c0(param_2); + FUN_005b22c0(param_2); + return; +} + + + +// --- FUN_00450f70 at 0x00450F70 (size: 113) --- + +void __thiscall FUN_00450f70(undefined4 *param_1,int param_2) + +{ + undefined1 uVar1; + undefined1 *puVar2; + undefined4 *puVar3; + + uVar1 = (**(code **)*param_1)(); + FUN_0040ad10(1); + puVar2 = (undefined1 *)FUN_0040acf0(1); + if ((puVar2 != (undefined1 *)0x0) && ((*(byte *)(param_2 + 4) & 1) != 0)) { + *puVar2 = uVar1; + } + FUN_0040ad10(4); + puVar3 = (undefined4 *)FUN_0040acf0(4); + if (puVar3 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) != 0) { + *puVar3 = param_1[1]; + FUN_005b22c0(param_2); + return; + } + param_1[1] = *puVar3; + } + FUN_005b22c0(param_2); + return; +} + + + +// --- FUN_00451410 at 0x00451410 (size: 143) --- + +void __thiscall FUN_00451410(undefined4 *param_1,int param_2) + +{ + undefined1 uVar1; + undefined1 *puVar2; + undefined4 *puVar3; + int iVar4; + + uVar1 = (**(code **)*param_1)(); + FUN_0040ad10(1); + puVar2 = (undefined1 *)FUN_0040acf0(1); + if ((puVar2 != (undefined1 *)0x0) && ((*(byte *)(param_2 + 4) & 1) != 0)) { + *puVar2 = uVar1; + } + FUN_0040ad10(4); + puVar3 = (undefined4 *)FUN_0040acf0(4); + if (puVar3 != (undefined4 *)0x0) { + if ((*(byte *)(param_2 + 4) & 1) == 0) { + param_1[1] = *puVar3; + } + else { + *puVar3 = param_1[1]; + } + } + param_1 = param_1 + 2; + FUN_0040ad10(0x40); + puVar3 = (undefined4 *)FUN_0040acf0(0x40); + if (puVar3 != (undefined4 *)0x0) { + iVar4 = 0x10; + if ((*(byte *)(param_2 + 4) & 1) != 0) { + for (; iVar4 != 0; iVar4 = iVar4 + -1) { + *puVar3 = *param_1; + param_1 = param_1 + 1; + puVar3 = puVar3 + 1; + } + return; + } + for (; iVar4 != 0; iVar4 = iVar4 + -1) { + *param_1 = *puVar3; + puVar3 = puVar3 + 1; + param_1 = param_1 + 1; + } + } + return; +} + + + +// --- FUN_00451a60 at 0x00451A60 (size: 114) --- + +/* WARNING: Removing unreachable block (ram,0x00451aa0) */ +/* WARNING: Removing unreachable block (ram,0x00451a7b) */ +/* WARNING: Removing unreachable block (ram,0x00451ac0) */ +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __thiscall FUN_00451a60(float *param_1,uint param_2) + +{ + *param_1 = (float)(param_2 >> 0x10 & 0xff) * _DAT_00799208; + param_1[1] = (float)(param_2 >> 8 & 0xff) * _DAT_00799208; + param_1[2] = (float)(param_2 & 0xff) * _DAT_00799208; + return; +} + + + +// --- FUN_00451ae0 at 0x00451AE0 (size: 33) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __thiscall FUN_00451ae0(float *param_1,float param_2) + +{ + param_2 = _DAT_007938b0 / param_2; + *param_1 = param_2 * *param_1; + param_1[1] = param_2 * param_1[1]; + param_1[2] = param_2 * param_1[2]; + return; +} + + + +// --- FUN_00451b10 at 0x00451B10 (size: 49) --- + +bool FUN_00451b10(ushort param_1,ushort param_2) + +{ + uint uVar1; + + uVar1 = (int)((uint)param_2 - (uint)param_1) >> 0x1f; + if ((int)(((uint)param_2 - (uint)param_1 ^ uVar1) - uVar1) < 0x8000) { + return param_1 < param_2; + } + return param_2 < param_1; +} + + + +// --- FUN_00451b50 at 0x00451B50 (size: 83) --- + +undefined4 __thiscall FUN_00451b50(int param_1,int param_2,ushort param_3) + +{ + ushort uVar1; + uint uVar2; + bool bVar3; + + uVar1 = *(ushort *)(param_1 + 0x164 + param_2 * 2); + uVar2 = (int)((uint)param_3 - (uint)uVar1) >> 0x1f; + if ((int)(((uint)param_3 - (uint)uVar1 ^ uVar2) - uVar2) < 0x8000) { + bVar3 = uVar1 < param_3; + } + else { + bVar3 = param_3 < uVar1; + } + if (bVar3) { + *(ushort *)(param_1 + 0x164 + param_2 * 2) = param_3; + return 1; + } + return 0; +} + + + +// --- FUN_00451bc0 at 0x00451BC0 (size: 11) --- + +void __fastcall FUN_00451bc0(int param_1) + +{ + /* WARNING: Could not recover jumptable at 0x00451bc8. Too many branches */ + /* WARNING: Treating indirect jump as call */ + (**(code **)(**(int **)(param_1 + 0xac) + 0x34))(); + return; +} + + + +// --- FUN_00451bd0 at 0x00451BD0 (size: 11) --- + +void FUN_00451bd0(void) + +{ + FUN_00509da0(); + return; +} + + + +// --- FUN_00451be0 at 0x00451BE0 (size: 10) --- + +void FUN_00451be0(undefined4 param_1) + +{ + DAT_00844bfc = param_1; + return; +} + + + +// --- FUN_00451bf0 at 0x00451BF0 (size: 11) --- + +undefined4 FUN_00451bf0(void) + +{ + return CONCAT31((int3)((uint)DAT_00844c00 >> 8),DAT_00844c00 != 0); +} + + + +// --- FUN_00451c00 at 0x00451C00 (size: 23) --- + +void __thiscall FUN_00451c00(int param_1,undefined1 param_2,undefined4 param_3) + +{ + *(undefined1 *)(param_1 + 200) = param_2; + *(undefined4 *)(param_1 + 0xc4) = param_3; + return; +} + + + +// --- FUN_00451c20 at 0x00451C20 (size: 57) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +float10 __fastcall FUN_00451c20(int param_1) + +{ + float10 fVar1; + + if (*(char *)(param_1 + 200) != '\0') { + return (float10)*(float *)(param_1 + 0xc4); + } + fVar1 = (float10)fptan(((float10)*(float *)(param_1 + 0xc0) / + ((float10)*(float *)(DAT_00870340 + 0xa8) - (float10)_DAT_007958cc)) * + (float10)_DAT_00799088); + return (float10)_DAT_007938c0 / fVar1; +} + + + +// --- FUN_00451c60 at 0x00451C60 (size: 29) --- + +undefined4 __fastcall FUN_00451c60(int param_1) + +{ + if ((*(int *)(param_1 + 0xf8) != 0) && (*(int *)(param_1 + 0xdc) == 0)) { + return 1; + } + return 0; +} + + + +// --- FUN_00451c80 at 0x00451C80 (size: 17) --- + +undefined4 __fastcall FUN_00451c80(int param_1) + +{ + undefined4 uVar1; + + uVar1 = *(undefined4 *)(param_1 + 0xe4); + *(undefined4 *)(param_1 + 0xe4) = 0; + return uVar1; +} + + + +// --- FUN_00451ca0 at 0x00451CA0 (size: 113) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 FUN_00451ca0(int param_1,int param_2) + +{ + uint uVar1; + uint uVar2; + + DAT_0083da4c = param_1; + _DAT_0083da50 = param_2; + DAT_0083da44 = 0; + _DAT_00819618 = 0xffffffff; + uVar1 = param_1 - *(int *)(DAT_00870340 + 0x8c); + uVar2 = param_2 - *(int *)(DAT_00870340 + 0x90); + if ((uVar1 < *(uint *)(DAT_00870340 + 0x94)) && (uVar2 < *(uint *)(DAT_00870340 + 0x98))) { + FUN_0054c360(uVar1,uVar2,1); + DAT_00844c00 = 0; + DAT_0083da48 = 1; + return 1; + } + FUN_0054c3a0(); + return 0; +} + + + +// --- FUN_00451d20 at 0x00451D20 (size: 6) --- + +undefined4 FUN_00451d20(void) + +{ + return DAT_0083da44; +} + + + +// --- FUN_00451d30 at 0x00451D30 (size: 27) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_00451d30(undefined4 param_1,undefined4 param_2) + +{ + DAT_0083da44 = param_1; + _DAT_00819618 = param_2; + FUN_006935e0(param_1); + return; +} + + + +// --- FUN_00451d50 at 0x00451D50 (size: 13) --- + +void __thiscall FUN_00451d50(int param_1,undefined4 param_2) + +{ + *(undefined4 *)(param_1 + 0x100) = param_2; + return; +} + + + +// --- FUN_00451d60 at 0x00451D60 (size: 13) --- + +void __thiscall FUN_00451d60(int param_1,undefined4 param_2) + +{ + *(undefined4 *)(param_1 + 0xfc) = param_2; + return; +} + + + +// --- FUN_00451d70 at 0x00451D70 (size: 11) --- + +void __fastcall FUN_00451d70(int param_1) + +{ + *(undefined4 *)(param_1 + 0xd8) = 0; + return; +} + + + +// --- FUN_00451d80 at 0x00451D80 (size: 11) --- + +void __fastcall FUN_00451d80(int param_1) + +{ + *(undefined4 *)(param_1 + 0xd8) = 1; + return; +} + + + +// --- FUN_00451d90 at 0x00451D90 (size: 74) --- + +undefined4 FUN_00451d90(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4) + +{ + int iVar1; + + iVar1 = FUN_0054be30(param_1,param_2,param_3,param_4); + if (iVar1 != 0) { + if (DAT_0083da48 != '\0') { + FUN_00451ca0(DAT_0083da4c,DAT_0083da4c); + } + return 1; + } + return 0; +} + + + +// --- FUN_00451de0 at 0x00451DE0 (size: 10) --- + +void FUN_00451de0(undefined4 param_1) + +{ + DAT_008452f4 = param_1; + return; +} + + + +// --- FUN_00451df0 at 0x00451DF0 (size: 22) --- + +void FUN_00451df0(int param_1) + +{ + FUN_005a3fe0(param_1 != 0); + return; +} + + + +// --- FUN_00451e10 at 0x00451E10 (size: 17) --- + +void FUN_00451e10(int param_1) + +{ + DAT_0081dbf9 = param_1 != 0; + return; +} + + + +// --- FUN_00451e30 at 0x00451E30 (size: 35) --- + +uint __thiscall FUN_00451e30(int param_1,undefined1 param_2,undefined1 param_3) + +{ + uint in_EAX; + uint uVar1; + + uVar1 = in_EAX & 0xffffff00; + if (*(int *)(param_1 + 0xb0) != 0) { + uVar1 = FUN_005075a0(param_2,param_3,param_3,0); + } + return uVar1; +} + + + +// --- FUN_00451e60 at 0x00451E60 (size: 49) --- + +bool FUN_00451e60(undefined4 param_1,undefined4 param_2,undefined4 *param_3,undefined4 *param_4) + +{ + char cVar1; + + *param_3 = 0; + *param_4 = 0; + cVar1 = FUN_00455d50(param_1,param_2,param_3,param_4); + return cVar1 != '\0'; +} + + + +// --- FUN_00451ea0 at 0x00451EA0 (size: 19) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __thiscall FUN_00451ea0(int param_1,float param_2) + +{ + *(float *)(param_1 + 0xc0) = param_2 * (float)_DAT_0079c6b0; + return; +} + + + +// --- FUN_00451ec0 at 0x00451EC0 (size: 31) --- + +bool __fastcall FUN_00451ec0(int param_1) + +{ + if (*(int *)(param_1 + 0xf8) != 0) { + return (*(uint *)(*(int *)(param_1 + 0xf8) + 0x4c) & 0xffff) < 0x100; + } + return false; +} + + + +// --- FUN_00451f80 at 0x00451F80 (size: 120) --- + +undefined4 __thiscall FUN_00451f80(int param_1,int param_2,undefined4 param_3,ushort param_4) + +{ + ushort uVar1; + uint uVar2; + bool bVar3; + + uVar1 = *(ushort *)(param_2 + 0x172); + uVar2 = (int)((uint)param_4 - (uint)uVar1) >> 0x1f; + if ((int)(((uint)param_4 - (uint)uVar1 ^ uVar2) - uVar2) < 0x8000) { + bVar3 = uVar1 < param_4; + } + else { + bVar3 = param_4 < uVar1; + } + if (bVar3) { + *(ushort *)(param_2 + 0x172) = param_4; + (**(code **)(**(int **)(param_1 + 0xac) + 0x24))(param_2,param_3); + if (param_2 == *(int *)(param_1 + 0xf8)) { + (**(code **)(**(int **)(param_1 + 0xac) + 0x30))(param_3); + } + return 1; + } + return 0; +} + + + +// --- FUN_00452000 at 0x00452000 (size: 83) --- + +int FUN_00452000(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4) + +{ + int iVar1; + + iVar1 = FUN_00508890(param_2); + if (iVar1 == 0) { + FUN_00509da0(param_2,param_1); + return 4; + } + iVar1 = FUN_0050ff30(param_3,param_4); + return (-(uint)(iVar1 != 0) & 0xfffffffe) + 3; +} + + + +// --- FUN_00452060 at 0x00452060 (size: 78) --- + +int FUN_00452060(undefined4 param_1,undefined4 param_2,undefined4 param_3) + +{ + int iVar1; + + iVar1 = FUN_00508890(param_2); + if (iVar1 == 0) { + FUN_00509da0(param_2,param_1); + return 4; + } + iVar1 = FUN_00511800(param_3); + return (-(uint)(iVar1 != 0) & 0xfffffffe) + 3; +} + + + +// --- FUN_004520b0 at 0x004520B0 (size: 83) --- + +int FUN_004520b0(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4) + +{ + int iVar1; + + iVar1 = FUN_00508890(param_2); + if (iVar1 == 0) { + FUN_00509da0(param_2,param_1); + return 4; + } + iVar1 = FUN_00513d60(param_3,param_4); + return (-(uint)(iVar1 != 0) & 0xfffffffe) + 3; +} + + + +// --- FUN_00452110 at 0x00452110 (size: 123) --- + +void __thiscall FUN_00452110(int param_1,int param_2,undefined4 param_3,ushort param_4) + +{ + ushort uVar1; + uint uVar2; + bool bVar3; + + uVar1 = *(ushort *)(param_2 + 0x168); + uVar2 = (int)((uint)param_4 - (uint)uVar1) >> 0x1f; + if ((int)(((uint)param_4 - (uint)uVar1 ^ uVar2) - uVar2) < 0x8000) { + bVar3 = uVar1 < param_4; + } + else { + bVar3 = param_4 < uVar1; + } + if (bVar3) { + *(ushort *)(param_2 + 0x168) = param_4; + FUN_005158d0(param_3,1); + if (((param_2 == *(int *)(param_1 + 0xf8)) && (*(int *)(param_1 + 0xe0) != 0)) && + ((*(uint *)(param_2 + 0xa8) & 0x4000) == 0)) { + *(undefined4 *)(param_1 + 0xe0) = 0; + } + } + return; +} + + + +// --- FUN_00452190 at 0x00452190 (size: 104) --- + +undefined4 __thiscall FUN_00452190(int param_1,undefined4 param_2,ushort param_3) + +{ + ushort uVar1; + uint uVar2; + bool bVar3; + + if (*(int *)(param_1 + 0xf8) != 0) { + uVar1 = *(ushort *)(*(int *)(param_1 + 0xf8) + 0x16c); + uVar2 = (int)((uint)uVar1 - (uint)param_3) >> 0x1f; + if ((int)(((uint)uVar1 - (uint)param_3 ^ uVar2) - uVar2) < 0x8000) { + bVar3 = param_3 < uVar1; + } + else { + bVar3 = uVar1 < param_3; + } + if (!bVar3) { + *(undefined4 *)(param_1 + 0xdc) = 0; + *(undefined4 *)(param_1 + 0xe4) = 0; + *(undefined4 *)(param_1 + 0xe0) = 1; + return 1; + } + } + return 1; +} + + + +// --- FUN_00452200 at 0x00452200 (size: 119) --- + +void __thiscall +FUN_00452200(int param_1,int param_2,undefined4 param_3,undefined4 param_4,ushort param_5) + +{ + ushort uVar1; + int iVar2; + uint uVar3; + bool bVar4; + + uVar1 = *(ushort *)(param_2 + 0x16a); + uVar3 = (int)((uint)param_5 - (uint)uVar1) >> 0x1f; + if ((int)(((uint)param_5 - (uint)uVar1 ^ uVar3) - uVar3) < 0x8000) { + bVar4 = uVar1 < param_5; + } + else { + bVar4 = param_5 < uVar1; + } + if (bVar4) { + *(ushort *)(param_2 + 0x16a) = param_5; + if ((param_2 == *(int *)(param_1 + 0xf8)) && + (iVar2 = (**(code **)(**(int **)(param_1 + 0xb8) + 0x60))(), iVar2 == 0)) { + return; + } + FUN_00511ec0(param_3,1); + FUN_005101a0(param_4,1); + } + return; +} + + + +// --- FUN_00452280 at 0x00452280 (size: 80) --- + +void FUN_00452280(int param_1,ushort param_2) + +{ + ushort uVar1; + uint uVar2; + bool bVar3; + + uVar1 = *(ushort *)(param_1 + 0x164); + uVar2 = (int)((uint)param_2 - (uint)uVar1) >> 0x1f; + if ((int)(((uint)param_2 - (uint)uVar1 ^ uVar2) - uVar2) < 0x8000) { + bVar3 = uVar1 < param_2; + } + else { + bVar3 = param_2 < uVar1; + } + if (bVar3) { + *(ushort *)(param_1 + 0x164) = param_2; + FUN_00513f70(); + FUN_005160a0(); + } + return; +} + + + +// --- FUN_004522d0 at 0x004522D0 (size: 142) --- + +void __thiscall +FUN_004522d0(int param_1,int param_2,int param_3,undefined4 param_4,undefined4 param_5, + ushort param_6) + +{ + ushort uVar1; + int *piVar2; + uint uVar3; + bool bVar4; + + uVar1 = *(ushort *)(param_2 + 0x164); + uVar3 = (int)((uint)param_6 - (uint)uVar1) >> 0x1f; + if ((int)(((uint)param_6 - (uint)uVar1 ^ uVar3) - uVar3) < 0x8000) { + bVar4 = uVar1 < param_6; + } + else { + bVar4 = param_6 < uVar1; + } + if (bVar4) { + *(ushort *)(param_2 + 0x164) = param_6; + if ((*(int *)(param_2 + 0x40) == 0) && (*(int *)(param_3 + 8) != *(int *)(param_1 + 0xf4))) { + piVar2 = (int *)FUN_005088e0(*(int *)(param_3 + 8)); + if (piVar2 != (int *)0x0) { + (**(code **)(*piVar2 + 0xc))(1); + } + } + FUN_00516590(param_3,param_4); + FUN_00511e50(param_5,1); + } + return; +} + + + +// --- FUN_00452360 at 0x00452360 (size: 57) --- + +bool __fastcall FUN_00452360(int param_1) + +{ + int iVar1; + + iVar1 = FUN_005df0f5(0x148); + if (iVar1 != 0) { + iVar1 = FUN_0052ce50(); + *(int *)(param_1 + 0x18) = iVar1; + return iVar1 != 0; + } + *(undefined4 *)(param_1 + 0x18) = 0; + return false; +} + + + +// --- FUN_004523a0 at 0x004523A0 (size: 26) --- + +void __thiscall FUN_004523a0(int param_1,undefined4 *param_2) + +{ + *(undefined4 *)(param_1 + 0x50) = *param_2; + *(undefined4 *)(param_1 + 0x54) = param_2[1]; + *(undefined4 *)(param_1 + 0x58) = param_2[2]; + return; +} + + + +// --- FUN_004523c0 at 0x004523C0 (size: 5) --- + +void __fastcall FUN_004523c0(int param_1) + +{ + *(undefined1 *)(param_1 + 0x6c) = 1; + return; +} + + + +// --- FUN_004523d0 at 0x004523D0 (size: 5) --- + +void __fastcall FUN_004523d0(int param_1) + +{ + *(undefined1 *)(param_1 + 0x6d) = 1; + return; +} + + + +// --- FUN_004523e0 at 0x004523E0 (size: 45) --- + +float10 FUN_004523e0(float param_1,float param_2,float param_3) + +{ + if (param_3 < param_1) { + return (float10)param_3; + } + if (param_1 < param_2) { + return (float10)param_2; + } + return (float10)param_1; +} + + + +// --- FUN_00452410 at 0x00452410 (size: 33) --- + +float10 __fastcall FUN_00452410(float *param_1) + +{ + return SQRT((float10)param_1[2] * (float10)param_1[2] + + (float10)param_1[1] * (float10)param_1[1] + (float10)*param_1 * (float10)*param_1); +} + + + +// --- FUN_00452440 at 0x00452440 (size: 81) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __thiscall FUN_00452440(float *param_1,float *param_2) + +{ + float fVar1; + float fVar2; + + fVar2 = _DAT_007938b0 / + SQRT(param_1[2] * param_1[2] + param_1[1] * param_1[1] + *param_1 * *param_1); + fVar1 = *param_1; + *param_1 = fVar2 * fVar1; + param_1[1] = fVar2 * param_1[1]; + param_1[2] = fVar2 * param_1[2]; + *param_2 = fVar2 * fVar1; + param_2[1] = param_1[1]; + param_2[2] = param_1[2]; + return; +} + + + +// --- FUN_004524a0 at 0x004524A0 (size: 82) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 __fastcall FUN_004524a0(float *param_1) + +{ + float fVar1; + + fVar1 = SQRT(param_1[2] * param_1[2] + param_1[1] * param_1[1] + *param_1 * *param_1); + if (fVar1 < _DAT_0079c6ac) { + return 1; + } + fVar1 = _DAT_007938b0 / fVar1; + *param_1 = fVar1 * *param_1; + param_1[1] = fVar1 * param_1[1]; + param_1[2] = fVar1 * param_1[2]; + return 0; +} + + + +// --- FUN_00452500 at 0x00452500 (size: 35) --- + +void __thiscall FUN_00452500(float *param_1,float *param_2,float *param_3) + +{ + float fVar1; + float fVar2; + float fVar3; + float fVar4; + + fVar1 = param_1[2]; + fVar2 = param_3[2]; + fVar3 = param_1[1]; + fVar4 = param_3[1]; + *param_2 = *param_1 - *param_3; + param_2[1] = fVar3 - fVar4; + param_2[2] = fVar1 - fVar2; + return; +} + + + +// --- FUN_00452530 at 0x00452530 (size: 82) --- + +void __thiscall FUN_00452530(int param_1,float *param_2,float *param_3) + +{ + float fVar1; + float fVar2; + float fVar3; + float fVar4; + float fVar5; + float fVar6; + float fVar7; + float fVar8; + float fVar9; + float fVar10; + float fVar11; + float fVar12; + + fVar1 = *(float *)(param_1 + 0x30); + fVar2 = param_3[2]; + fVar3 = *(float *)(param_1 + 0x18); + fVar4 = *param_3; + fVar5 = *(float *)(param_1 + 0x24); + fVar6 = param_3[1]; + fVar7 = *(float *)(param_1 + 0x2c); + fVar8 = param_3[2]; + fVar9 = *(float *)(param_1 + 0x14); + fVar10 = *param_3; + fVar11 = *(float *)(param_1 + 0x20); + fVar12 = param_3[1]; + *param_2 = *(float *)(param_1 + 0x1c) * param_3[1] + + *(float *)(param_1 + 0x10) * *param_3 + *(float *)(param_1 + 0x28) * param_3[2]; + param_2[1] = fVar11 * fVar12 + fVar9 * fVar10 + fVar7 * fVar8; + param_2[2] = fVar5 * fVar6 + fVar3 * fVar4 + fVar1 * fVar2; + return; +} + + + +// --- FUN_00452590 at 0x00452590 (size: 82) --- + +void __thiscall FUN_00452590(int param_1,float *param_2,float *param_3) + +{ + float fVar1; + float fVar2; + float fVar3; + float fVar4; + float fVar5; + float fVar6; + float fVar7; + float fVar8; + float fVar9; + float fVar10; + float fVar11; + float fVar12; + + fVar1 = *(float *)(param_1 + 0x30); + fVar2 = param_3[2]; + fVar3 = *(float *)(param_1 + 0x28); + fVar4 = *param_3; + fVar5 = *(float *)(param_1 + 0x2c); + fVar6 = param_3[1]; + fVar7 = *(float *)(param_1 + 0x24); + fVar8 = param_3[2]; + fVar9 = *(float *)(param_1 + 0x1c); + fVar10 = *param_3; + fVar11 = *(float *)(param_1 + 0x20); + fVar12 = param_3[1]; + *param_2 = *(float *)(param_1 + 0x14) * param_3[1] + + *(float *)(param_1 + 0x10) * *param_3 + *(float *)(param_1 + 0x18) * param_3[2]; + param_2[1] = fVar11 * fVar12 + fVar9 * fVar10 + fVar7 * fVar8; + param_2[2] = fVar5 * fVar6 + fVar3 * fVar4 + fVar1 * fVar2; + return; +} + + + +// --- FUN_004525f0 at 0x004525F0 (size: 98) --- + +void __thiscall FUN_004525f0(int param_1,float *param_2) + +{ + float local_c; + float local_8; + float local_4; + + local_c = *(float *)(param_1 + 0x1c) * param_2[1] + + *(float *)(param_1 + 0x10) * *param_2 + *(float *)(param_1 + 0x28) * param_2[2]; + local_8 = *(float *)(param_1 + 0x20) * param_2[1] + + *(float *)(param_1 + 0x14) * *param_2 + *(float *)(param_1 + 0x2c) * param_2[2]; + local_4 = *(float *)(param_1 + 0x24) * param_2[1] + + *(float *)(param_1 + 0x18) * *param_2 + *(float *)(param_1 + 0x30) * param_2[2]; + FUN_005364e0(&local_c); + return; +} + + + +// --- FUN_00452660 at 0x00452660 (size: 91) --- + +void __thiscall FUN_00452660(int param_1,float *param_2,float *param_3) + +{ + float fVar1; + float fVar2; + float fVar3; + float fVar4; + float fVar5; + float fVar6; + float fVar7; + float fVar8; + float fVar9; + float fVar10; + float fVar11; + float fVar12; + float fVar13; + float fVar14; + + fVar1 = *(float *)(param_1 + 0x30); + fVar2 = param_3[2]; + fVar3 = *(float *)(param_1 + 0x18); + fVar4 = *param_3; + fVar5 = *(float *)(param_1 + 0x24); + fVar6 = param_3[1]; + fVar7 = *(float *)(param_1 + 0x3c); + fVar8 = *(float *)(param_1 + 0x2c); + fVar9 = param_3[2]; + fVar10 = *(float *)(param_1 + 0x14); + fVar11 = *param_3; + fVar12 = *(float *)(param_1 + 0x20); + fVar13 = param_3[1]; + fVar14 = *(float *)(param_1 + 0x38); + *param_2 = *(float *)(param_1 + 0x1c) * param_3[1] + + *(float *)(param_1 + 0x10) * *param_3 + *(float *)(param_1 + 0x28) * param_3[2] + + *(float *)(param_1 + 0x34); + param_2[1] = fVar12 * fVar13 + fVar10 * fVar11 + fVar8 * fVar9 + fVar14; + param_2[2] = fVar5 * fVar6 + fVar3 * fVar4 + fVar1 * fVar2 + fVar7; + return; +} + + + +// --- FUN_004526c0 at 0x004526C0 (size: 125) --- + +void __thiscall FUN_004526c0(int param_1,float *param_2,float *param_3) + +{ + float fVar1; + float fVar2; + float fVar3; + float fVar4; + float fVar5; + float fVar6; + float fVar7; + float fVar8; + float fVar9; + + fVar7 = *param_3 - *(float *)(param_1 + 0x34); + fVar8 = param_3[1] - *(float *)(param_1 + 0x38); + fVar9 = param_3[2] - *(float *)(param_1 + 0x3c); + fVar1 = *(float *)(param_1 + 0x30); + fVar2 = *(float *)(param_1 + 0x28); + fVar3 = *(float *)(param_1 + 0x2c); + fVar4 = *(float *)(param_1 + 0x24); + fVar5 = *(float *)(param_1 + 0x1c); + fVar6 = *(float *)(param_1 + 0x20); + *param_2 = fVar8 * *(float *)(param_1 + 0x14) + + fVar7 * *(float *)(param_1 + 0x10) + fVar9 * *(float *)(param_1 + 0x18); + param_2[1] = fVar8 * fVar6 + fVar7 * fVar5 + fVar9 * fVar4; + param_2[2] = fVar8 * fVar3 + fVar7 * fVar2 + fVar9 * fVar1; + return; +} + + + +// --- FUN_00452740 at 0x00452740 (size: 114) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __thiscall FUN_00452740(int *param_1,float *param_2) + +{ + float fVar1; + float local_c; + float local_8; + float local_4; + + if ((*param_1 == 1) || (*param_1 == 2)) { + local_c = *param_2; + local_8 = param_2[1]; + fVar1 = param_2[2]; + local_4 = _DAT_007938b0 / SQRT(local_8 * local_8 + fVar1 * fVar1 + local_c * local_c); + local_c = local_4 * local_c; + local_8 = local_4 * local_8; + local_4 = local_4 * fVar1; + FUN_00536af0(&local_c); + } + return; +} + + + +// --- FUN_004527c0 at 0x004527C0 (size: 35) --- + +undefined4 * __thiscall FUN_004527c0(undefined4 *param_1,undefined4 param_2,undefined4 param_3) + +{ + *param_1 = &PTR_LAB_00797910; + param_1[1] = param_2; + FUN_00425f10(param_3); + return param_1; +} + + + +// --- FUN_004527f0 at 0x004527F0 (size: 60) --- + +uint __fastcall FUN_004527f0(int param_1) + +{ + int iVar1; + uint local_10; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + local_c = *(undefined4 *)(param_1 + 0x3c); + local_8 = *(undefined4 *)(param_1 + 0x40); + local_4 = *(undefined4 *)(param_1 + 0x44); + local_10 = *(uint *)(param_1 + 4); + iVar1 = FUN_005aac70(&local_10,&local_c); + return -(uint)(iVar1 != 0) & local_10; +} + + + +// --- FUN_00452830 at 0x00452830 (size: 194) --- + +undefined4 __thiscall FUN_00452830(int param_1,undefined4 param_2,int param_3,float *param_4) + +{ + float fVar1; + float fVar2; + float fVar3; + float fVar4; + float fVar5; + float fVar6; + float fVar7; + float fVar8; + float fVar9; + float fVar10; + float fVar11; + float fVar12; + float fVar13; + float fVar14; + float fVar15; + float fVar16; + float fVar17; + float fVar18; + float fVar19; + float fVar20; + float fVar21; + float local_c; + float local_8; + float local_4; + + fVar1 = *(float *)(param_3 + 0x24); + fVar2 = param_4[1]; + fVar3 = *(float *)(param_3 + 0x18); + fVar4 = *param_4; + fVar5 = *(float *)(param_3 + 0x30); + fVar6 = param_4[2]; + fVar7 = *(float *)(param_3 + 0x3c); + fVar8 = *(float *)(param_3 + 0x28); + fVar9 = param_4[1]; + fVar10 = *(float *)(param_3 + 0x1c); + fVar11 = *param_4; + fVar12 = *(float *)(param_3 + 0x34); + fVar13 = param_4[2]; + fVar14 = *(float *)(param_3 + 0x40); + fVar15 = *(float *)(param_3 + 0x2c); + fVar16 = param_4[1]; + fVar17 = *(float *)(param_3 + 0x20); + fVar18 = *param_4; + fVar19 = *(float *)(param_3 + 0x38); + fVar20 = param_4[2]; + fVar21 = *(float *)(param_3 + 0x44); + FUN_0043e7d0(&local_c,*(undefined4 *)(param_1 + 4),*(undefined4 *)(param_3 + 4)); + local_c = local_c + fVar5 * fVar6 + fVar3 * fVar4 + fVar1 * fVar2 + fVar7; + local_8 = local_8 + fVar12 * fVar13 + fVar10 * fVar11 + fVar8 * fVar9 + fVar14; + local_4 = local_4 + fVar19 * fVar20 + fVar17 * fVar18 + fVar15 * fVar16 + fVar21; + FUN_004526c0(param_2,&local_c); + return param_2; +} + + + +// --- FUN_00452900 at 0x00452900 (size: 71) --- + +void __thiscall FUN_00452900(int param_1,float *param_2,int param_3) + +{ + float fVar1; + float fVar2; + float local_c; + float local_8; + float local_4; + + FUN_0043e7d0(&local_c,*(undefined4 *)(param_1 + 4),*(undefined4 *)(param_3 + 4)); + fVar1 = *(float *)(param_3 + 0x40); + fVar2 = *(float *)(param_3 + 0x44); + *param_2 = local_c + *(float *)(param_3 + 0x3c); + param_2[1] = local_8 + fVar1; + param_2[2] = local_4 + fVar2; + return; +} + + + +// --- FUN_00452950 at 0x00452950 (size: 4) --- + +int __fastcall FUN_00452950(int param_1) + +{ + return param_1 + 0x50; +} + + + +// --- FUN_00452960 at 0x00452960 (size: 78) --- + +void __fastcall FUN_00452960(int param_1) + +{ + int iVar1; + uint uVar2; + + uVar2 = 0; + *(undefined4 *)(param_1 + 0x48) = 0; + if (*(int *)(param_1 + 0x4c) != 0) { + do { + (**(code **)**(undefined4 **)(*(int *)(param_1 + 0x50) + uVar2 * 4))(); + iVar1 = *(int *)(*(int *)(*(int *)(param_1 + 0x50) + uVar2 * 4) + 0xc); + if ((*(int **)(iVar1 + 0x14) != (int *)0x0) && (*(int *)(iVar1 + 0x18) == 0)) { + (**(code **)(**(int **)(iVar1 + 0x14) + 0x14))(); + *(undefined4 *)(iVar1 + 0x14) = 0; + } + uVar2 = uVar2 + 1; + } while (uVar2 < *(uint *)(param_1 + 0x4c)); + } + return; +} + + + +// --- FUN_004529b0 at 0x004529B0 (size: 33) --- + +void __thiscall FUN_004529b0(int param_1,undefined4 *param_2) + +{ + *param_2 = *(undefined4 *)(param_1 + 0x8c); + param_2[1] = *(undefined4 *)(param_1 + 0x90); + param_2[2] = *(undefined4 *)(param_1 + 0x94); + return; +} + + + +// --- FUN_004529e0 at 0x004529E0 (size: 37) --- + +undefined4 * __thiscall FUN_004529e0(undefined4 *param_1,int param_2) + +{ + *param_1 = &PTR_LAB_00797910; + param_1[1] = *(undefined4 *)(param_2 + 4); + FUN_00425f10(param_2 + 8); + return param_1; +} + + + +// --- FUN_00452a10 at 0x00452A10 (size: 623) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __fastcall FUN_00452a10(int param_1) + +{ + undefined4 *puVar1; + bool bVar2; + uint uVar3; + float fVar4; + undefined4 local_d0; + undefined4 local_cc; + undefined4 local_c8; + undefined4 local_c4; + undefined4 local_9c; + undefined4 local_98; + undefined4 local_94; + undefined **local_90; + undefined4 local_8c; + undefined **local_48; + undefined4 local_44; + + puVar1 = (undefined4 *)(DAT_0083da58 + 0xbc); + if (*(int *)(DAT_0083da58 + 0xbc) == 0) { + *(undefined4 *)(DAT_0083da58 + 0xd4) = DAT_008452f4; + DAT_008452f4 = 1; + *puVar1 = 1; + } + if (*(int *)(param_1 + 0x18) == 0) { + return; + } + bVar2 = false; + if ((*(char *)(param_1 + 0x6d) != '\0') && (DAT_0081ffa0 < 2)) { + FUN_005a0d60(0xbfb33333); + bVar2 = true; + } + local_48 = &PTR_LAB_00797910; + local_44 = DAT_008200f4; + FUN_00425f10(&DAT_008200f8); + local_90 = &PTR_LAB_00797910; + local_8c = 0; + FUN_00425f10(param_1 + 0x1c); + FUN_00550fd0(&local_90); + uVar3 = 0; + if (*(int *)(param_1 + 8) != 0) { + do { + FUN_00515020(); + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 8)); + } + FUN_00550fd0(&local_48); + _DAT_008682b0 = *(undefined4 *)(param_1 + 0x5c); + _DAT_008682b4 = *(undefined4 *)(param_1 + 0x60); + _DAT_008682b8 = *(undefined4 *)(param_1 + 100); + FUN_0054e060(1); + DAT_008683b4 = 0; + DAT_0086b838 = 0; + FUN_0054e060(0); + if (*(char *)(param_1 + 0x6c) == '\0') { + fVar4 = *(float *)(param_1 + 0x68); + } + else { + if (*(char *)(DAT_0083da58 + 200) != '\0') { + FUN_0054be50(*(undefined4 *)(DAT_0083da58 + 0xc4)); + goto LAB_00452b74; + } + fVar4 = *(float *)(DAT_0083da58 + 0xc0) / ((float)DAT_00870340[0x2a] - _DAT_007958cc); + } + FUN_0054bee0(fVar4); +LAB_00452b74: + local_d0 = 0x3f800000; + local_cc = 0; + local_c8 = 0; + local_c4 = 0; + local_9c = 0; + local_98 = 0; + local_94 = 0; + FUN_00535b30(); + uVar3 = 0; + if (*(int *)(param_1 + 0x14) != 0) { + do { + FUN_0054dff0(*(undefined4 *)(*(int *)(param_1 + 0xc) + uVar3 * 4),0,&local_d0); + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 0x14)); + } + FUN_0052c560(); + if ((char)DAT_00870340[0x2b] != '\0') { + FUN_0054e830(param_1 + 0x1c); + FUN_0054fb60(); + FUN_0054dd60(3,&local_d0,(DAT_00867338 - _DAT_0086733c) + -1); + (**(code **)(*DAT_00870340 + 100))(*(undefined4 *)(param_1 + 0x18)); + FUN_0054c9e0(); + FUN_0059e3f0(0); + } + if (bVar2) { + FUN_005a0d60(*(undefined4 *)(DAT_0086734c + 0x98)); + } + FUN_0054e060(1); + DAT_008683b4 = 0; + DAT_0086b838 = 0; + FUN_0054e060(0); + return; +} + + + +// --- FUN_00452c80 at 0x00452C80 (size: 285) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __thiscall FUN_00452c80(int param_1,int param_2,int param_3) + +{ + int iVar1; + undefined4 uVar2; + + iVar1 = param_1 + 8; + *(undefined4 *)(param_1 + 0xc) = *(undefined4 *)(param_2 + 4); + FUN_00425f10(param_2 + 8); + if (param_3 != 0) { + *(undefined4 *)(param_1 + 0x5c) = *(undefined4 *)(param_2 + 4); + FUN_00425f10(param_2 + 8); + } + *(undefined4 *)(param_1 + 0x50) = 0; + _DAT_008196e0 = DAT_00819610; + DAT_0086b838 = 0; + _DAT_008196dc = DAT_0083dc10; + if (*(int *)(param_1 + 0xf8) == 0) { + if ((DAT_00819680 == 0) || (DAT_00819680 == 2)) { + _DAT_008196b8 = 0; + _DAT_008196bc = 0; + _DAT_008196c0 = 0; + } + uVar2 = *(undefined4 *)(param_1 + 0xc); + param_1 = param_1 + 0x10; + } + else { + if ((DAT_00819680 == 0) || (DAT_00819680 == 2)) { + _DAT_008196b8 = 0; + _DAT_008196bc = 0; + _DAT_008196c0 = 0x40000000; + } + uVar2 = *(undefined4 *)(*(int *)(param_1 + 0xf8) + 0x4c); + param_1 = *(int *)(param_1 + 0xf8) + 0x50; + } + FUN_0054e030(&DAT_00819680,uVar2,param_1); + thunk_FUN_0052e070(); + FUN_00550fd0(iVar1); + FUN_00505690(iVar1); + FUN_0043e8e0(iVar1); + return; +} + + + +// --- FUN_00452da0 at 0x00452DA0 (size: 49) --- + +void __fastcall FUN_00452da0(int param_1) + +{ + int iVar1; + undefined1 local_48 [72]; + + iVar1 = FUN_00456780(local_48,param_1 + 8); + *(undefined4 *)(param_1 + 0x5c) = *(undefined4 *)(iVar1 + 4); + FUN_00425f10(iVar1 + 8); + return; +} + + + +// --- FUN_00452de0 at 0x00452DE0 (size: 116) --- + +undefined4 __thiscall FUN_00452de0(int param_1,int param_2,undefined4 *param_3) + +{ + undefined4 *puVar1; + undefined4 local_18; + undefined4 local_14; + undefined4 local_10; + undefined1 local_c [12]; + + if (((*(int *)(param_1 + 0xf8) != 0) && (param_2 != 0)) && (*(int *)(param_2 + 0x90) != 0)) { + local_18 = 0; + local_14 = 0; + local_10 = 0; + puVar1 = (undefined4 *)FUN_00452830(local_c,param_2 + 0x48,&local_18); + *param_3 = *puVar1; + param_3[1] = puVar1[1]; + param_3[2] = puVar1[2]; + return 1; + } + return 0; +} + + + +// --- FUN_00452e60 at 0x00452E60 (size: 590) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 FUN_00452e60(undefined4 param_1,undefined4 *param_2,float *param_3) + +{ + int iVar1; + int iVar2; + int iVar3; + float *pfVar4; + undefined4 uVar5; + float10 fVar6; + undefined1 local_48 [8]; + float local_40; + float local_3c; + float local_38; + undefined1 local_34 [4]; + undefined1 auStack_30 [8]; + undefined1 local_28 [12]; + undefined1 local_1c [12]; + undefined4 local_10; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + iVar1 = FUN_00508890(); + if (iVar1 == 0) { + return 3; + } + uVar5 = 0; + FUN_0054fb60(); + local_40 = 1.0; + local_3c = 1.0; + local_38 = 1.0; + DAT_0081fec0 = 0x3f800000; + DAT_0081fec4 = 0x3f800000; + DAT_0081fec8 = 0x3f800000; + DAT_0081fc84 = 0x3f800000; + FUN_0054c9c0(3,iVar1 + 0x48); + iVar2 = FUN_0050f510(&local_10); + if (iVar2 == 0) { + local_38 = 0.1; + local_8 = 0x3dcccccd; + local_4 = 0x3dcccccd; + local_40 = 0.0; + local_3c = 0.0; + local_10 = 0; + local_c = 0; + } + iVar2 = FUN_0054ce60(&local_10); + FUN_0050a140(); + FUN_0050a140(); + if (iVar2 != 0) { + FUN_0054c010(&local_10,local_34,local_28); + iVar3 = (**(code **)(*DAT_0086734c + 0x44))(local_34,local_48); + if (iVar3 == 0) { + iVar2 = 0; + } + iVar3 = (**(code **)(*DAT_0086734c + 0x44))(auStack_30,&stack0xffffffa8); + if ((iVar3 != 0) && (iVar2 != 0)) { + if ((0 < iVar2) && (iVar2 < 3)) { + uVar5 = FUN_005df4c4(); + *param_2 = uVar5; + uVar5 = FUN_005df4c4(); + param_2[2] = uVar5; + uVar5 = FUN_005df4c4(); + param_2[1] = uVar5; + uVar5 = FUN_005df4c4(); + param_2[3] = uVar5; + uVar5 = 1; + } + goto LAB_0045308c; + } + } + pfVar4 = (float *)FUN_00452830(local_1c,iVar1 + 0x48,&local_10); + local_40 = *pfVar4; + local_3c = pfVar4[1]; + local_38 = pfVar4[2]; + iVar1 = FUN_004524a0(); + if (iVar1 == 0) { + if (local_3c <= DAT_00796344) { + fpatan((float10)_DAT_00795610,(float10)local_40); + fVar6 = (float10)_CIfmod(); + *param_3 = (float)fVar6; + } + else { + fpatan((float10)local_38,(float10)local_40); + fVar6 = (float10)_CIfmod(); + *param_3 = (float)fVar6; + } + } + else { + *param_3 = 0.0; + } + uVar5 = 2; +LAB_0045308c: + FUN_0054c9e0(); + FUN_00695670(); + FUN_00695670(); + return uVar5; +} + + + +// --- FUN_004530e0 at 0x004530E0 (size: 114) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __thiscall FUN_004530e0(int param_1,float param_2,undefined4 param_3) + +{ + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + *(float *)(param_1 + 0xcc) = param_2; + *(undefined4 *)(param_1 + 0xd0) = param_3; + if (*(int *)(param_1 + 0xbc) == 0) { + FUN_00451a60(param_3); + _DAT_008682b0 = local_c * param_2; + _DAT_008682b4 = local_8 * param_2; + _DAT_008682b8 = local_4 * param_2; + } + return; +} + + + +// --- FUN_00453160 at 0x00453160 (size: 81) --- + +undefined4 __fastcall FUN_00453160(int param_1) + +{ + if (*(int *)(param_1 + 0xbc) != 0) { + DAT_008452f4 = *(undefined4 *)(param_1 + 0xd4); + *(undefined4 *)(param_1 + 0xbc) = 0; + FUN_004530e0(*(undefined4 *)(param_1 + 0xcc),*(undefined4 *)(param_1 + 0xd0)); + DAT_008683b4 = 0; + DAT_0086b838 = 0; + FUN_0052eb50(); + } + return 1; +} + + + +// --- FUN_004531c0 at 0x004531C0 (size: 97) --- + +undefined1 __thiscall FUN_004531c0(int param_1,undefined4 param_2) + +{ + char cVar1; + int iVar2; + undefined1 unaff_BL; + undefined1 uVar3; + + cVar1 = *(char *)(*(int *)(param_1 + 0xa4) + 0x18); + FUN_00455a50(); + iVar2 = FUN_00505660(param_2); + uVar3 = iVar2 != 0; + if (((((bool)uVar3) && (cVar1 != '\0')) && (iVar2 = *(int *)(param_1 + 0xf8), iVar2 != 0)) && + (*(int *)(iVar2 + 0x4c) != 0)) { + FUN_00455ad0(iVar2 + 0x48,1); + uVar3 = unaff_BL; + } + return uVar3; +} + + + +// --- FUN_00453230 at 0x00453230 (size: 67) --- + +char FUN_00453230(undefined4 param_1) + +{ + char cVar1; + + FUN_00455a50(); + cVar1 = FUN_004ff370(param_1); + if (cVar1 != '\0') { + FUN_00507710(); + FUN_004531c0(DAT_0081ffb4); + } + return cVar1; +} + + + +// --- FUN_00453280 at 0x00453280 (size: 247) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __fastcall FUN_00453280(int param_1) + +{ + int iVar1; + float fVar2; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + if (*(int *)(param_1 + 0xf8) != 0) { + FUN_00455fc0(*(undefined4 *)(*(int *)(param_1 + 0xf8) + 8),0xffffffff); + iVar1 = *(int *)(param_1 + 0xa0); + local_c = 0; + *(undefined4 *)(iVar1 + 0x18) = 0; + local_8 = 0; + *(undefined4 *)(iVar1 + 0x1c) = 0; + local_4 = 0x3fc00000; + *(undefined4 *)(iVar1 + 0x20) = 0x3fc00000; + FUN_00455fa0(); + FUN_00455fb0(4); + local_c = 0; + local_8 = 0x3f800000; + local_4 = 0; + FUN_004564c0(&local_c); + FUN_00455fb0(1); + FUN_00455fb0(0x10); + iVar1 = *(int *)(param_1 + 0xa0); + fVar2 = _DAT_0079a1ec * *(float *)(iVar1 + 0x6c); + *(undefined4 *)(iVar1 + 0x48) = 0; + *(float *)(iVar1 + 0x4c) = fVar2; + *(float *)(iVar1 + 0x50) = *(float *)(iVar1 + 0x6c) * _DAT_0079c6dc; + } + return; +} + + + +// --- FUN_004534c0 at 0x004534C0 (size: 164) --- + +undefined4 +FUN_004534c0(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4,int param_5 + ) + +{ + undefined2 uVar1; + ushort uVar2; + ushort uVar3; + int iVar4; + uint uVar5; + bool bVar6; + + uVar1 = *(undefined2 *)(param_5 + 6); + uVar2 = *(ushort *)(param_5 + 4); + iVar4 = FUN_00508890(param_2); + if (iVar4 != 0) { + uVar3 = *(ushort *)(iVar4 + 0x174); + uVar5 = (int)((uint)uVar2 - (uint)uVar3) >> 0x1f; + if ((int)(((uint)uVar2 - (uint)uVar3 ^ uVar5) - uVar5) < 0x8000) { + bVar6 = uVar3 < uVar2; + } + else { + bVar6 = uVar2 < uVar3; + } + if (!bVar6) { + if (uVar3 == uVar2) { + FUN_00452200(iVar4,param_3,param_4,uVar1); + return 1; + } + return 2; + } + } + FUN_00509da0(param_2,param_1); + return 4; +} + + + +// --- FUN_004536e0 at 0x004536E0 (size: 110) --- + +uint __thiscall FUN_004536e0(int *param_1,int param_2) + +{ + int *in_EAX; + uint uVar1; + uint uVar2; + + if (param_2 != 0) { + uVar2 = 0; + in_EAX = (int *)0x0; + if (param_1[2] != 0) { + in_EAX = (int *)*param_1; + do { + if (*in_EAX == param_2) { + FUN_00513ef0(param_1[6]); + uVar1 = param_1[2]; + if (uVar2 < uVar1) { + uVar1 = uVar1 - 1; + param_1[2] = uVar1; + if (uVar2 != uVar1) { + *(undefined4 *)(*param_1 + uVar2 * 4) = *(undefined4 *)(*param_1 + uVar1 * 4); + uVar1 = param_1[2]; + *(undefined4 *)(*param_1 + uVar1 * 4) = 0; + } + } + return CONCAT31((int3)(uVar1 >> 8),1); + } + uVar2 = uVar2 + 1; + in_EAX = in_EAX + 1; + } while (uVar2 < (uint)param_1[2]); + } + } + return (uint)in_EAX & 0xffffff00; +} + + + +// --- FUN_00453750 at 0x00453750 (size: 22) --- + +undefined4 __thiscall FUN_00453750(int *param_1,uint param_2) + +{ + if ((uint)param_1[2] <= param_2) { + return 0; + } + return *(undefined4 *)(*param_1 + param_2 * 4); +} + + + +// --- FUN_00453770 at 0x00453770 (size: 35) --- + +void FUN_00453770(undefined4 param_1) + +{ + FUN_00536930(0,0,0,0); + FUN_004525f0(param_1); + return; +} + + + +// --- FUN_004537a0 at 0x004537A0 (size: 93) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void FUN_004537a0(float *param_1) + +{ + float local_18; + float local_14; + float local_10; + float local_4; + + FUN_00536930(0,0,0,0); + local_18 = *param_1 * _DAT_0079c504; + local_14 = param_1[1] * _DAT_0079c504; + local_10 = param_1[2] * _DAT_0079c504; + local_4 = local_10; + FUN_004525f0(&local_18); + return; +} + + + +// --- FUN_00453800 at 0x00453800 (size: 66) --- + +void __thiscall FUN_00453800(int *param_1,undefined4 param_2) + +{ + undefined4 *puVar1; + + puVar1 = (undefined4 *)FUN_005df0f5(8); + if (puVar1 == (undefined4 *)0x0) { + puVar1 = (undefined4 *)0x0; + } + else { + *puVar1 = param_2; + puVar1[1] = 0; + } + if (param_1[1] == 0) { + *param_1 = (int)puVar1; + param_1[1] = (int)puVar1; + return; + } + *(undefined4 **)(param_1[1] + 4) = puVar1; + param_1[1] = *(int *)(param_1[1] + 4); + return; +} + + + +// --- FUN_00453850 at 0x00453850 (size: 87) --- + +uint FUN_00453850(uint param_1) + +{ + int iVar1; + uint uVar2; + + if (param_1 < 9) { + return 8; + } + if (param_1 < 0x4001) { + iVar1 = 0x1f; + if (param_1 != 0) { + for (; param_1 >> iVar1 == 0; iVar1 = iVar1 + -1) { + } + } + uVar2 = 1 << ((byte)iVar1 & 0x1f); + if (uVar2 < param_1) { + param_1 = uVar2 * 2; + } + } + else if ((param_1 & 0x3fff) != 0) { + return param_1 + (0x4000 - (param_1 & 0x3fff)); + } + return param_1; +} + + + +// --- FUN_004538b0 at 0x004538B0 (size: 35) --- + +undefined4 * __thiscall FUN_004538b0(int param_1,undefined4 *param_2) + +{ + *param_2 = &PTR_LAB_00797910; + param_2[1] = *(undefined4 *)(param_1 + 0x1c); + FUN_00425f10(param_1 + 0x20); + return param_2; +} + + + +// --- FUN_004538e0 at 0x004538E0 (size: 40) --- + +void FUN_004538e0(void) + +{ + FUN_0054e370(&LAB_004530b0); + if (DAT_0083da58 != (undefined4 *)0x0) { + (**(code **)*DAT_0083da58)(1); + } + DAT_0083da58 = (undefined4 *)0x0; + return; +} + + + +// --- FUN_00453910 at 0x00453910 (size: 158) --- + +void __thiscall FUN_00453910(int param_1,int param_2,float param_3) + +{ + int iVar1; + float10 fVar2; + + iVar1 = *(int *)(param_1 + 0xf8); + if (iVar1 == 0) { + return; + } + if (param_2 == 0) { + fVar2 = (float10)FUN_0050f640(); + if ((float10)param_3 <= fVar2) goto LAB_00453987; + } + else { + *(undefined4 *)(param_1 + 0xdc) = 0; + *(undefined4 *)(param_1 + 0xe0) = 0; + *(undefined4 *)(param_1 + 0xe4) = 0; + FUN_005159d0(1); + (**(code **)(**(int **)(param_1 + 0xb8) + 0x74))(); + } + FUN_00452c80(iVar1 + 0x48,1); + FUN_00506d30(0); +LAB_00453987: + iVar1 = *(int *)(param_1 + 0xf8); + if ((iVar1 != 0) && (*(int *)(iVar1 + 0x4c) != 0)) { + FUN_00455ad0(iVar1 + 0x48,param_2); + } + return; +} + + + +// --- FUN_004539b0 at 0x004539B0 (size: 43) --- + +void __thiscall FUN_004539b0(int param_1,undefined4 param_2) + +{ + if (*(int *)(param_1 + 0xf8) != 0) { + FUN_00516db0(param_2,1); + FUN_00453910(1,0x7f7fffff); + } + return; +} + + + +// --- FUN_004539e0 at 0x004539E0 (size: 64) --- + +void __thiscall FUN_004539e0(int param_1,undefined4 param_2) + +{ + float10 fVar1; + + if (*(int *)(param_1 + 0xf8) != 0) { + fVar1 = (float10)FUN_005aa560(param_2); + FUN_00516db0(param_2,1); + FUN_00453910(0,(float)fVar1); + } + return; +} + + + +// --- FUN_00453a20 at 0x00453A20 (size: 131) --- + +void __thiscall FUN_00453a20(int param_1,int param_2) + +{ + int *piVar1; + undefined4 *puVar2; + int *piVar3; + + if (*(int *)(param_1 + 0xec) == 0) { + puVar2 = (undefined4 *)FUN_005df0f5(8); + if (puVar2 == (undefined4 *)0x0) { + puVar2 = (undefined4 *)0x0; + } + else { + *puVar2 = 0; + puVar2[1] = 0; + } + *(undefined4 **)(param_1 + 0xec) = puVar2; + } + InterlockedIncrement((LONG *)(param_2 + 4)); + piVar1 = *(int **)(param_1 + 0xec); + piVar3 = (int *)FUN_005df0f5(8); + if (piVar3 == (int *)0x0) { + piVar3 = (int *)0x0; + } + else { + *piVar3 = param_2; + piVar3[1] = 0; + } + if (piVar1[1] == 0) { + *piVar1 = (int)piVar3; + piVar1[1] = (int)piVar3; + return; + } + *(int **)(piVar1[1] + 4) = piVar3; + piVar1[1] = *(int *)(piVar1[1] + 4); + return; +} + + + +// --- FUN_00453ab0 at 0x00453AB0 (size: 144) --- + +void __fastcall FUN_00453ab0(int param_1) + +{ + int iVar1; + int *piVar2; + undefined4 *puVar3; + void *pvVar4; + LONG LVar5; + undefined4 *puVar6; + + if (*(int **)(param_1 + 0xec) != (int *)0x0) { + iVar1 = **(int **)(param_1 + 0xec); + while (iVar1 != 0) { + piVar2 = *(int **)(param_1 + 0xec); + puVar3 = (undefined4 *)*piVar2; + if (puVar3 == (undefined4 *)0x0) { + puVar6 = (undefined4 *)0x0; + } + else { + iVar1 = puVar3[1]; + *piVar2 = iVar1; + if (iVar1 == 0) { + piVar2[1] = 0; + } + puVar6 = (undefined4 *)*puVar3; + operator_delete(puVar3); + } + LVar5 = InterlockedDecrement(puVar6 + 1); + if ((LVar5 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + iVar1 = **(int **)(param_1 + 0xec); + } + pvVar4 = *(void **)(param_1 + 0xec); + if (pvVar4 != (void *)0x0) { + FUN_004c65a0(); + operator_delete(pvVar4); + } + *(undefined4 *)(param_1 + 0xec) = 0; + } + return; +} + + + +// --- FUN_00453b40 at 0x00453B40 (size: 325) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __fastcall FUN_00453b40(int param_1) + +{ + bool bVar1; + undefined4 uVar2; + bool bVar3; + undefined4 local_14; + undefined1 local_10 [16]; + + if ((char)DAT_00870340[0x2b] != '\0') { + bVar3 = (*(uint *)(param_1 + 0xc) & 0xffff) < 0x100; + if ((bVar3) || (*(int *)(*(int *)(param_1 + 0x50) + 0xe8) != 0)) { + bVar1 = true; + } + else { + bVar1 = false; + } + if (*(char *)(param_1 + 200) == '\0') { + FUN_0054bee0(*(float *)(param_1 + 0xc0) / ((float)DAT_00870340[0x2a] - _DAT_007958cc)); + } + else { + FUN_0054be50(*(undefined4 *)(param_1 + 0xc4)); + } + if (bVar3) { + FUN_00506d30(*(undefined4 *)(param_1 + 0xc)); + FUN_0054d9e0(param_1 + 8); + FUN_0054fb60(); + FUN_0054e060(1); + FUN_00506d90(); + } + else { + if (bVar1) { + uVar2 = FUN_004527f0(); + FUN_00506d30(uVar2); + } + FUN_0054d9e0(param_1 + 8); + (**(code **)(*DAT_00870340 + 0x48))(*(undefined4 *)(param_1 + 0x50)); + } + } + FUN_0059e3f0(0); + if ((*(int *)(param_1 + 0xfc) != 0) && (*(int *)(param_1 + 0x100) != 0)) { + uVar2 = FUN_00452e60(*(int *)(param_1 + 0xfc),local_10,&local_14); + (**(code **)(param_1 + 0x100))(*(undefined4 *)(param_1 + 0xfc),uVar2,local_10,local_14); + } + if (*(code **)(param_1 + 0x114) != (code *)0x0) { + (**(code **)(param_1 + 0x114))(); + } + return; +} + + + +// --- FUN_00453c90 at 0x00453C90 (size: 131) --- + +void __thiscall FUN_00453c90(int param_1,int param_2) + +{ + DAT_008452f4 = 0; + *(undefined4 *)(param_1 + 0xf8) = 0; + if (*(int *)(param_1 + 0xa8) != 0) { + FUN_0050a150(0); + } + if (*(int **)(param_1 + 0xb8) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0xb8) + 0x5c))(param_1); + } + if (*(int *)(param_1 + 0xa4) != 0) { + FUN_00455a50(); + } + *(undefined4 *)(param_1 + 0x50) = 0; + *(undefined4 *)(param_1 + 0xdc) = 0; + *(undefined4 *)(param_1 + 0xe4) = 0; + if (param_2 != 0) { + *(undefined4 *)(param_1 + 0xf4) = 0; + if (*(int **)(param_1 + 0xac) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0xac) + 0x30))(0); + FUN_00509700(); + } + FUN_00453ab0(); + } + return; +} + + + +// --- FUN_00453d20 at 0x00453D20 (size: 86) --- + +void __thiscall FUN_00453d20(int param_1,undefined4 param_2,undefined4 param_3) + +{ + *(undefined4 *)(param_1 + 0xf8) = param_2; + FUN_00453280(); + FUN_0050a150(*(undefined4 *)(param_1 + 0xf8)); + FUN_0050ff90(*(undefined4 *)(param_1 + 0xf8)); + DAT_00844c08 = *(undefined4 *)(*(int *)(param_1 + 0xf8) + 8); + (**(code **)(**(int **)(param_1 + 0xb8) + 0x6c))(param_3); + return; +} + + + +// --- FUN_00453d80 at 0x00453D80 (size: 745) --- + +void __fastcall FUN_00453d80(int param_1) + +{ + float *pfVar1; + undefined4 *puVar2; + int iVar3; + int iVar4; + undefined4 unaff_EBX; + int iVar5; + undefined ***pppuStack_188; + int local_174 [2]; + undefined **local_16c [13]; + float local_138; + float local_134; + float local_130; + undefined1 local_12c [12]; + undefined **local_120; + undefined4 local_11c; + undefined **local_118 [13]; + undefined4 local_e4; + undefined4 local_e0; + undefined4 local_dc; + undefined **local_d8; + undefined4 local_d4; + undefined **local_90; + undefined4 local_8c; + undefined1 auStack_54 [12]; + undefined **local_48; + undefined4 local_44; + + iVar3 = *(int *)(param_1 + 0xf8); + if (iVar3 == 0) { + return; + } + if (*(int *)(iVar3 + 0x90) == 0) { + FUN_00516d50(); + iVar3 = *(int *)(param_1 + 0xf8); + if (*(int *)(iVar3 + 0x90) == 0) { + pppuStack_188 = (undefined ***)0x453dc2; + FUN_00452c80(); + *(undefined4 *)(param_1 + 0x50) = 0; + return; + } + } + DAT_0081ff5c = *(undefined4 *)(iVar3 + 0x4c); + FUN_00425f10(); + if (DAT_0083da40 != 0) { + return; + } + local_11c = *(undefined4 *)(param_1 + 0x5c); + pppuStack_188 = (undefined ***)(param_1 + 0x60); + local_120 = &PTR_LAB_00797910; + FUN_00425f10(); + iVar3 = *(int *)(param_1 + 0xa0); + local_174[0] = 0; + iVar4 = *(int *)(iVar3 + 0x14); + if (iVar4 != -1) { + iVar5 = *(int *)(param_1 + 0xf8); + if (iVar4 < *(int *)(*(int *)(iVar5 + 0x10) + 0x58)) { + pppuStack_188 = + (undefined ***)(*(int *)(*(int *)(*(int *)(iVar5 + 0x10) + 0x5c) + iVar4 * 4) + 0x38); + goto LAB_00453e45; + } + } + iVar5 = *(int *)(param_1 + 0xf8); + pppuStack_188 = (undefined ***)(iVar5 + 0x50); +LAB_00453e45: + FUN_00425f10(); + pppuStack_188 = (undefined ***)(iVar3 + 0x18); + pfVar1 = (float *)FUN_00452530(local_12c); + local_138 = local_138 + *pfVar1; + local_134 = local_134 + pfVar1[1]; + local_130 = local_130 + pfVar1[2]; + if ((*(uint *)(iVar5 + 0x4c) & 0xffff) < 0x100) { + local_174[0] = *(int *)(iVar5 + 0x90); + } + else { + local_8c = *(undefined4 *)(iVar5 + 0x4c); + pppuStack_188 = local_16c; + local_90 = &PTR_LAB_00797910; + FUN_00425f10(); + pppuStack_188 = (undefined ***)0x1; + iVar3 = FUN_00512850(&local_90,&DAT_0083dc14,local_174,0); + if (iVar3 == 0) { + local_174[0] = *(int *)(*(int *)(param_1 + 0xf8) + 0x90); + } + } + iVar3 = local_174[0]; + local_d4 = *(undefined4 *)(local_174[0] + 0x28); + pppuStack_188 = local_16c; + local_d8 = &PTR_LAB_00797910; + FUN_00425f10(); + pppuStack_188 = &local_120; + puVar2 = (undefined4 *)FUN_00452900(local_12c); + local_e4 = *puVar2; + local_e0 = puVar2[1]; + local_dc = puVar2[2]; + pppuStack_188 = local_118; + local_44 = *(undefined4 *)(iVar3 + 0x28); + local_48 = &PTR_LAB_00797910; + FUN_00425f10(); + pppuStack_188 = (undefined ***)0x453f73; + iVar3 = FUN_0050bc20(); + if (iVar3 != 0) { + pppuStack_188 = (undefined ***)0x5c; + thunk_FUN_0050da00(*(undefined4 *)(param_1 + 0xf8)); + pppuStack_188 = (undefined ***)0x3f800000; + FUN_0050a920(1,&DAT_0083dc14); + FUN_0050a930(unaff_EBX,&local_e4,auStack_54); + iVar4 = FUN_0050cde0(); + if (iVar4 != 0) { + FUN_00452c80(iVar3 + 0xc0,0); + *(undefined4 *)(param_1 + 0x50) = *(undefined4 *)(iVar3 + 0xbc); + FUN_0050a890(iVar3); + return; + } + pppuStack_188 = (undefined ***)0x0; + iVar4 = FUN_00512850(&local_138,&DAT_0083dc14,&pppuStack_188,0,1); + if (iVar4 != 0) { + FUN_00452c80(&local_138,0); + *(undefined ****)(param_1 + 0x50) = pppuStack_188; + FUN_0050a890(iVar3); + return; + } + FUN_00452c80(*(int *)(param_1 + 0xf8) + 0x48,1); + *(undefined4 *)(param_1 + 0x50) = 0; + FUN_0050a890(iVar3); + } + return; +} + + + +// --- FUN_00454070 at 0x00454070 (size: 748) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __thiscall +FUN_00454070(int param_1,int param_2,int param_3,undefined4 param_4,int param_5,undefined4 param_6, + undefined4 param_7,uint param_8,undefined4 param_9) + +{ + ushort uVar1; + undefined2 uVar2; + int iVar3; + uint uVar4; + int *piVar5; + uint uVar6; + ushort uVar7; + bool bVar8; + float10 fVar9; + float fVar10; + undefined4 uStack_54; + undefined4 uStack_50; + undefined4 uStack_4c; + undefined **local_48; + undefined4 local_44; + + local_44 = *(undefined4 *)(param_3 + 4); + local_48 = &PTR_LAB_00797910; + FUN_00425f10(param_3 + 8); + uVar7 = (ushort)param_8; + if (param_2 == *(int *)(param_1 + 0xf8)) { + iVar3 = FUN_00451b50(6,param_9); + if (iVar3 != 0) { + uVar1 = *(ushort *)(*(int *)(param_1 + 0xf8) + 0x16c); + uVar4 = (uint)uVar1 - (param_8 & 0xffff); + uVar6 = (int)uVar4 >> 0x1f; + if ((int)((uVar4 ^ uVar6) - uVar6) < 0x8000) { + bVar8 = uVar7 < uVar1; + } + else { + bVar8 = uVar1 < uVar7; + } + if (!bVar8) { + fVar9 = (float10)FUN_00512010(); + FUN_00536b80((float)fVar9); + FUN_004539e0(&local_48); + *(undefined2 *)(*(int *)(param_1 + 0xf8) + 0x164) = (undefined2)param_7; + (**(code **)(**(int **)(param_1 + 0xb8) + 0x58))(); + return; + } + } + } + uVar2 = *(undefined2 *)(param_2 + 0x164); + iVar3 = FUN_00451b50(0,param_7); + if (iVar3 == 0) { + uVar1 = *(ushort *)(param_2 + 0x16c); + uVar4 = (param_8 & 0xffff) - (uint)uVar1; + uVar6 = (int)uVar4 >> 0x1f; + if ((int)((uVar4 ^ uVar6) - uVar6) < 0x8000) { + bVar8 = uVar1 < uVar7; + } + else { + bVar8 = uVar7 < uVar1; + } + if (bVar8) { + _DAT_0083dc24 = _DAT_0083dc24 + 1; + } + } + else { + uVar1 = *(ushort *)(param_2 + 0x16c); + uVar4 = (uint)uVar1 - (param_8 & 0xffff); + uVar6 = (int)uVar4 >> 0x1f; + if ((int)((uVar4 ^ uVar6) - uVar6) < 0x8000) { + bVar8 = uVar7 < uVar1; + } + else { + bVar8 = uVar1 < uVar7; + } + if (bVar8) { + *(undefined2 *)(param_2 + 0x164) = uVar2; + return; + } + if ((*(int *)(param_2 + 0x40) != 0) && + (*(int *)(*(int *)(param_2 + 0x40) + 8) != *(int *)(param_1 + 0xf4))) { + piVar5 = (int *)FUN_005088e0(*(undefined4 *)(param_2 + 8)); + if (piVar5 != (int *)0x0) { + (**(code **)(*piVar5 + 0xc))(0); + } + } + FUN_00513f70(); + iVar3 = FUN_00510240(); + if (iVar3 == 0) { + FUN_00511e50(param_4,1); + } + if (param_2 == *(int *)(param_1 + 0xf8)) { + iVar3 = FUN_00451b50(4,param_8); + if (iVar3 != 0) { + FUN_004539b0(&local_48); + fVar9 = (float10)FUN_0050f6e0(); + fVar10 = (float)fVar9; + fVar9 = (float10)FUN_0050f690(fVar10); + FUN_00510ff0(&local_48,(float)fVar9,fVar10); + uStack_54 = 0; + uStack_50 = 0; + uStack_4c = 0; + FUN_00511ec0(&uStack_54,1); + return; + } + fVar9 = (float10)FUN_0050f6e0(); + fVar10 = (float)fVar9; + fVar9 = (float10)FUN_0050f690(fVar10); + FUN_00510ff0(&local_48,(float)fVar9,fVar10); + iVar3 = (**(code **)(**(int **)(param_1 + 0xb8) + 0x60))(); + if ((iVar3 != 0) && (param_5 != 0)) { + iVar3 = (**(code **)(**(int **)(param_1 + 0xb8) + 0xb4))(); + FUN_00510fc0(&local_48,iVar3 != 0); + return; + } + } + else { + iVar3 = FUN_00516e30(&local_48,param_8,param_5,param_6); + if (iVar3 != 0) { + fVar9 = (float10)FUN_0050f6e0(); + fVar10 = (float)fVar9; + fVar9 = (float10)FUN_0050f690(fVar10); + FUN_00510ff0(param_2 + 0x48,(float)fVar9,fVar10); + return; + } + } + } + return; +} + + + +// --- FUN_00454430 at 0x00454430 (size: 90) --- + +undefined4 * __fastcall FUN_00454430(undefined4 *param_1) + +{ + *param_1 = 0; + param_1[1] = 0; + param_1[2] = 0; + param_1[3] = 0; + param_1[4] = 0; + param_1[5] = 0; + param_1[6] = 0; + param_1[7] = 0x3f800000; + param_1[8] = 0; + param_1[9] = 0; + param_1[10] = 0; + param_1[0x14] = 0; + param_1[0x15] = 0; + param_1[0x16] = 0; + FUN_00535b30(); + param_1[0x17] = 0x3e99999a; + param_1[0x18] = 0x3e99999a; + param_1[0x19] = 0x3e99999a; + *(undefined1 *)(param_1 + 0x1b) = 0; + *(undefined1 *)((int)param_1 + 0x6d) = 0; + param_1[0x1a] = 0x3f490fdb; + return param_1; +} + + + +// --- FUN_00454490 at 0x00454490 (size: 64) --- + +void __fastcall FUN_00454490(int param_1) + +{ + uint uVar1; + + if (*(int *)(param_1 + 0x18) != 0) { + uVar1 = 0; + if (*(int *)(param_1 + 8) != 0) { + do { + FUN_00513ef0(*(undefined4 *)(param_1 + 0x18)); + uVar1 = uVar1 + 1; + } while (uVar1 < *(uint *)(param_1 + 8)); + } + FUN_0052f310(1); + } + FUN_0044dcb0(); + return; +} + + + +// --- FUN_004544d0 at 0x004544D0 (size: 130) --- + +void __fastcall FUN_004544d0(int param_1) + +{ + void *pvVar1; + int iVar2; + uint uVar3; + + uVar3 = 0; + if (*(int *)(param_1 + 0x14) != 0) { + do { + pvVar1 = *(void **)(*(int *)(param_1 + 0xc) + uVar3 * 4); + if (pvVar1 != (void *)0x0) { + operator_delete(pvVar1); + } + uVar3 = uVar3 + 1; + } while (uVar3 < *(uint *)(param_1 + 0x14)); + } + *(undefined4 *)(param_1 + 0x14) = 0; + if ((*(uint *)(param_1 + 0x10) & 0x80000000) == 0x80000000) { + operator_delete__(*(void **)(param_1 + 0xc)); + *(undefined4 *)(param_1 + 0xc) = 0; + *(undefined4 *)(param_1 + 0x10) = 0; + return; + } + if (*(int *)(param_1 + 0xc) != 0) { + iVar2 = (*(uint *)(param_1 + 0x10) & 0x7fffffff) - 1; + while (-1 < iVar2) { + iVar2 = iVar2 + -1; + *(undefined4 *)(*(int *)(param_1 + 0xc) + 4 + iVar2 * 4) = 0; + } + } + return; +} + + + +// --- FUN_00454560 at 0x00454560 (size: 35) --- + +undefined4 __thiscall FUN_00454560(int param_1,uint param_2,undefined4 param_3) + +{ + if (param_2 < *(uint *)(param_1 + 0x14)) { + FUN_00452740(param_3); + return 1; + } + return 0; +} + + + +// --- FUN_00454590 at 0x00454590 (size: 162) --- + +int * __thiscall FUN_00454590(int *param_1,int *param_2,int *param_3) + +{ + int *piVar1; + int *piVar2; + int *piVar3; + int iVar4; + int *local_4; + + piVar1 = param_3; + local_4 = param_1; + if (param_3 == (int *)0x0) { + piVar3 = (int *)*param_1; + if (piVar3 != (int *)0x0) { + *param_1 = 0; + (**(code **)(*piVar3 + 0x14))(); + param_1[1] = 0; + } + iVar4 = -0x7fffbffe; + } + else { + iVar4 = *param_3; + param_3 = (int *)0x0; + piVar3 = (int *)(**(code **)(iVar4 + 0xc))(&local_4,&DAT_0079c5e8,¶m_3); + piVar2 = param_3; + iVar4 = *piVar3; + piVar3 = (int *)*param_1; + if (iVar4 < 0) { + if (piVar3 != (int *)0x0) { + (**(code **)(*piVar3 + 0x14))(); + } + *param_1 = 0; + param_1[1] = 0; + *param_2 = iVar4; + (**(code **)(*piVar1 + 0x14))(); + return param_2; + } + if (piVar3 != (int *)0x0) { + (**(code **)(*piVar3 + 0x14))(); + } + *param_1 = (int)piVar2; + param_1[1] = 0; + } + *param_2 = iVar4; + if (piVar1 != (int *)0x0) { + (**(code **)(*piVar1 + 0x14))(); + } + return param_2; +} + + + +// --- FUN_00454640 at 0x00454640 (size: 724) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 * __thiscall FUN_00454640(undefined4 *param_1,int param_2) + +{ + LONG LVar1; + undefined4 *puVar2; + int local_50 [17]; + undefined4 uStack_c; + undefined4 uStack_8; + undefined4 uStack_4; + + *param_1 = &PTR_FUN_0079c76c; + param_1[1] = 0; + param_1[3] = 0; + param_1[2] = &PTR_LAB_00797910; + param_1[4] = 0x3f800000; + param_1[5] = 0; + param_1[6] = 0; + param_1[7] = 0; + param_1[0x11] = 0; + param_1[0x12] = 0; + param_1[0x13] = 0; + FUN_00535b30(); + param_1[0x14] = 0; + param_1[0x15] = 0x10; + param_1[0x16] = &PTR_LAB_00797910; + param_1[0x17] = 0; + param_1[0x18] = 0x3f800000; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + param_1[0x25] = 0; + param_1[0x26] = 0; + param_1[0x27] = 0; + FUN_00535b30(); + param_1[0x3a] = param_2; + param_1[0x28] = 0; + param_1[0x29] = 0; + param_1[0x2a] = 0; + param_1[0x2b] = 0; + param_1[0x2c] = 0; + param_1[0x2d] = 0; + param_1[0x2e] = 0; + param_1[0x2f] = 0; + param_1[0x30] = 0x3fc90fdb; + param_1[0x31] = 0; + *(undefined1 *)(param_1 + 0x32) = 0; + param_1[0x33] = 0; + param_1[0x35] = 0; + param_1[0x36] = 0; + param_1[0x37] = 0; + param_1[0x38] = 0; + param_1[0x39] = 0; + param_1[0x3b] = 0; + param_1[0x3c] = 0; + param_1[0x3d] = 0; + param_1[0x3e] = 0; + param_1[0x3f] = 0; + param_1[0x40] = 0; + param_1[0x41] = 0; + param_1[0x42] = 0; + param_1[0x43] = 0; + param_1[0x44] = 0; + param_1[0x45] = 0; + _DAT_0083dc14 = 0; + local_50[1] = 0; + local_50[2] = 0; + local_50[3] = 0; + _DAT_0083dc18 = 0; + _DAT_0083dc1c = 0; + _DAT_0083dc20 = 0x3e99999a; + FUN_00401340("The intensity of the player light"); + FUN_00401340("SmartBox.ViewerLightIntensity"); + FUN_004369a0(&DAT_0083dc10,9,¶m_2,local_50,0,0,0,0); + puVar2 = (undefined4 *)(param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + puVar2 = (undefined4 *)(local_50[0] + -0x14); + LVar1 = InterlockedDecrement((LONG *)(local_50[0] + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + FUN_00401340("The falloff distance of the player light"); + FUN_00401340("SmartBox.ViewerLightFalloff"); + FUN_004369a0(&DAT_00819610,9,¶m_2,local_50,0,0,0,0); + puVar2 = (undefined4 *)(param_2 + -0x14); + LVar1 = InterlockedDecrement((LONG *)(param_2 + -0x10)); + if ((LVar1 == 0) && (puVar2 != (undefined4 *)0x0)) { + (**(code **)*puVar2)(1); + } + LVar1 = InterlockedDecrement((LONG *)(local_50[0] + -0x10)); + if ((LVar1 == 0) && ((undefined4 *)(local_50[0] + -0x14) != (undefined4 *)0x0)) { + (*(code *)**(undefined4 **)(local_50[0] + -0x14))(1); + } + DAT_00819680 = 0; + local_50[4] = 0x3f800000; + local_50[5] = 0; + local_50[6] = 0; + local_50[7] = 0; + uStack_c = 0; + uStack_8 = 0; + uStack_4 = 0; + FUN_00535b30(); + FUN_00425f10(local_50 + 4); + FUN_00451a60(0xffffffff); + _DAT_008196dc = DAT_0083dc10; + _DAT_008196e0 = DAT_00819610; + _DAT_008196e4 = 0x43b40000; + return param_1; +} + + + +// --- FUN_00454920 at 0x00454920 (size: 489) --- + +void __fastcall FUN_00454920(undefined4 *param_1) + +{ + void *pvVar1; + LONG LVar2; + undefined4 *puVar3; + undefined4 *local_4; + + *param_1 = &PTR_FUN_0079c76c; + local_4 = param_1; + FUN_00453c90(1); + FUN_00401340("SmartBox.ViewerLightIntensity"); + FUN_00436cf0(&local_4); + puVar3 = local_4 + -5; + LVar2 = InterlockedDecrement(local_4 + -4); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + FUN_00401340("SmartBox.ViewerLightFalloff"); + FUN_00436cf0(&local_4); + puVar3 = local_4 + -5; + LVar2 = InterlockedDecrement(local_4 + -4); + if ((LVar2 == 0) && (puVar3 != (undefined4 *)0x0)) { + (**(code **)*puVar3)(1); + } + if (param_1[0x28] != 0) { + if (DAT_00837ff4 != (int *)0x0) { + (**(code **)(*DAT_00837ff4 + 0x4c))(param_1[0x28],4); + } + if (param_1[0x28] != 0) { + (*(code *)**(undefined4 **)(param_1[0x28] + 4))(1); + } + param_1[0x28] = 0; + } + if (param_1[0x29] != 0) { + *(undefined4 *)(param_1[0x29] + 4) = 0; + pvVar1 = (void *)param_1[0x29]; + if (pvVar1 != (void *)0x0) { + FUN_00455930(); + operator_delete(pvVar1); + } + param_1[0x29] = 0; + } + if ((int *)param_1[0x2e] != (int *)0x0) { + (**(code **)(*(int *)param_1[0x2e] + 0x5c))(0); + if ((undefined4 *)param_1[0x2e] != (undefined4 *)0x0) { + (*(code *)**(undefined4 **)param_1[0x2e])(1); + } + param_1[0x2e] = 0; + } + FUN_0052b980(0); + FUN_0050ff80(0); + DAT_00842b98 = 0; + DAT_008456f0 = 0; + if (param_1[0x2d] != 0) { + FUN_00452960(); + pvVar1 = (void *)param_1[0x2d]; + if (pvVar1 != (void *)0x0) { + FUN_00552380(); + operator_delete(pvVar1); + } + param_1[0x2d] = 0; + } + pvVar1 = (void *)param_1[0x2c]; + if (pvVar1 != (void *)0x0) { + FUN_00505e70(); + operator_delete(pvVar1); + param_1[0x2c] = 0; + } + pvVar1 = (void *)param_1[0x2a]; + if (pvVar1 != (void *)0x0) { + FUN_0050a3e0(); + operator_delete(pvVar1); + param_1[0x2a] = 0; + } + if ((int *)param_1[0x2b] != (int *)0x0) { + (**(code **)(*(int *)param_1[0x2b] + 0x14))(); + param_1[0x2b] = 0; + } + FUN_004ff3b0(); + pvVar1 = DAT_008ee9c8; + if (DAT_008ee9c8 != (void *)0x0) { + FUN_005a7f80(); + operator_delete(pvVar1); + DAT_008ee9c8 = (void *)0x0; + } + param_1[0x16] = &PTR_FUN_0079385c; + param_1[2] = &PTR_FUN_0079385c; + return; +} + + + +// --- FUN_00454b10 at 0x00454B10 (size: 171) --- + +void __fastcall FUN_00454b10(int *param_1) + +{ + int *piVar1; + undefined4 *puVar2; + void *pvVar3; + int iVar4; + LONG LVar5; + undefined4 *puVar6; + + if ((int *)param_1[0x3b] != (int *)0x0) { + iVar4 = *(int *)param_1[0x3b]; + while (iVar4 != 0) { + piVar1 = (int *)param_1[0x3b]; + puVar2 = (undefined4 *)*piVar1; + if (puVar2 == (undefined4 *)0x0) { + puVar6 = (undefined4 *)0x0; + } + else { + iVar4 = puVar2[1]; + *piVar1 = iVar4; + if (iVar4 == 0) { + piVar1[1] = 0; + } + puVar6 = (undefined4 *)*puVar2; + operator_delete(puVar2); + } + iVar4 = (**(code **)(*param_1 + 4))(puVar6); + if (iVar4 == 0) { + FUN_00453a20(puVar6); + } + else { + (**(code **)(*param_1 + 8))(puVar6); + } + LVar5 = InterlockedDecrement(puVar6 + 1); + if ((LVar5 == 0) && (puVar6 != (undefined4 *)0x0)) { + (**(code **)*puVar6)(1); + } + iVar4 = *(int *)param_1[0x3b]; + } + pvVar3 = (void *)param_1[0x3b]; + if (pvVar3 != (void *)0x0) { + FUN_004c65a0(); + operator_delete(pvVar3); + } + param_1[0x3b] = 0; + } + return; +} + + + +// --- FUN_00454bc0 at 0x00454BC0 (size: 250) --- + +void __thiscall FUN_00454bc0(int *param_1,int param_2) + +{ + undefined4 *puVar1; + void *pvVar2; + void *pvVar3; + int *piVar4; + int *piVar5; + LONG LVar6; + int *piVar7; + int iVar8; + int *piVar9; + int *piVar10; + bool bVar11; + + if (*(int **)(param_2 + 300) != (int *)0x0) { + (**(code **)(**(int **)(param_2 + 300) + 8))(); + } + piVar4 = *(int **)(param_2 + 0xc); + if (piVar4 != (int *)0x0) { + piVar7 = (int *)0x0; + piVar9 = (int *)0x0; + if (*piVar4 != 0) { + do { + piVar5 = (int *)*piVar4; + if (piVar5 == (int *)0x0) { + iVar8 = 0; + } + else { + iVar8 = piVar5[1]; + *piVar4 = iVar8; + if (iVar8 == 0) { + piVar4[1] = 0; + } + iVar8 = *piVar5; + operator_delete(piVar5); + } + piVar5 = (int *)FUN_005df0f5(8); + if (piVar5 == (int *)0x0) { + piVar5 = (int *)0x0; + } + else { + *piVar5 = iVar8; + piVar5[1] = 0; + } + piVar10 = piVar5; + if (piVar7 != (int *)0x0) { + piVar7[1] = (int)piVar5; + piVar10 = piVar9; + } + piVar4 = *(int **)(param_2 + 0xc); + piVar7 = piVar5; + piVar9 = piVar10; + } while (*piVar4 != 0); + while (piVar10 != (int *)0x0) { + piVar4 = (int *)piVar10[1]; + puVar1 = (undefined4 *)*piVar10; + operator_delete(piVar10); + iVar8 = (**(code **)(*param_1 + 4))(puVar1); + if (iVar8 == 0) { + FUN_00453a20(puVar1); + } + else { + (**(code **)(*param_1 + 8))(puVar1); + } + LVar6 = InterlockedDecrement(puVar1 + 1); + piVar10 = piVar4; + if ((LVar6 == 0) && (puVar1 != (undefined4 *)0x0)) { + (**(code **)*puVar1)(1); + } + } + } + bVar11 = false; + pvVar3 = (void *)0x0; + while (bVar11) { + pvVar2 = *(void **)((int)pvVar3 + 4); + operator_delete(pvVar3); + bVar11 = pvVar2 != (void *)0x0; + pvVar3 = pvVar2; + } + } + return; +} + + + +// --- FUN_00454cc0 at 0x00454CC0 (size: 93) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __fastcall FUN_00454cc0(int param_1) + +{ + undefined4 uVar1; + + FUN_00453160(); + if (*(int *)(param_1 + 0xf8) != 0) { + FUN_00453d80(); + if (*(int *)(param_1 + 0x50) != 0) { + FUN_00453b40(); + } + } + if (DAT_0083da48 != '\0') { + uVar1 = FUN_0054d590(); + DAT_0083da44 = FUN_0054d560(); + _DAT_00819618 = uVar1; + FUN_006935e0(DAT_0083da44); + DAT_0083da48 = '\0'; + } + FUN_0054c3a0(); + return; +} + + + +// --- FUN_00454d20 at 0x00454D20 (size: 1167) --- + +undefined4 __thiscall +FUN_00454d20(int param_1,undefined4 param_2,int param_3,undefined4 param_4,int param_5, + undefined4 param_6,int param_7) + +{ + short sVar1; + short sVar2; + int iVar3; + int iVar4; + undefined4 uVar5; + undefined4 uVar6; + undefined4 uVar7; + undefined4 uVar8; + undefined4 uVar9; + undefined ***pppuVar10; + int local_bc; + int local_b8; + undefined4 local_b4; + int local_b0; + undefined **local_ac; + int local_a8; + undefined4 local_a4; + undefined1 local_a0 [4]; + undefined1 local_9c [4]; + int local_98; + undefined **ppuStack_58; + undefined4 local_54 [21]; + + local_b0 = 0; + local_bc = 0; + local_b8 = 0; + iVar3 = FUN_0051df90(); + if ((iVar3 != 0) && (local_b0 = FUN_00508890(iVar3), local_b0 == 0)) { + FUN_00509da0(iVar3,param_2); + return 4; + } + iVar4 = FUN_00508a40(param_3,&local_bc,&local_b8); + if (iVar4 == 0) { +LAB_00455046: + if (local_bc == 0) goto LAB_0045504a; + } + else { + if (local_bc != 0) { + if (param_7 == 0) { + local_b4 = CONCAT22(local_b4._2_2_,*(undefined2 *)(local_bc + 0x174)); + uVar5 = FUN_0051df80(8); + iVar4 = FUN_00451b10(local_b4,uVar5); + if (iVar4 == 0) { + FUN_0050f430(&local_b4); + FUN_0051e280(local_a0); + sVar1 = *(short *)(local_bc + 0x174); + sVar2 = FUN_0051df80(8); + if (sVar1 != sVar2) { + return 2; + } + uVar5 = FUN_0051df80(7); + FUN_00451f80(local_bc,param_4,uVar5); + uVar5 = FUN_0051df80(0); + if (iVar3 == 0) { + uVar6 = FUN_0051df80(4); + local_b4 = FUN_0051df80(6); + FUN_004538b0(local_9c); + if (local_98 == 0) { + FUN_00452280(local_bc,uVar5); + } + else { + local_ac = *(undefined ***)(param_5 + 0x74); + local_a8 = *(int *)(param_5 + 0x78); + local_a4 = *(undefined4 *)(param_5 + 0x7c); + pppuVar10 = &local_ac; + uVar9 = 1; + uVar8 = local_b4; + uVar7 = FUN_004f32b0(1,pppuVar10,uVar5,uVar6,local_b4); + FUN_00454070(local_bc,local_9c,uVar7,uVar9,pppuVar10,uVar5,uVar6,uVar8); + } + } + else { + uVar6 = FUN_004f32b0(uVar5); + uVar8 = FUN_0051dfa0(uVar6); + FUN_004522d0(local_bc,local_b0,uVar8,uVar6,uVar5); + } + iVar3 = FUN_004f8da0(); + if (iVar3 != 0) { + uVar5 = FUN_0051df70(); + uVar6 = FUN_0051df80(5); + uVar8 = FUN_0051df80(1); + uVar7 = FUN_004f8da0(uVar8,uVar6,uVar5); + uVar9 = FUN_004f8d90(uVar7); + FUN_0050a160(local_bc,uVar9,uVar7,uVar8,uVar6,uVar5); + } + uVar5 = FUN_0051df80(2); + FUN_00452110(local_bc,*(undefined4 *)(param_5 + 0x60),uVar5); + uVar5 = FUN_0051df80(3); + local_ac = *(undefined ***)(param_5 + 0x74); + local_a8 = *(undefined4 *)(param_5 + 0x78); + local_a4 = *(undefined4 *)(param_5 + 0x7c); + uVar6 = FUN_004529b0(local_54); + FUN_00452200(local_bc,&local_ac,uVar6,uVar5); + if (local_b8 != 0) { + (**(code **)(**(int **)(param_1 + 0xac) + 0x28))(local_b8,param_6,1); + } + if (*(int *)(local_bc + 0x4c) == 0) { + if (local_b8 != 0) { + return 1; + } + FUN_00509a40(*(undefined4 *)(local_bc + 8)); + return 1; + } + if (*(int *)(local_bc + 0x90) != 0) { + FUN_00508f10(*(undefined4 *)(local_bc + 8)); + return 1; + } + FUN_00509a40(*(undefined4 *)(local_bc + 8)); + return 1; + } + } + goto LAB_00455046; + } +LAB_0045504a: + if (local_b8 == 0) goto LAB_0045505e; + } + (**(code **)(**(int **)(param_1 + 0xac) + 0x1c))(param_3); +LAB_0045505e: + iVar3 = (**(code **)(**(int **)(param_1 + 0xac) + 0x2c))(param_3,param_4,param_5,param_6); + if (iVar3 != 0) { + if (param_3 == *(int *)(param_1 + 0xf4)) { + uVar5 = FUN_0051df70(); + FUN_00453d20(iVar3,uVar5); + local_54[0] = *(undefined4 *)(param_5 + 0x1c); + ppuStack_58 = &PTR_LAB_00797910; + FUN_00425f10(param_5 + 0x20); + FUN_00514ca0(&ppuStack_58); + iVar4 = *(int *)(param_1 + 0xf8); + if ((iVar4 != 0) && (*(int *)(iVar4 + 0x4c) != 0)) { + FUN_00455ad0(iVar4 + 0x48,1); + } + local_a8 = *(int *)(param_5 + 0x1c); + local_ac = &PTR_LAB_00797910; + FUN_00425f10(param_5 + 0x20); + if (*(int *)(param_1 + 0xf8) != 0) { + FUN_00516e10(&local_ac); + FUN_00453910(1,0x7f7fffff); + } + (**(code **)(**(int **)(param_1 + 0xac) + 0x30))(param_4); + } + else { + iVar4 = FUN_0051df90(); + if (iVar4 == 0) { + local_a8 = *(int *)(param_5 + 0x1c); + FUN_00425f10(param_5 + 0x20); + if (local_a8 != 0) { + uVar5 = FUN_004538b0(&local_ac); + FUN_00516e10(uVar5); + } + } + } + FUN_00454bc0(iVar3); + return 1; + } + return 3; +} + + + +// --- FUN_004551b0 at 0x004551B0 (size: 62) --- + +undefined4 __thiscall FUN_004551b0(int param_1,undefined4 param_2,undefined4 param_3) + +{ + if (*(int *)(param_1 + 0xf4) != 0) { + return 3; + } + *(undefined4 *)(param_1 + 0xf4) = param_3; + FUN_00454b10(); + (**(code **)(**(int **)(param_1 + 0xb8) + 0x88))(); + return 1; +} + + + +// --- FUN_004551f0 at 0x004551F0 (size: 86) --- + +void __fastcall FUN_004551f0(undefined4 *param_1) + +{ + FUN_00454490(); + if ((int *)param_1[6] != (int *)0x0) { + (**(code **)(*(int *)param_1[6] + 0x18))(1); + } + param_1[6] = 0; + if ((param_1[4] & 0x80000000) == 0x80000000) { + operator_delete__((void *)param_1[3]); + } + if ((param_1[1] & 0x80000000) == 0x80000000) { + operator_delete__((void *)*param_1); + } + return; +} + + + +// --- FUN_00455250 at 0x00455250 (size: 62) --- + +undefined4 * __thiscall FUN_00455250(undefined4 *param_1,int *param_2) + +{ + undefined4 *puVar1; + int *piVar2; + undefined4 uVar3; + + *param_1 = 0; + param_1[1] = 0; + piVar2 = (int *)*param_2; + uVar3 = 0; + if (piVar2 != (int *)0x0) { + (**(code **)(*piVar2 + 0x10))(piVar2,0); + } + puVar1 = (undefined4 *)FUN_00454590(¶m_2,piVar2,uVar3); + param_1[1] = *puVar1; + return param_1; +} + + + +// --- FUN_00455290 at 0x00455290 (size: 533) --- + +uint __fastcall FUN_00455290(int param_1) + +{ + int iVar1; + int *piVar2; + undefined4 *puVar3; + uint uVar4; + undefined1 *puVar5; + undefined *puVar6; + undefined *puVar7; + undefined4 uVar8; + int *piVar9; + int **ppiVar10; + int *local_14; + undefined1 local_10 [4]; + undefined1 local_c [4]; + int local_8; + undefined4 local_4; + + ppiVar10 = &local_14; + uVar8 = 0; + puVar7 = &DAT_0079c69c; + puVar5 = local_10; + puVar6 = &DAT_0079c5f8; + local_14 = (int *)0x0; + FUN_00406d10(puVar5,&DAT_0079c5f8,&DAT_0079c69c,0,ppiVar10); + FUN_00406650(puVar5,puVar6,puVar7,uVar8,ppiVar10); + piVar2 = local_14; + uVar8 = 0; + local_8 = 0; + local_4 = 0; + piVar9 = local_14; + if (local_14 != (int *)0x0) { + (**(code **)(*local_14 + 0x10))(local_14,0); + } + FUN_00454590(local_c,piVar9,uVar8); + if (piVar2 != (int *)0x0) { + (**(code **)(*piVar2 + 0x14))(); + } + uVar4 = 0; + if (local_8 != 0) { + *(int *)(param_1 + 0xac) = local_8; + if (*(int *)(param_1 + 4) != 0) { + *(undefined4 *)(local_8 + 0x10) = 0; + } + iVar1 = FUN_005df0f5(0x10); + if (iVar1 == 0) { + iVar1 = 0; + } + else { + iVar1 = FUN_0050a530(*(undefined4 *)(param_1 + 0xac),param_1); + } + *(int *)(param_1 + 0xa8) = iVar1; + uVar4 = 0; + if (iVar1 != 0) { + iVar1 = FUN_005df0f5(0x34); + if (iVar1 == 0) { + iVar1 = 0; + } + else { + iVar1 = FUN_00505dd0(); + } + *(int *)(param_1 + 0xb0) = iVar1; + uVar4 = 0; + if (iVar1 != 0) { + iVar1 = FUN_005df0f5(0x74); + if (iVar1 == 0) { + iVar1 = 0; + } + else { + iVar1 = FUN_00552300(); + } + *(int *)(param_1 + 0xb4) = iVar1; + uVar4 = 0; + if (iVar1 != 0) { + (**(code **)(*DAT_00870340 + 0x44))(*(undefined4 *)(param_1 + 0xb0)); + FUN_0052b980(*(undefined4 *)(param_1 + 0xac)); + FUN_0050ff80(*(undefined4 *)(param_1 + 0xac)); + DAT_00842b98 = *(undefined4 *)(param_1 + 0xac); + DAT_008456f0 = *(undefined4 *)(param_1 + 0xb0); + piVar2 = (int *)FUN_0054bad0(); + *(int **)(param_1 + 0xb8) = piVar2; + uVar4 = 0; + if (piVar2 != (int *)0x0) { + (**(code **)(*piVar2 + 0x5c))(DAT_0083da58); + (**(code **)(**(int **)(param_1 + 0xb8) + 0xb0))(DAT_00819614); + iVar1 = FUN_005df0f5(0x78); + if (iVar1 == 0) { + puVar3 = (undefined4 *)0x0; + } + else { + puVar3 = (undefined4 *)FUN_004558d0(); + } + *(undefined4 **)(param_1 + 0xa4) = puVar3; + uVar4 = 0; + if (puVar3 != (undefined4 *)0x0) { + *puVar3 = *(undefined4 *)(param_1 + 0xb0); + *(undefined4 *)(*(int *)(param_1 + 0xa4) + 4) = *(undefined4 *)(param_1 + 0xb4); + iVar1 = FUN_005df0f5(0xc0); + if (iVar1 == 0) { + uVar4 = 0; + } + else { + uVar4 = FUN_004571b0(); + } + *(uint *)(param_1 + 0xa0) = uVar4; + if ((uVar4 != 0) && (DAT_00837ff4 != (int *)0x0)) { + (**(code **)(*DAT_00837ff4 + 0x48))(uVar4,4); + FUN_00453280(); + *(undefined4 *)(param_1 + 0xd8) = 1; + return 1; + } + } + } + } + } + } + } + return uVar4 & 0xffffff00; +} + + + +// --- FUN_004554b0 at 0x004554B0 (size: 337) --- + +void __fastcall FUN_004554b0(int *param_1) + +{ + int *piVar1; + undefined4 *puVar2; + int iVar3; + LONG LVar4; + undefined4 *puVar5; + + if (*(char *)(param_1[0x29] + 0x18) == '\0') { + if ((*(char *)(param_1[0x29] + 0x19) == '\0') && (iVar3 = FUN_00455d00(), iVar3 != 0)) { + FUN_00455830(); + } + iVar3 = param_1[0x3e]; + if ((iVar3 != 0) && (*(int *)(iVar3 + 0x4c) != 0)) { + FUN_00455ad0(iVar3 + 0x48,0); + } + if (((param_1[0x3e] != 0) && (param_1[0x38] == 0)) && (param_1[0x37] == 0)) { + param_1[0x37] = 1; + param_1[0x39] = 1; + } + FUN_00509480(); + FUN_0050a420(); + if (DAT_008ee9c8 != 0) { + FUN_005a7800(); + FUN_005062e0(); + } + FUN_005524a0(); + } + else { + FUN_00455d00(); + } + FUN_0043f7b0(); + if (param_1[0x3a] != 0) { + while( true ) { + piVar1 = (int *)param_1[0x3a]; + puVar2 = (undefined4 *)*piVar1; + if (puVar2 == (undefined4 *)0x0) { + puVar5 = (undefined4 *)0x0; + } + else { + iVar3 = puVar2[1]; + *piVar1 = iVar3; + if (iVar3 == 0) { + piVar1[1] = 0; + } + puVar5 = (undefined4 *)*puVar2; + operator_delete(puVar2); + } + if (puVar5 == (undefined4 *)0x0) break; + iVar3 = (**(code **)(*param_1 + 4))(puVar5); + if (iVar3 == 0) { + FUN_00453a20(puVar5); + } + else { + (**(code **)(*param_1 + 8))(puVar5); + } + LVar4 = InterlockedDecrement(puVar5 + 1); + if (LVar4 == 0) { + (**(code **)*puVar5)(1); + } + } + } + if (param_1[1] == 0) { + (**(code **)(*(int *)param_1[0x2e] + 0xa8))(); + } + FUN_0054d700(); + return; +} + + + +// --- FUN_00455610 at 0x00455610 (size: 16) --- + +void __fastcall FUN_00455610(int param_1) + +{ + if (*(int *)(param_1 + 0xd8) == 0) { + FUN_00454cc0(); + return; + } + return; +} + + + +// --- FUN_00455620 at 0x00455620 (size: 35) --- + +void FUN_00455620(undefined4 param_1,undefined4 param_2,undefined4 param_3,undefined4 param_4, + undefined4 param_5) + +{ + FUN_00454d20(param_1,param_2,param_3,param_4,param_5,1); + return; +} + + + +// --- FUN_00455650 at 0x00455650 (size: 192) --- + +void __thiscall FUN_00455650(int param_1,undefined4 param_2,undefined4 param_3) + +{ + char cVar1; + undefined4 *puVar2; + uint uVar3; + undefined4 uVar4; + undefined4 local_c; + undefined4 local_8; + undefined4 local_4; + + puVar2 = (undefined4 *)FUN_005df0f5(0x68); + if (puVar2 == (undefined4 *)0x0) { + puVar2 = (undefined4 *)0x0; + } + else { + puVar2[1] = 0x3f800000; + puVar2[2] = 0; + puVar2[3] = 0; + puVar2[4] = 0; + puVar2[0xe] = 0; + puVar2[0xf] = 0; + puVar2[0x10] = 0; + FUN_00535b30(); + } + *puVar2 = param_2; + local_c = 0x3f800000; + local_8 = 0x3f800000; + local_4 = 0x3f800000; + FUN_00452740(&local_c); + puVar2[0x17] = param_3; + FUN_00451a60(0xffffffff); + puVar2[0x18] = 0x7f7fffff; + puVar2[0x19] = 0x43b40000; + uVar3 = *(uint *)(param_1 + 0x10) & 0x7fffffff; + if (uVar3 <= *(uint *)(param_1 + 0x14)) { + uVar4 = FUN_00453850(uVar3 + 1); + cVar1 = FUN_004180a0(uVar4); + if (cVar1 == '\0') { + return; + } + } + *(undefined4 **)(*(int *)(param_1 + 0xc) + *(int *)(param_1 + 0x14) * 4) = puVar2; + *(int *)(param_1 + 0x14) = *(int *)(param_1 + 0x14) + 1; + return; +} + + + +// --- FUN_00455710 at 0x00455710 (size: 91) --- + +undefined4 * FUN_00455710(undefined4 param_1,undefined4 param_2) + +{ + char cVar1; + + DAT_0083da58 = (undefined4 *)FUN_0054bbf0(param_1); + if (DAT_0083da58 != (undefined4 *)0x0) { + DAT_0083da58[1] = param_2; + cVar1 = FUN_00455290(param_1); + if (cVar1 != '\0') { + FUN_0054fc10(&LAB_004530b0); + return DAT_0083da58; + } + if (DAT_0083da58 != (undefined4 *)0x0) { + (**(code **)*DAT_0083da58)(1); + } + } + DAT_0083da58 = (undefined4 *)0x0; + return (undefined4 *)0x0; +} + + + +// --- FUN_00455770 at 0x00455770 (size: 113) --- + +uint __thiscall FUN_00455770(int *param_1,int *param_2) + +{ + int iVar1; + uint uVar2; + undefined4 uVar3; + int *piVar4; + + uVar2 = 0; + if (param_1[2] != 0) { + piVar4 = (int *)*param_1; + do { + if (*piVar4 == *param_2) { + if (uVar2 != 0xffffffff) goto LAB_004557be; + break; + } + uVar2 = uVar2 + 1; + piVar4 = piVar4 + 1; + } while (uVar2 < (uint)param_1[2]); + } + if ((param_1[1] & 0x7fffffffU) <= (uint)param_1[2]) { + uVar3 = FUN_00453850((param_1[1] & 0x7fffffffU) + 1); + uVar2 = FUN_004180a0(uVar3); + if ((char)uVar2 == '\0') { +LAB_004557be: + return uVar2 & 0xffffff00; + } + } + *(int *)(*param_1 + param_1[2] * 4) = *param_2; + iVar1 = param_1[2]; + param_1[2] = iVar1 + 1; + return CONCAT31((int3)((uint)(iVar1 + 1) >> 8),1); +} + + + +// --- FUN_004557f0 at 0x004557F0 (size: 62) --- + +undefined4 __thiscall FUN_004557f0(int param_1,int param_2) + +{ + char cVar1; + + if (param_2 != 0) { + cVar1 = FUN_00455770(¶m_2); + if (cVar1 != '\0') { + FUN_005154e0(*(undefined4 *)(param_1 + 0x18)); + FUN_00511e50(0,1); + return 1; + } + } + return 0; +} + + + +// --- FUN_00455830 at 0x00455830 (size: 32) --- + +void __fastcall FUN_00455830(int param_1) + +{ + uint uVar1; + + uVar1 = *(uint *)(param_1 + 0x2c); + if ((uVar1 != 0) && ((uVar1 & 0xffff) < 0x100)) { + FUN_00507730(uVar1); + } + return; +} + + + +// --- FUN_00455850 at 0x00455850 (size: 55) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +float10 FUN_00455850(void) + +{ + return SQRT((float10)DAT_00842950 * (float10)DAT_00842950 + + (float10)DAT_00842954 * (float10)DAT_00842954 + + (float10)DAT_00842958 * (float10)DAT_00842958) * (float10)_DAT_0079a1e8 + + (float10)DAT_00842780; +} + + + +// --- FUN_00455890 at 0x00455890 (size: 63) --- + +void __fastcall FUN_00455890(int param_1) + +{ + int iVar1; + uint uVar2; + + if (*(int *)(param_1 + 0x4c) != 0) { + uVar2 = 0; + do { + iVar1 = *(int *)(*(int *)(*(int *)(param_1 + 0x50) + uVar2 * 4) + 0xc); + if ((*(int **)(iVar1 + 0x14) != (int *)0x0) && (*(int *)(iVar1 + 0x18) == 0)) { + (**(code **)(**(int **)(iVar1 + 0x14) + 0x14))(); + *(undefined4 *)(iVar1 + 0x14) = 0; + } + uVar2 = uVar2 + 1; + } while (uVar2 < *(uint *)(param_1 + 0x4c)); + } + return; +} + + + +// --- FUN_004558d0 at 0x004558D0 (size: 83) --- + +undefined4 * __fastcall FUN_004558d0(undefined4 *param_1) + +{ + *param_1 = 0; + param_1[2] = 0; + param_1[4] = 0; + param_1[5] = 0; + *(undefined1 *)(param_1 + 6) = 0; + *(undefined1 *)((int)param_1 + 0x19) = 1; + param_1[7] = 0; + param_1[8] = 0; + param_1[9] = 0; + param_1[10] = &PTR_LAB_00797910; + param_1[0xb] = 0; + param_1[0xc] = 0x3f800000; + param_1[0xd] = 0; + param_1[0xe] = 0; + param_1[0xf] = 0; + param_1[0x19] = 0; + param_1[0x1a] = 0; + param_1[0x1b] = 0; + FUN_00535b30(); + param_1[0x1c] = 0; + return param_1; +} + + + +// --- FUN_00455930 at 0x00455930 (size: 8) --- + +void __fastcall FUN_00455930(int param_1) + +{ + *(undefined ***)(param_1 + 0x28) = &PTR_FUN_0079385c; + return; +} + + + +// --- FUN_00455940 at 0x00455940 (size: 266) --- + +undefined1 __thiscall FUN_00455940(uint param_1,uint param_2,int param_3) + +{ + char cVar1; + int iVar2; + uint uVar3; + uint uStack_4; + + uStack_4 = param_1; + cVar1 = (**(code **)(*DAT_00837bac + 0x3c))(); + if (cVar1 != '\0') { + return 1; + } + uStack_4 = 0; + if ((param_2 & 0xffff) < 0x100) { + if (((param_3 != 0) || (*(char *)(param_1 + 0x19) == '\0')) || + (((*(uint *)(param_1 + 8) ^ param_2) & 0xffff0000) != 0)) { + iVar2 = FUN_005060c0(param_2 | 0xffff,&uStack_4); + goto LAB_004559af; + } + *(undefined1 *)(param_1 + 0x19) = 1; + } + else { + iVar2 = FUN_0052de40(param_2,&uStack_4); +LAB_004559af: + if (iVar2 == 0) { + *(undefined1 *)(param_1 + 0x19) = 0; + } + else { + *(undefined1 *)(param_1 + 0x19) = 1; + } + } + *(uint *)(param_1 + 8) = param_2; + if (param_3 == 0) { + if (*(char *)(param_1 + 0x19) == '\0') goto LAB_00455a3e; + } + else { + if (uStack_4 != 0) { + if (*(uint *)(param_1 + 0x20) == 0) { + *(uint *)(param_1 + 0x20) = uStack_4; + iVar2 = 0; + uVar3 = uStack_4; + } + else { + if (*(uint *)(param_1 + 0x20) < uStack_4) { + *(uint *)(param_1 + 0x20) = uStack_4; + } + uVar3 = *(uint *)(param_1 + 0x20); + iVar2 = uVar3 - uStack_4; + *(int *)(param_1 + 0x1c) = iVar2; + } + FUN_006937c0(1,iVar2,uVar3); + } + if (*(char *)(param_1 + 0x19) == '\0') { + if (*(char *)(param_1 + 0x18) == '\0') { + *(undefined1 *)(param_1 + 0x18) = 1; + return *(undefined1 *)(param_1 + 0x19); + } + goto LAB_00455a3e; + } + } + if (*(char *)(param_1 + 0x18) != '\0') { + *(undefined1 *)(param_1 + 0x18) = 0; + FUN_006937c0(0,0,0); + *(undefined4 *)(param_1 + 0x1c) = 0; + *(undefined4 *)(param_1 + 0x20) = 0; + } +LAB_00455a3e: + return *(undefined1 *)(param_1 + 0x19); +} + + + +// --- FUN_00455a50 at 0x00455A50 (size: 122) --- + +void __fastcall FUN_00455a50(int param_1) + +{ + bool bVar1; + + bVar1 = (*(uint *)(param_1 + 0x2c) & 0xffff) < 0x100; + if (*(int **)(param_1 + 0x24) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x24) + 0x74))(); + (**(code **)(**(int **)(param_1 + 0x24) + 0x14))(); + bVar1 = *(int *)(*(int *)(param_1 + 0x24) + 0xe8) != 0 || bVar1; + *(undefined4 *)(param_1 + 0x24) = 0; + FUN_0052eb50(); + } + if (bVar1) { + FUN_005055c0(); + } + FUN_00452960(); + *(undefined4 *)(param_1 + 0x2c) = 0; + if (*(char *)(param_1 + 0x18) != '\0') { + *(undefined1 *)(param_1 + 0x18) = 0; + FUN_006937c0(0,0,0); + *(undefined4 *)(param_1 + 0x1c) = 0; + *(undefined4 *)(param_1 + 0x20) = 0; + } + *(undefined1 *)(param_1 + 0x19) = 1; + return; +} + + + +// --- FUN_00455ad0 at 0x00455AD0 (size: 16) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __thiscall FUN_00455ad0(int param_1,int param_2,int param_3) + +{ + int iVar1; + undefined4 uVar2; + undefined4 uVar3; + int *piVar4; + int iVar5; + bool bVar6; + float10 fVar7; + float fVar8; + undefined4 uVar9; + + iVar1 = *(int *)(param_2 + 4); + if (iVar1 == 0) { + FUN_00455a50(); + return; + } + iVar5 = 1; + if (*(char *)(param_1 + 0x18) == '\0') { + iVar5 = param_3; + } + if ((*(int *)(param_1 + 0x2c) == iVar1) && (*(int *)(param_1 + 0x24) != 0)) goto LAB_00455c55; + FUN_00455940(iVar1,iVar5); + if (*(int **)(param_1 + 0x24) != (int *)0x0) { + (**(code **)(**(int **)(param_1 + 0x24) + 0x74))(); + (**(code **)(**(int **)(param_1 + 0x24) + 0x14))(); + *(undefined4 *)(param_1 + 0x24) = 0; + } + bVar6 = (*(uint *)(param_2 + 4) & 0xffff) < 0x100; + if (iVar5 == 0) { + if (bVar6) { + FUN_00507730(*(uint *)(param_2 + 4)); + } + piVar4 = (int *)FUN_0052bd90(*(undefined4 *)(param_2 + 4)); + if (piVar4 != (int *)0x0) { + if (!bVar6) { + if ((piVar4[0x3a] == 0) && (*(int *)(param_1 + 0x70) == 0)) { + FUN_005055c0(); + (**(code **)(*piVar4 + 0x70))(); + *(int **)(param_1 + 0x24) = piVar4; + goto LAB_00455bb3; + } + uVar9 = FUN_004527f0(); + FUN_00507730(uVar9); + } + (**(code **)(*piVar4 + 0x70))(); + *(int **)(param_1 + 0x24) = piVar4; + } + } + else { + FUN_005055c0(); + } +LAB_00455bb3: + if (*(int *)(param_1 + 0x24) != 0) { + _DAT_0081ecc8 = _DAT_0081ecc8 + 1; + DAT_008683b4 = 0; + DAT_0086b838 = 0; + DAT_0081ff5c = *(undefined4 *)(*(int *)(param_1 + 0x24) + 0x58); + FUN_00425f10(*(int *)(param_1 + 0x24) + 0x5c); + } + FUN_0052eb50(); + uVar3 = DAT_00842958; + uVar2 = DAT_00842954; + uVar9 = DAT_00842950; + if (*(int *)(param_1 + 0x24) == 0) goto LAB_00455c55; + if ((bVar6) || (*(int *)(*(int *)(param_1 + 0x24) + 0xe8) != 0)) { + _DAT_008682c8 = DAT_00842950; + _DAT_008682d0 = DAT_00842958; + bVar6 = true; + _DAT_008682cc = DAT_00842954; + FUN_00451a60(DAT_00842778); + _DAT_008682bc = uVar9; + _DAT_008682c0 = uVar2; + _DAT_008682c4 = uVar3; + DAT_008682d4 = 0; + if (DAT_0083da58 != 0) { + uVar9 = DAT_0084277c; + fVar7 = (float10)FUN_00455850(DAT_0084277c); + fVar8 = (float)fVar7; + goto LAB_00455c14; + } + } + else { + bVar6 = false; + if (DAT_0083da58 != 0) { + uVar9 = 0xffffffff; + fVar8 = DAT_0079c7fc; +LAB_00455c14: + FUN_004530e0(fVar8,uVar9); + } + } + FUN_005521f0(param_2); + FUN_00695670(*(undefined4 *)(param_1 + 4)); + if (bVar6) { + FUN_00506270(*(undefined4 *)(param_1 + 4)); + } + FUN_00552670(); + FUN_00455890(); +LAB_00455c55: + *(undefined4 *)(param_1 + 0x2c) = *(undefined4 *)(param_2 + 4); + FUN_00425f10(param_2 + 8); + return; +} + + + +// --- FUN_00455ae0 at 0x00455AE0 (size: 539) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +void __thiscall FUN_00455ae0(int param_1) + +{ + int *piVar1; + undefined4 uVar2; + undefined4 uVar3; + int in_EAX; + int *piVar4; + char cVar5; + int *unaff_EBX; + int unaff_EBP; + bool in_ZF; + float10 fVar6; + int in_stack_00000018; + int *in_stack_0000001c; + float fVar7; + undefined4 uVar8; + + if (in_ZF) { + FUN_00455a50(); + return; + } + cVar5 = (char)unaff_EBX; + piVar4 = (int *)0x1; + if (*(char *)(param_1 + 0x18) == cVar5) { + piVar4 = in_stack_0000001c; + } + if ((*(int *)(param_1 + 0x2c) == in_EAX) && (*(int **)(param_1 + 0x24) != unaff_EBX)) + goto LAB_00455c55; + FUN_00455940(in_EAX,piVar4); + if (*(int **)(param_1 + 0x24) != unaff_EBX) { + (**(code **)(**(int **)(param_1 + 0x24) + 0x74))(); + (**(code **)(**(int **)(param_1 + 0x24) + 0x14))(); + *(int **)(param_1 + 0x24) = unaff_EBX; + } + piVar1 = (int *)(uint)((*(uint *)(unaff_EBP + 4) & 0xffff) < 0x100); + if (piVar4 == unaff_EBX) { + if (piVar1 != unaff_EBX) { + FUN_00507730(*(uint *)(unaff_EBP + 4)); + } + piVar4 = (int *)FUN_0052bd90(*(undefined4 *)(in_stack_00000018 + 4)); + if (piVar4 != unaff_EBX) { + if (piVar1 == unaff_EBX) { + if (((int *)piVar4[0x3a] == unaff_EBX) && (*(int **)(param_1 + 0x70) == unaff_EBX)) { + FUN_005055c0(); + (**(code **)(*piVar4 + 0x70))(); + *(int **)(param_1 + 0x24) = piVar4; + goto LAB_00455bb3; + } + uVar8 = FUN_004527f0(); + FUN_00507730(uVar8); + } + (**(code **)(*piVar4 + 0x70))(); + *(int **)(param_1 + 0x24) = piVar4; + } + } + else { + FUN_005055c0(); + } +LAB_00455bb3: + if (*(int **)(param_1 + 0x24) != unaff_EBX) { + _DAT_0081ecc8 = _DAT_0081ecc8 + 1; + DAT_0081ff5c = *(undefined4 *)(*(int *)(param_1 + 0x24) + 0x58); + DAT_008683b4 = unaff_EBX; + DAT_0086b838 = unaff_EBX; + FUN_00425f10(*(int *)(param_1 + 0x24) + 0x5c); + } + FUN_0052eb50(); + uVar3 = DAT_00842958; + uVar2 = DAT_00842954; + uVar8 = DAT_00842950; + unaff_EBP = in_stack_00000018; + if (*(int **)(param_1 + 0x24) == unaff_EBX) goto LAB_00455c55; + if ((piVar1 == unaff_EBX) && ((int *)(*(int **)(param_1 + 0x24))[0x3a] == unaff_EBX)) { + piVar4 = (int *)0x0; + if (DAT_0083da58 != unaff_EBX) { + uVar8 = 0xffffffff; + fVar7 = DAT_0079c7fc; +LAB_00455c14: + FUN_004530e0(fVar7,uVar8); + } + } + else { + _DAT_008682c8 = DAT_00842950; + _DAT_008682d0 = DAT_00842958; + piVar4 = (int *)0x1; + _DAT_008682cc = DAT_00842954; + FUN_00451a60(DAT_00842778); + _DAT_008682bc = uVar8; + _DAT_008682c0 = uVar2; + _DAT_008682c4 = uVar3; + DAT_008682d4 = cVar5; + if (DAT_0083da58 != unaff_EBX) { + uVar8 = DAT_0084277c; + fVar6 = (float10)FUN_00455850(DAT_0084277c); + fVar7 = (float)fVar6; + goto LAB_00455c14; + } + } + FUN_005521f0(in_stack_00000018); + FUN_00695670(*(undefined4 *)(param_1 + 4)); + if (piVar4 != unaff_EBX) { + FUN_00506270(*(undefined4 *)(param_1 + 4)); + } + FUN_00552670(); + FUN_00455890(); +LAB_00455c55: + *(undefined4 *)(param_1 + 0x2c) = *(undefined4 *)(unaff_EBP + 4); + FUN_00425f10(unaff_EBP + 8); + return; +} + + + +// --- FUN_00455d00 at 0x00455D00 (size: 73) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +bool __fastcall FUN_00455d00(int param_1) + +{ + undefined4 uVar1; + int iVar2; + + if (_DAT_0079a1b0 < (double)CONCAT44(DAT_008379ac,DAT_008379a8) - *(double *)(param_1 + 0x10)) { + iVar2 = FUN_00455940(*(undefined4 *)(param_1 + 0x2c),*(undefined1 *)(param_1 + 0x18)); + uVar1 = DAT_008379ac; + *(undefined4 *)(param_1 + 0x10) = DAT_008379a8; + *(undefined4 *)(param_1 + 0x14) = uVar1; + return iVar2 != 0; + } + return false; +} + + + +// --- FUN_00455d50 at 0x00455D50 (size: 309) --- + +/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */ + +undefined4 FUN_00455d50(int param_1,int param_2,undefined4 *param_3,undefined4 *param_4) + +{ + float fVar1; + int iVar2; + uint uVar3; + + if (param_1 < 2) { + *param_4 = + "Usage:\n@render