implement agent_release

.gitignore

@@ -1,3 +1,12 @@
 # Original files
 binaries
 schema
+
+# Ghidra
+ghidra
+
+# Licence-restricted vendor material, local reference only (see third-party/README.md)
+third-party/_local/
+
+# Meson build output
+src/build/

AGENTS.md

@@ -8,6 +8,26 @@ driven through **REA** (`reverse-engineer-anything` skill + `rea-agents` MCP
 server). There is no application source code here — the binaries are the
 primary evidence.
 
+The server binaries are **C++** (MSVC 2010, x64). See
+[`docs/ARCHITECTURE.md`](docs/ARCHITECTURE.md) for the evidence and what is known
+about their structure.
+
+## Target runtime environment
+
+The analyzed binaries are expected to run in the following environment. Use
+this when interpreting imports, API usage, and database access in decompiled
+code.
+
+- **OS**: Windows Server — exact version unknown; assume **2008 or 2012**.
+- **Runtime dependencies** (winetricks-style identifiers):
+  - `dotnet7` — .NET 7 runtime
+  - `dotnetdesktop7` — .NET 7 Desktop runtime
+  - `vcrun2010` — Visual C++ 2010 redistributable
+  - `d3dx9` — DirectX 9 D3DX libraries
+  - `d3dx10` — DirectX 10 D3DX libraries
+- **Database**: Microsoft SQL Server, supported up to **SQL Server 2019**.
+  Schema files for the backing databases are in `schema/`.
+
 ## Directory layout
 
 | Path | Contents | Mutability |
@@ -16,6 +36,18 @@ primary evidence.
 | `schema/` | SQL Server database schema/log files (`.mdf` / `.ldf`) for `RustyHearts`, `RustyHearts_Account`, `RustyHearts_Auth`, `RustyHearts_Log`, `GMRustyHearts` | **Read-only.** Never modify. Gitignored. |
 | `decomp/` | Raw decompilation objects exported from Ghidra/REA (pseudocode, listings, function metadata) | Derived output. Regenerable; created on demand. |
 | `.agents/skills/` | Installed agent skills, notably `reverse-engineer-anything` (REA) | Agent configuration. |
+| `src/` | Linux C++ reconstructions of analysed binaries (Meson; one sub-folder per binary, e.g. `agent_release/`). Build: `cd src && meson setup build && ninja -C build` | Hand-written; cite decomp addresses; `src/build/` is gitignored. |
+| `docs/` | Project documentation, e.g. `ARCHITECTURE.md` (language/toolchain, libraries, code conventions) | Hand-maintained; update as findings are confirmed. |
+| `third-party/` | Upstream sources/headers matched to the shipped support DLLs (OpenSSL 1.0.0d, curl 7.21.4, BugTrap ~1.3, mingw-w64 `dbghelp.h`, TinyXML 2.5.x) | Reference only, not build inputs. Do not edit upstream files; record provenance changes in the doc below. |
+
+**Third-party libraries:** see [`third-party/README.md`](third-party/README.md)
+for each support DLL's observed version, matched source and checksums, match
+quality (exact vs. closest), libraries with no public source, and acquisition
+routes. Consult it before decompiling any support DLL, and use the matched
+headers for symbol/struct recovery instead of re-deriving known APIs.
+The servers also statically link **ProudNet** (Nettention, proprietary). Its
+headers live only in gitignored `third-party/_local/`; never commit them or any
+other licence-restricted vendor files.
 
 ## Tooling
 
@@ -39,7 +71,10 @@ primary evidence.
 3. Export raw decompilation artifacts (pseudocode, listings) into `decomp/`
    using per-binary subdirectories, e.g. `decomp/GameServer_Release_USA_x64/`.
    Keep filenames stable and function-address-based so results are reproducible.
-4. Close the REA session (`close_binary`) when the investigation is complete.
+4. Track targets, artifact SHA-256 identities, and per-binary status in
+   `decomp/INVENTORY.md`; keep a per-binary finding ledger in
+   `decomp/<name>/evidence.md`.
+5. Close the REA session (`close_binary`) when the investigation is complete.
 
 ## Evidence and claims
 
@@ -59,6 +94,13 @@ primary evidence.
 - Do not install Ghidra, Java, Node, or REA prerequisites ad hoc — they are
   provisioned via `mise.toml` and `/opt/ghidra`; repair configuration instead.
 - Version-pin REA at `rea-agents@6.5.0` as declared in `opencode.json`.
+- Do not add npm `devEngines`/`packageManager` constraints to `package.json` —
+  they make `npx` exit `EBADDEVENGINES` in this directory and break the REA MCP
+  launch (this happened once; `devEngines` was removed).
+- Keep the REA registration **project-local**: `opencode.json` in this repo is
+  the source of truth. Do not write global client config
+  (`~/.config/opencode/…`) or run `rea setup` against global paths —
+  `rea doctor` may report global registration drift; that is accepted here.
 - When tooling is missing or an MCP call is blocked, diagnose the specific
   blocker (registration vs. restart vs. provider) rather than re-running setup
   wholesale — see the REA skill's connection-and-recovery reference.

decomp/Agent_Release_x64/0x1400037a0.pseudo.c

@@ -0,0 +1,385 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 pseudocode via REA, ev_2fa3bc1da1e9e82a4bd2859ca38ee1636f1ade7ba45372348ff4288d16c2f449
+ * Decompiler output, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
+
+undefined8 FUN_1400037a0(longlong param_1,undefined8 **param_2,undefined8 *param_3,uint *param_4)
+
+{
+  int *piVar1;
+  double dVar2;
+  char cVar3;
+  undefined8 *puVar4;
+  undefined1 auVar5 [16];
+  bool bVar6;
+  bool bVar7;
+  longlong *plVar8;
+  BOOL BVar9;
+  wchar_t *pwVar10;
+  wchar_t *pwVar11;
+  ulonglong uVar12;
+  longlong *plVar13;
+  wchar_t *pwVar14;
+  char *pcVar15;
+  ulonglong *puVar16;
+  longlong *plVar17;
+  undefined2 *puVar18;
+  wchar_t *pwVar19;
+  longlong lVar20;
+  undefined4 uVar21;
+  undefined4 uVar22;
+  undefined4 uVar23;
+  undefined4 uVar24;
+  undefined4 uVar25;
+  undefined1 auStack_2a8 [32];
+  longlong *local_288;
+  wchar_t *local_280;
+  LARGE_INTEGER local_278;
+  undefined8 *local_270;
+  wchar_t *local_268;
+  wchar_t *local_260;
+  int *local_258;
+  undefined1 local_250;
+  undefined8 local_248;
+  undefined2 local_238;
+  undefined1 local_236 [158];
+  undefined1 local_198 [160];
+  undefined8 *local_f8;
+  undefined2 local_f0;
+  undefined6 uStack_ee;
+  undefined8 local_e0;
+  ulonglong local_d8;
+  undefined2 local_c8;
+  undefined6 uStack_c6;
+  undefined8 local_b8;
+  ulonglong local_b0;
+  ulonglong local_98;
+  
+  local_248 = 0xfffffffffffffffe;
+  local_98 = DAT_1401555a0 ^ (ulonglong)auStack_2a8;
+  FUN_140010960(L"# Agent Startup #\n\n",param_2,param_3,param_4);
+  CoInitialize((LPVOID)0x0);
+  FUN_140010aa0(L"+ Prepare Startup\n",param_2,param_3,param_4);
+  local_278 = (LARGE_INTEGER)operator_new(0xb8);
+  pwVar19 = (wchar_t *)0x0;
+  pwVar10 = pwVar19;
+  if ((undefined8 *)local_278.QuadPart != (undefined8 *)0x0) {
+    pwVar10 = (wchar_t *)FUN_140005020((undefined8 *)local_278,param_2,param_3,param_4);
+  }
+  if (pwVar10 == (wchar_t *)0x0) {
+    local_288 = (longlong *)0x0;
+  }
+  else {
+    local_288 = (longlong *)FUN_140030280(0x10);
+    local_288[1] = 1;
+    *local_288 = (longlong)pwVar10;
+  }
+  plVar17 = local_288;
+  pwVar11 = operator_new(0x68);
+  pwVar10 = pwVar19;
+  local_280 = pwVar11;
+  if (pwVar11 != (wchar_t *)0x0) {
+    if (plVar17 != (longlong *)0x0) {
+      pwVar10 = (wchar_t *)*plVar17;
+    }
+    *(wchar_t **)pwVar11 = pwVar10;
+    pwVar11[4] = L'\0';
+    pwVar11[5] = L'\0';
+    pwVar11[6] = L'\0';
+    pwVar11[7] = L'\0';
+    pwVar11[8] = L'\0';
+    pwVar11[9] = L'\0';
+    pwVar11[10] = L'\0';
+    pwVar11[0xb] = L'\0';
+    pwVar11[0xc] = L'\0';
+    pwVar11[0xd] = L'\0';
+    pwVar11[0xe] = L'\0';
+    pwVar11[0xf] = L'\0';
+    uVar12 = FUN_14002e790();
+    param_2 = (undefined8 **)(uVar12 & 0xffffffff);
+    param_3 = (undefined8 *)CONCAT71((int7)((ulonglong)param_3 >> 8),1);
+    FUN_14002e600((undefined4 *)(pwVar11 + 0x14),(ulonglong)param_2,param_3,param_4);
+    FUN_140007960((longlong)pwVar11);
+    pwVar10 = pwVar11;
+  }
+  if (pwVar10 == (wchar_t *)0x0) {
+    local_280 = (wchar_t *)0x0;
+  }
+  else {
+    local_280 = (wchar_t *)FUN_140030280(0x10);
+    *(undefined8 *)((longlong)local_280 + 8) = 1;
+    *(wchar_t **)local_280 = pwVar10;
+  }
+  pwVar10 = local_280;
+  pwVar11 = pwVar19;
+  if (plVar17 != (longlong *)0x0) {
+    pwVar11 = (wchar_t *)*plVar17;
+  }
+  *(wchar_t **)(param_1 + 0xa0) = pwVar11;
+  pwVar11 = pwVar19;
+  if (local_280 != (wchar_t *)0x0) {
+    pwVar11 = *(wchar_t **)local_280;
+  }
+  *(wchar_t **)(param_1 + 0xa8) = pwVar11;
+  pwVar11 = pwVar19;
+  if (local_280 != (wchar_t *)0x0) {
+    pwVar11 = *(wchar_t **)local_280;
+  }
+  FUN_140007960((longlong)pwVar11);
+  local_f8 = (undefined8 *)0x0;
+  local_d8 = 7;
+  local_e0 = 0;
+  local_f0 = 0;
+  local_b0 = 7;
+  local_b8 = 0;
+  local_c8 = 0;
+  if (*(longlong *)(DAT_140162d68 + 0x1c8) != 0) {
+    auVar5._8_8_ = 0;
+    auVar5._0_8_ = *(ulonglong *)(DAT_140162d68 + 0x1b0);
+    param_2 = SUB168((ZEXT816(0) << 0x40 | ZEXT816(0x15)) % auVar5,0);
+    local_270 = (undefined8 *)(*(longlong *)(DAT_140162d68 + 0x1a8) + (longlong)param_2 * 8);
+    for (local_268 = (wchar_t *)*local_270; local_268 != (wchar_t *)0x0;
+        local_268 = *(wchar_t **)local_268) {
+      if ((char)local_268[4] == '\x15') {
+        if (local_268 != (wchar_t *)0x0) goto LAB_1400039c4;
+        break;
+      }
+    }
+  }
+  local_270 = (undefined8 *)0x0;
+  local_268 = pwVar19;
+LAB_1400039c4:
+  if ((local_268 != (wchar_t *)0x0) &&
+     (puVar4 = *(undefined8 **)(local_268 + 8), puVar4 != *(undefined8 **)(local_268 + 0xc))) {
+    local_f8 = (undefined8 *)*puVar4;
+    FUN_140001600((longlong *)&local_f0,puVar4 + 1,0,0xffffffffffffffff);
+    param_4 = (uint *)0xffffffffffffffff;
+    param_3 = (undefined8 *)0x0;
+    FUN_140001600((longlong *)&local_c8,puVar4 + 6,0,0xffffffffffffffff);
+    param_2 = &local_f8;
+    FUN_140007a80(*(undefined8 **)(param_1 + 0xa8),param_2,param_3,(undefined8 *)param_4);
+    lVar20 = *(longlong *)(param_1 + 0xa8);
+    piVar1 = (int *)(lVar20 + 0x28);
+    local_258 = piVar1;
+    FUN_14002e6e0(piVar1);
+    plVar13 = *(longlong **)(lVar20 + 8);
+    if (*plVar13 == 0) {
+      FUN_14002e770((longlong)piVar1);
+      local_250 = 0;
+    }
+    else {
+      lVar20 = *plVar13;
+      FUN_14002e770((longlong)piVar1);
+      local_250 = 0;
+      if (lVar20 != 0) {
+        cVar3 = *(char *)(lVar20 + 0x88);
+        while (cVar3 == '\0') {
+          FUN_1400023e0(lVar20);
+          cVar3 = *(char *)(lVar20 + 0x88);
+        }
+      }
+    }
+  }
+  pwVar11 = pwVar19;
+  if (plVar17 != (longlong *)0x0) {
+    pwVar11 = (wchar_t *)*plVar17;
+  }
+  FUN_140005360((longlong)pwVar11,param_2,param_3,(longlong)param_4);
+  pwVar11 = pwVar19;
+  if (plVar17 != (longlong *)0x0) {
+    pwVar11 = (wchar_t *)*plVar17;
+  }
+  *(undefined8 *)(pwVar11 + 0x24) = *(undefined8 *)(param_1 + 0xa8);
+  FUN_140010960(L"\n # Agent Running... #\n",param_2,param_3,param_4);
+  plVar13 = operator_new(0x18);
+  if (plVar13 == (longlong *)0x0) {
+    plVar13 = (longlong *)0x0;
+  }
+  else {
+    *plVar13 = (longlong)TimeSourceHRWin32::vftable;
+    BVar9 = QueryPerformanceFrequency(&local_278);
+    if (BVar9 == 0) {
+      *(undefined1 *)(plVar13 + 2) = 0;
+      GetLastError();
+    }
+    else {
+      *(undefined1 *)(plVar13 + 2) = 1;
+      plVar13[1] = (longlong)(1.0 / (double)local_278.QuadPart);
+    }
+  }
+  plVar8 = DAT_140162d50;
+  if ((undefined8 *)DAT_140162d50[2] != (undefined8 *)0x0) {
+    (*(code *)**(undefined8 **)DAT_140162d50[2])();
+  }
+  plVar8[2] = (longlong)plVar13;
+  if (plVar13 != (longlong *)0x0) {
+    lVar20 = (**(code **)(*plVar13 + 8))(plVar13);
+    plVar8[6] = lVar20;
+    plVar8[7] = lVar20;
+  }
+  plVar8[0x12] = 0x3ff0000000000000;
+  pwVar14 = operator_new(0x28);
+  pwVar11 = pwVar19;
+  local_260 = pwVar14;
+  if (pwVar14 != (wchar_t *)0x0) {
+    *(undefined ***)pwVar14 = Magi::Timer::vftable;
+    plVar13 = DAT_140162d50;
+    *(longlong **)(pwVar14 + 4) = DAT_140162d50;
+    pwVar14[8] = L'\0';
+    pwVar14[9] = L'\0';
+    pwVar14[10] = L'\0';
+    pwVar14[0xb] = L'\0';
+    pwVar14[0xc] = L'\0';
+    pwVar14[0xd] = L'\0';
+    pwVar14[0xe] = L'\0';
+    pwVar14[0xf] = L'\0';
+    *(undefined1 *)(pwVar14 + 0x10) = 0;
+    pwVar14[0x12] = L'\0';
+    pwVar14[0x13] = L'㾀';
+    (**(code **)(*plVar13 + 0x10))();
+    pwVar11 = pwVar14;
+  }
+  *(wchar_t **)(param_1 + 0x50) = pwVar11;
+  bVar6 = true;
+  local_238 = 0;
+  memset(local_236,0,0x9e);
+  puVar16 = (ulonglong *)0x0;
+  puVar18 = (undefined2 *)0xa0;
+  memset(local_198,0,0xa0);
+  uVar21 = 0;
+  uVar23 = 0;
+  FUN_1400271e0(DAT_140162d68);
+  pcVar15 = *(char **)(DAT_140162d58 + 8);
+  do {
+    pwVar11 = pwVar19;
+    if (pcVar15 == *(char **)(DAT_140162d58 + 0x10)) {
+LAB_140003c4a:
+      FUN_140009780(pwVar11);
+      FUN_140001dc0(param_1 + 8);
+      bVar7 = false;
+      cVar3 = *(char *)(param_1 + 0x60);
+      uVar24 = uVar21;
+      uVar25 = uVar23;
+      while (cVar3 != '\0') {
+        FUN_1400dc520((longlong)DAT_140162d50);
+        dVar2 = *(double *)(*(longlong *)(param_1 + 0x50) + 0x10);
+        if (((0.0 < *(double *)(DAT_140162d68 + 0x178)) &&
+            (0.0 < dVar2 - *(double *)(DAT_140162d68 + 0x178))) && (bVar6)) {
+          bVar6 = false;
+          pcVar15 = "Start Auto Server On. \n";
+          printf("Start Auto Server On. \n");
+          FUN_140009bd0(pcVar15,puVar16,puVar18,param_4);
+        }
+        FUN_140007da0(*(longlong *)(param_1 + 0xa8),dVar2);
+        uVar22 = (undefined4)((ulonglong)dVar2 >> 0x20);
+        if (1.0 <= dVar2 - (double)CONCAT44(uVar23,uVar21)) {
+          if (DAT_140162cc4 != 0) {
+            puVar16 = (ulonglong *)&DAT_14011b7b4;
+            if (bVar7) {
+              puVar16 = (ulonglong *)&DAT_14011b7b0;
+            }
+            puVar18 = (undefined2 *)(ulonglong)DAT_140162cc8;
+            printf("[ %s ] FPS[ %d ]\n");
+            bVar7 = !bVar7;
+          }
+          _DAT_140162ccc = DAT_140162cc8;
+          DAT_140162cc8 = 0;
+          uVar21 = SUB84(dVar2,0);
+          uVar23 = uVar22;
+        }
+        if (0.10000000149011612 <= dVar2 - (double)CONCAT44(uVar25,uVar24)) {
+          DAT_140162cc8 = DAT_140162cc8 + 1;
+          FUN_140003f30(param_1,puVar16,puVar18,param_4);
+          pwVar11 = pwVar19;
+          if (plVar17 != (longlong *)0x0) {
+            pwVar11 = (wchar_t *)*plVar17;
+          }
+          FUN_1400053e0((longlong)pwVar11,dVar2);
+          uVar24 = SUB84(dVar2,0);
+          uVar25 = uVar22;
+        }
+        *(double *)(param_1 + 0x58) = dVar2;
+        Sleep(1);
+        cVar3 = *(char *)(param_1 + 0x60);
+      }
+      FUN_140010aa0(L"+ Prepare Stop\n",puVar16,puVar18,param_4);
+      FUN_1400079d0(*(longlong *)(param_1 + 0xa8));
+      lVar20 = *(longlong *)(param_1 + 0xa0);
+      puVar4 = *(undefined8 **)(lVar20 + 0x28);
+      if (puVar4 != (undefined8 *)0x0) {
+        puVar16 = (ulonglong *)0x1;
+        (**(code **)*puVar4)();
+      }
+      *(undefined8 *)(lVar20 + 0x28) = 0;
+      CoUninitialize();
+      FUN_140010960(L"# Agent Stoped... #\n",puVar16,puVar18,param_4);
+      if (7 < local_b0) {
+        operator_delete((void *)CONCAT62(uStack_c6,local_c8));
+      }
+      local_b0 = 7;
+      local_b8 = 0;
+      local_c8 = 0;
+      if (7 < local_d8) {
+        operator_delete((void *)CONCAT62(uStack_ee,local_f0));
+      }
+      pwVar19 = local_280;
+      local_d8 = 7;
+      local_e0 = 0;
+      local_f0 = 0;
+      if (pwVar10 != (wchar_t *)0x0) {
+        plVar13 = (longlong *)((longlong)pwVar10 + 8);
+        *plVar13 = *plVar13 + -1;
+        plVar17 = local_288;
+        if (*plVar13 == 0) {
+          pwVar10 = *(wchar_t **)local_280;
+          local_260 = pwVar10;
+          if (pwVar10 != (wchar_t *)0x0) {
+            FUN_14002e7a0((undefined4 *)(pwVar10 + 0x14),puVar16,puVar18,param_4);
+            if (*(void **)(pwVar10 + 4) != (void *)0x0) {
+              operator_delete(*(void **)(pwVar10 + 4));
+            }
+            pwVar10[4] = L'\0';
+            pwVar10[5] = L'\0';
+            pwVar10[6] = L'\0';
+            pwVar10[7] = L'\0';
+            pwVar10[8] = L'\0';
+            pwVar10[9] = L'\0';
+            pwVar10[10] = L'\0';
+            pwVar10[0xb] = L'\0';
+            pwVar10[0xc] = L'\0';
+            pwVar10[0xd] = L'\0';
+            pwVar10[0xe] = L'\0';
+            pwVar10[0xf] = L'\0';
+            operator_delete(pwVar10);
+          }
+          FUN_1400302f0(pwVar19);
+          plVar17 = local_288;
+        }
+      }
+      plVar13 = local_288;
+      if (plVar17 != (longlong *)0x0) {
+        plVar17 = plVar17 + 1;
+        *plVar17 = *plVar17 + -1;
+        if (*plVar17 == 0) {
+          puVar4 = (undefined8 *)*local_288;
+          if (puVar4 != (undefined8 *)0x0) {
+            (**(code **)*puVar4)(puVar4,1);
+          }
+          FUN_1400302f0(plVar13);
+        }
+      }
+      return 0;
+    }
+    if (*pcVar15 == '\x18') {
+      pwVar11 = (wchar_t *)(pcVar15 + 8);
+      if (7 < *(ulonglong *)(pcVar15 + 0x20)) {
+        pwVar11 = *(wchar_t **)(pcVar15 + 8);
+      }
+      goto LAB_140003c4a;
+    }
+    pcVar15 = pcVar15 + 0x30;
+  } while( true );
+}
+

decomp/Agent_Release_x64/0x140008c90.pseudo.c

@@ -0,0 +1,83 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 pseudocode via REA, ev_ad71d730ad826f5e73d5b5ec119273acf91c525002d977f0d017bc11eb2cfbb4
+ * Decompiler output, not original source. */
+
+undefined8 FUN_140008c90(undefined8 *param_1)
+
+{
+  DWORD DVar1;
+  HANDLE hProcess;
+  undefined4 *puVar2;
+  undefined8 *puVar3;
+  longlong lVar4;
+  longlong lVar5;
+  uint *puVar6;
+  undefined *puVar7;
+  uint *puVar8;
+  uint local_res8 [2];
+  DWORD local_res10 [2];
+  undefined8 *local_res18;
+  undefined8 *local_res20;
+  undefined8 local_118;
+  undefined8 local_110;
+  undefined8 local_108;
+  undefined8 local_100;
+  undefined8 local_f8;
+  undefined8 local_f0 [4];
+  undefined4 local_d0 [44];
+  
+  local_f8 = 0xfffffffffffffffe;
+  hProcess = (HANDLE)*param_1;
+  DVar1 = *(DWORD *)(param_1 + 2);
+  local_res10[0] = DVar1;
+  do {
+    Sleep(10);
+    GetExitCodeProcess(hProcess,local_res10);
+  } while (local_res10[0] == 0x103);
+  puVar2 = (undefined4 *)FUN_14002c9a0(DAT_140162d60,DVar1);
+  if (puVar2 == (undefined4 *)0x0) {
+    wprintf(L"NOT FIND PROCESS ID \n");
+  }
+  else {
+    lVar5 = *(longlong *)(DAT_1401626f8 + 0xa8);
+    if (lVar5 != 0) {
+      puVar2[0x28] = 0;
+      puVar2[0x31] = 0;
+      local_res18 = local_f0;
+      puVar3 = FUN_140006c30((longlong)puVar2,local_f0);
+      local_118 = *(undefined8 *)(puVar2 + 0x2e);
+      local_110 = *(undefined8 *)(puVar2 + 0x30);
+      local_108 = *(undefined8 *)(puVar2 + 0x32);
+      local_100 = *(undefined8 *)(puVar2 + 0x34);
+      local_res8[0] = puVar2[1];
+      local_res20 = puVar3;
+      lVar4 = FUN_140007fa0(lVar5);
+      (**(code **)(*(longlong *)(lVar4 + 0x68) + 0x40))
+                ((longlong *)(lVar4 + 0x68),1,&DAT_1401555d0,local_res8,&local_118,puVar3);
+      if ((void *)*puVar3 != (void *)0x0) {
+        operator_delete((void *)*puVar3);
+      }
+      *puVar3 = 0;
+      puVar3[1] = 0;
+      puVar3[2] = 0;
+      local_res20 = (undefined8 *)CONCAT44(local_res20._4_4_,1);
+      local_res18 = (undefined8 *)CONCAT44(local_res18._4_4_,puVar2[1]);
+      local_res8[0] = CONCAT31(local_res8[0]._1_3_,1);
+      lVar5 = FUN_140007fa0(lVar5);
+      puVar8 = local_res8;
+      puVar7 = &DAT_1401555d0;
+      (**(code **)(*(longlong *)(lVar5 + 0x68) + 0x50))
+                ((longlong *)(lVar5 + 0x68),1,&DAT_1401555d0,puVar8,&local_res20,&local_res18);
+      if ((*(char *)((longlong)puVar2 + 0xd5) != '\0') || (*(char *)(DAT_140162d68 + 0x171) != '\0')
+         ) {
+        puVar6 = FUN_14000b8e0(puVar2,local_d0);
+        FUN_140008ea0(DAT_140162d78,puVar6,puVar7,puVar8);
+        if ((*(char *)(puVar2 + 3) == '\x01') && (0 < (int)puVar2[0x34])) {
+          FUN_140009f20(DAT_140162d78,puVar2[1]);
+        }
+      }
+    }
+  }
+  return 0;
+}
+

decomp/Agent_Release_x64/0x140008ea0.pseudo.c

@@ -0,0 +1,271 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 pseudocode via REA, ev_e87b1dd73483b4679d62c8af5a049a4eba2945ad39d8d854566eb6f8725e1200
+ * Decompiler output, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+/* WARNING: Type propagation algorithm not settling */
+
+void FUN_140008ea0(undefined8 param_1,uint *param_2,undefined8 param_3,uint *param_4)
+
+{
+  char cVar1;
+  wchar_t wVar2;
+  ulonglong uVar3;
+  DWORD DVar4;
+  char *pcVar5;
+  wchar_t *******pppppppwVar6;
+  longlong lVar7;
+  ulonglong uVar8;
+  undefined8 uVar9;
+  char *pcVar10;
+  wchar_t *pwVar11;
+  undefined8 *puVar12;
+  short *psVar13;
+  wchar_t *pwVar14;
+  undefined1 auStack_488 [32];
+  void **local_468;
+  undefined8 *local_460;
+  uint local_458 [2];
+  undefined8 *local_450;
+  undefined1 *local_448;
+  undefined8 local_440;
+  basic_ostream<wchar_t,std::char_traits<wchar_t>_> local_438 [136];
+  basic_ios<wchar_t,std::char_traits<wchar_t>_> local_3b0 [104];
+  uint *local_348;
+  wchar_t *******local_340 [2];
+  wchar_t ******local_330;
+  wchar_t ******local_328;
+  undefined2 local_318;
+  undefined6 uStack_316;
+  undefined8 local_308;
+  ulonglong local_300;
+  ulonglong local_2f0 [2];
+  undefined8 local_2e0;
+  ulonglong local_2d8;
+  void *local_2c8;
+  undefined8 local_2c0;
+  undefined8 local_2b8;
+  ulonglong local_2b0;
+  ulonglong local_2a0 [2];
+  undefined8 local_290;
+  ulonglong local_288;
+  ulonglong local_278 [2];
+  undefined8 local_268;
+  ulonglong local_260;
+  wchar_t local_248;
+  undefined1 local_246 [526];
+  ulonglong local_38;
+  
+  local_440 = 0xfffffffffffffffe;
+  local_38 = DAT_1401555a0 ^ (ulonglong)auStack_488;
+  pwVar11 = (wchar_t *)0x0;
+  DVar4 = 0;
+  pwVar14 = pwVar11;
+  if (*(longlong *)(DAT_140162d60 + 0x58) != 0) {
+    for (puVar12 = *(undefined8 **)
+                    (*(longlong *)(DAT_140162d60 + 0x38) +
+                    ((ulonglong)(longlong)(int)param_2[1] % *(ulonglong *)(DAT_140162d60 + 0x40)) *
+                    8); puVar12 != (undefined8 *)0x0; puVar12 = (undefined8 *)*puVar12) {
+      if (param_2[1] == *(uint *)(puVar12 + 1)) {
+        if (puVar12 != (undefined8 *)0x0) {
+          pwVar14 = (wchar_t *)puVar12[2];
+        }
+        break;
+      }
+    }
+  }
+  local_348 = param_2;
+  if (*(int *)(pwVar14 + 0x62) == 0) {
+    pwVar14[0x62] = L'\x01';
+    pwVar14[99] = L'\0';
+    uVar3 = *(ulonglong *)(DAT_1401626f8 + 0xa8);
+    local_248 = L'\0';
+    memset(local_246,0,0x206);
+    FUN_14000a4b0(local_438);
+    std::basic_ostream<wchar_t,std::char_traits<wchar_t>_>::operator<<(local_438,param_2[1]);
+    FUN_14000a600((longlong)local_438,(void **)&local_318);
+    for (pcVar5 = *(char **)(DAT_140162d58 + 8); pcVar5 != *(char **)(DAT_140162d58 + 0x10);
+        pcVar5 = pcVar5 + 0x30) {
+      if (*pcVar5 == (char)param_2[3]) {
+        pwVar11 = (wchar_t *)(pcVar5 + 8);
+        if (7 < *(ulonglong *)(pcVar5 + 0x20)) {
+          pwVar11 = *(wchar_t **)pwVar11;
+        }
+        break;
+      }
+    }
+    wcscpy_s(&local_248,0x104,pwVar11);
+    wcscat_s(&local_248,0x104,L" ");
+    if (*(char *)(DAT_140162d68 + 0x152) == '\0') {
+      local_2d8 = 0xf;
+      local_2e0 = 0;
+      local_2f0[0]._0_1_ = '\0';
+      local_328 = (wchar_t ******)0x7;
+      local_330 = (wchar_t ******)0x0;
+      local_340[0] = (wchar_t *******)((ulonglong)local_340[0] & 0xffffffffffff0000);
+      FUN_140027540(DAT_140162d68,local_2f0,param_2);
+      pcVar5 = (char *)local_2f0;
+      if (0xf < local_2d8) {
+        pcVar5 = (char *)CONCAT71(local_2f0[0]._1_7_,(char)local_2f0[0]);
+      }
+      local_288 = 0xf;
+      local_290 = 0;
+      local_2a0[0]._0_1_ = '\0';
+      uVar8 = 0xffffffffffffffff;
+      pcVar10 = pcVar5;
+      do {
+        if (uVar8 == 0) break;
+        uVar8 = uVar8 - 1;
+        cVar1 = *pcVar10;
+        pcVar10 = pcVar10 + 1;
+      } while (cVar1 != '\0');
+      FUN_14000b810(local_2a0,pcVar5,~uVar8 - 1);
+      pppppppwVar6 = (wchar_t *******)FUN_1400dc8f0((ulonglong *)&local_2c8,(LPCSTR)local_2a0);
+      if (local_340 != (wchar_t ********)pppppppwVar6) {
+        if ((wchar_t ******)0x7 < local_328) {
+          operator_delete(local_340[0]);
+        }
+        local_328 = (wchar_t ******)0x7;
+        local_330 = (wchar_t ******)0x0;
+        local_340[0] = (wchar_t *******)((ulonglong)local_340[0] & 0xffffffffffff0000);
+        if (pppppppwVar6[3] < (wchar_t ******)0x8) {
+          memmove(local_340,pppppppwVar6,((longlong)pppppppwVar6[2] + 1U) * 2);
+        }
+        else {
+          local_340[0] = (wchar_t *******)*pppppppwVar6;
+          *pppppppwVar6 = (wchar_t ******)0x0;
+        }
+        local_330 = pppppppwVar6[2];
+        local_328 = pppppppwVar6[3];
+        pppppppwVar6[3] = (wchar_t ******)0x7;
+        pppppppwVar6[2] = (wchar_t ******)0x0;
+        *(undefined2 *)pppppppwVar6 = 0;
+      }
+      if (7 < local_2b0) {
+        operator_delete(local_2c8);
+      }
+      local_2b0 = 7;
+      local_2b8 = 0;
+      local_2c8 = (void *)((ulonglong)local_2c8 & 0xffffffffffff0000);
+      if (0xf < local_288) {
+        operator_delete((void *)CONCAT71(local_2a0[0]._1_7_,(CHAR)local_2a0[0]));
+      }
+      pppppppwVar6 = (wchar_t *******)local_340;
+      if ((wchar_t ******)0x7 < local_328) {
+        pppppppwVar6 = local_340[0];
+      }
+      uVar9 = 0x104;
+      wcscat_s(&local_248,0x104,(wchar_t *)pppppppwVar6);
+      if ((wchar_t ******)0x7 < local_328) {
+        operator_delete(local_340[0]);
+      }
+      local_328 = (wchar_t ******)0x7;
+      local_330 = (wchar_t ******)0x0;
+      local_340[0] = (wchar_t *******)((ulonglong)local_340[0] & 0xffffffffffff0000);
+      if (0xf < local_2d8) {
+        operator_delete((void *)CONCAT71(local_2f0[0]._1_7_,(char)local_2f0[0]));
+      }
+      local_2d8 = 0xf;
+      local_2e0 = 0;
+      local_2f0[0]._0_1_ = '\0';
+    }
+    else {
+      pppppppwVar6 = (wchar_t *******)&local_318;
+      if (7 < local_300) {
+        pppppppwVar6 = (wchar_t *******)CONCAT62(uStack_316,local_318);
+      }
+      uVar9 = 0x104;
+      wcscat_s(&local_248,0x104,(wchar_t *)pppppppwVar6);
+    }
+    uVar8 = 0xffffffffffffffff;
+    pwVar11 = &local_248;
+    do {
+      if (uVar8 == 0) break;
+      uVar8 = uVar8 - 1;
+      wVar2 = *pwVar11;
+      pwVar11 = pwVar11 + 1;
+    } while (wVar2 != L'\0');
+    if ((~uVar8 < 0x104) &&
+       (DVar4 = FUN_1400094e0(&local_248,uVar9,pppppppwVar6,param_4), 0 < (int)DVar4)) {
+      *(DWORD *)(pwVar14 + 0x52) = DVar4;
+      pwVar14[0x62] = L'\x01';
+      pwVar14[99] = L'\0';
+      local_448 = (undefined1 *)local_2a0;
+      puVar12 = FUN_140006c30((longlong)pwVar14,local_2a0);
+      local_2c8 = *(void **)(pwVar14 + 0x5c);
+      local_2c0 = *(undefined8 *)(pwVar14 + 0x60);
+      local_2b8 = *(undefined8 *)(pwVar14 + 100);
+      local_2b0 = *(ulonglong *)(pwVar14 + 0x68);
+      local_458[0] = *(uint *)(pwVar14 + 2);
+      local_450 = puVar12;
+      lVar7 = FUN_140007fa0(uVar3);
+      local_468 = &local_2c8;
+      param_4 = local_458;
+      local_460 = puVar12;
+      (**(code **)(*(longlong *)(lVar7 + 0x68) + 0x40))((longlong *)(lVar7 + 0x68),1,&DAT_1401555d0)
+      ;
+      if ((void *)*puVar12 != (void *)0x0) {
+        operator_delete((void *)*puVar12);
+      }
+      *puVar12 = 0;
+      puVar12[1] = 0;
+      puVar12[2] = 0;
+    }
+    else {
+      pwVar14[0x62] = L'\0';
+      pwVar14[99] = L'\0';
+    }
+    if (uVar3 == 0) {
+      if (7 < local_300) {
+        operator_delete((void *)CONCAT62(uStack_316,local_318));
+      }
+      local_300 = 7;
+      local_308 = 0;
+      local_318 = 0;
+      FUN_14000a550((longlong)local_3b0);
+      std::basic_ios<wchar_t,std::char_traits<wchar_t>_>::
+      ~basic_ios<wchar_t,std::char_traits<wchar_t>_>(local_3b0);
+    }
+    else if ((int)DVar4 < 1) {
+      puVar12 = (undefined8 *)(DAT_140162d68 + 0x30);
+      if (7 < *(ulonglong *)(DAT_140162d68 + 0x48)) {
+        puVar12 = (undefined8 *)*puVar12;
+      }
+      FUN_1400dc9d0(local_278,L"FAILED SERVER ON %s ",puVar12,param_4);
+      psVar13 = (short *)local_278;
+      if (7 < local_260) {
+        psVar13 = (short *)CONCAT62(local_278[0]._2_6_,(short)local_278[0]);
+      }
+      FUN_1400080a0(uVar3,1,psVar13,param_4);
+      if (7 < local_260) {
+        operator_delete((void *)CONCAT62(local_278[0]._2_6_,(short)local_278[0]));
+      }
+      local_260 = 7;
+      local_268 = 0;
+      local_278[0]._0_2_ = 0;
+      if (7 < local_300) {
+        operator_delete((void *)CONCAT62(uStack_316,local_318));
+      }
+      local_300 = 7;
+      local_308 = 0;
+      local_318 = 0;
+      FUN_14000a550((longlong)local_3b0);
+      std::basic_ios<wchar_t,std::char_traits<wchar_t>_>::
+      ~basic_ios<wchar_t,std::char_traits<wchar_t>_>(local_3b0);
+    }
+    else {
+      if (7 < local_300) {
+        operator_delete((void *)CONCAT62(uStack_316,local_318));
+      }
+      local_300 = 7;
+      local_308 = 0;
+      local_318 = 0;
+      FUN_14000a550((longlong)local_3b0);
+      std::basic_ios<wchar_t,std::char_traits<wchar_t>_>::
+      ~basic_ios<wchar_t,std::char_traits<wchar_t>_>(local_3b0);
+    }
+  }
+  FUN_140004e10((longlong)param_2);
+  return;
+}
+

decomp/Agent_Release_x64/0x1400094e0.pseudo.c

@@ -0,0 +1,107 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 pseudocode via REA, ev_e77cf4b520f4fa0b88408c03b2bdd27ca462d9ca84b0de51180cb56c85771b34
+ * Decompiler output, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+
+DWORD FUN_1400094e0(wchar_t *param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  int *piVar1;
+  wchar_t wVar2;
+  BOOL BVar3;
+  longlong *plVar4;
+  int *piVar5;
+  HANDLE hObject;
+  ulonglong uVar6;
+  wchar_t *pwVar7;
+  LPWSTR lpCommandLine;
+  undefined8 uVar8;
+  DWORD DVar9;
+  wchar_t *pwVar10;
+  code *pcVar11;
+  undefined8 uVar12;
+  _PROCESS_INFORMATION *_ArgList;
+  undefined1 auStackY_538 [32];
+  undefined *local_4e8;
+  _PROCESS_INFORMATION local_4e0;
+  int *local_4c8;
+  undefined1 local_4c0;
+  undefined8 local_4b8;
+  _STARTUPINFOW local_4a8;
+  wchar_t local_438;
+  undefined1 local_436 [526];
+  wchar_t local_228;
+  undefined1 local_226 [526];
+  ulonglong local_18;
+  
+  local_4b8 = 0xfffffffffffffffe;
+  local_18 = DAT_1401555a0 ^ (ulonglong)auStackY_538;
+  DVar9 = 0;
+  local_228 = L'\0';
+  memset(local_226,0,0x206);
+  local_438 = L'\0';
+  memset(local_436,0,0x206);
+  uVar6 = 0xffffffffffffffff;
+  pwVar10 = param_1;
+  do {
+    if (uVar6 == 0) break;
+    uVar6 = uVar6 - 1;
+    wVar2 = *pwVar10;
+    pwVar10 = pwVar10 + 1;
+  } while (wVar2 != L'\0');
+  uVar6 = ~uVar6;
+  wcscpy_s(&local_228,uVar6,param_1);
+  plVar4 = FUN_14002fe90((longlong *)&local_4e8,uVar6,param_1,param_4);
+  pwVar10 = (wchar_t *)*plVar4;
+  if ((wchar_t *)*plVar4 == (wchar_t *)0x0) {
+    pwVar10 = (wchar_t *)PTR_DAT_140155010;
+  }
+  pwVar7 = &local_438;
+  wcscpy_s(&local_438,0x104,pwVar10);
+  if (((local_4e8 != (undefined *)0x0) && (local_4e8 != PTR_DAT_140155010)) &&
+     (local_4e8 + -8 != (undefined *)0x0)) {
+    piVar5 = (int *)FUN_140030200(pwVar7,local_4e8,pwVar10,param_4);
+    local_4c8 = piVar5;
+    FUN_14002e6e0(piVar5);
+    local_4c0 = 1;
+    piVar1 = (int *)(local_4e8 + -4);
+    *piVar1 = *piVar1 + -1;
+    if (*piVar1 == 0) {
+      FUN_1400302f0(local_4e8 + -8);
+    }
+    FUN_14002e770((longlong)piVar5);
+  }
+  memset(&local_4a8,0,0x68);
+  local_4a8.cb = 0x68;
+  local_4a8.dwFlags = 0x13;
+  local_4a8.dwXSize = 700;
+  local_4a8.dwYSize = 0x6e;
+  local_4a8.dwFillAttribute = 0x17;
+  local_4a8.wShowWindow = 5;
+  uVar12 = 0;
+  uVar8 = 0;
+  lpCommandLine = &local_228;
+  BVar3 = CreateProcessW((LPCWSTR)0x0,lpCommandLine,(LPSECURITY_ATTRIBUTES)0x0,
+                         (LPSECURITY_ATTRIBUTES)0x0,0,0x10,(LPVOID)0x0,&local_438,&local_4a8,
+                         &local_4e0);
+  if (BVar3 == 0) {
+    FUN_140010aa0(L"=======Server Fail=======\n",lpCommandLine,uVar8,uVar12);
+    FUN_140010aa0(L"Path\t: [%s] \n",&local_438,uVar8,uVar12);
+    FUN_140010aa0(L"File\t: [%s] \n",&local_228,uVar8,uVar12);
+  }
+  else {
+    CloseHandle(local_4e0.hThread);
+    _ArgList = &local_4e0;
+    pcVar11 = FUN_140008c90;
+    uVar8 = 0;
+    hObject = (HANDLE)_beginthreadex((void *)0x0,0,FUN_140008c90,_ArgList,0,(uint *)&local_4e8);
+    CloseHandle(hObject);
+    FUN_140010aa0(L"=======ServerOn=======\n",uVar8,pcVar11,_ArgList);
+    DVar9 = local_4e0.dwProcessId;
+  }
+  printf("//////////////////////////////////////////////////////////////////////////\n");
+  Sleep(1000);
+  return DVar9;
+}
+

decomp/Agent_Release_x64/0x140009780.pseudo.c

@@ -0,0 +1,44 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 pseudocode via REA, ev_ad71d730ad826f5e73d5b5ec119273acf91c525002d977f0d017bc11eb2cfbb4
+ * Decompiler output, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+
+ulonglong FUN_140009780(wchar_t *param_1)
+
+{
+  int iVar1;
+  BOOL BVar2;
+  HANDLE hObject;
+  HANDLE hProcess;
+  undefined4 extraout_var;
+  undefined4 extraout_var_00;
+  undefined1 auStack_278 [32];
+  undefined4 local_258 [2];
+  DWORD local_250;
+  wchar_t local_22c [266];
+  ulonglong local_18;
+  
+  local_18 = DAT_1401555a0 ^ (ulonglong)auStack_278;
+  if (param_1 != (wchar_t *)0x0) {
+    hObject = (HANDLE)CreateToolhelp32Snapshot(2);
+    memset(local_258,0,0x238);
+    local_258[0] = 0x238;
+    iVar1 = Process32FirstW(hObject,local_258);
+    while (iVar1 != 0) {
+      iVar1 = _wcsicmp(param_1,local_22c);
+      if ((iVar1 == 0) &&
+         (hProcess = OpenProcess(1,0,local_250), hProcess != (HANDLE)0xffffffffffffffff)) {
+        wprintf(L"Process Kill.!!! [%s] \n");
+        TerminateProcess(hProcess,0);
+        BVar2 = CloseHandle(hProcess);
+        return CONCAT71((int7)(CONCAT44(extraout_var_00,BVar2) >> 8),1);
+      }
+      iVar1 = Process32NextW(hObject,local_258);
+    }
+    BVar2 = CloseHandle(hObject);
+    local_18 = CONCAT44(extraout_var,BVar2);
+  }
+  return local_18 & 0xffffffffffffff00;
+}
+

decomp/Agent_Release_x64/0x1400100b0.pseudo.c

@@ -0,0 +1,29 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 pseudocode via REA, ev_ad71d730ad826f5e73d5b5ec119273acf91c525002d977f0d017bc11eb2cfbb4
+ * Decompiler output, not original source. */
+
+undefined4 FUN_1400100b0(undefined8 *param_1)
+
+{
+  DWORD DVar1;
+  uint extraout_EAX;
+  HANDLE pvVar2;
+  wchar_t *_Format;
+  
+  pvVar2 = CreateMutexW((LPSECURITY_ATTRIBUTES)0x0,1,L"Global\\RustyHearts_Agent");
+  *param_1 = pvVar2;
+  DVar1 = GetLastError();
+  if (DVar1 == 5) {
+    _Format = L"ERROR_ACCESS_DENIED!!! %s \n";
+  }
+  else {
+    if (DVar1 != 0xb7) {
+      return CONCAT31((int3)(DVar1 >> 8),1);
+    }
+    _Format = L"ERROR_ALREADY_EXISTS!!! %s \n";
+  }
+  wprintf(_Format);
+  Sleep(3000);
+  return extraout_EAX & 0xffffff00;
+}
+

decomp/Agent_Release_x64/binary_overview.json

@@ -0,0 +1,83 @@
+{
+  "evidence_id": "ev_9fe3a449c6aa867adaabf1b34be9967bba78f98a7d72bc69f9fab835fb7db03b",
+  "sha256": "6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469",
+  "document": "target-6f2be7b8eb79.exe",
+  "image_base": "0x140000000",
+  "procedure_count": 6814,
+  "segment_count": 9,
+  "segments": [
+    {
+      "address_space": "ram",
+      "end": "0x140000400",
+      "image_base": "0x140000000",
+      "length": 1024,
+      "name": "Headers",
+      "start": "0x140000000"
+    },
+    {
+      "address_space": "ram",
+      "end": "0x1400f1a00",
+      "image_base": "0x140000000",
+      "length": 985600,
+      "name": ".text",
+      "start": "0x140001000"
+    },
+    {
+      "address_space": "ram",
+      "end": "0x140154200",
+      "image_base": "0x140000000",
+      "length": 401920,
+      "name": ".rdata",
+      "start": "0x1400f2000"
+    },
+    {
+      "address_space": "ram",
+      "end": "0x140163450",
+      "image_base": "0x140000000",
+      "length": 58448,
+      "name": ".data",
+      "start": "0x140155000"
+    },
+    {
+      "address_space": "ram",
+      "end": "0x14016ee00",
+      "image_base": "0x140000000",
+      "length": 44544,
+      "name": ".pdata",
+      "start": "0x140164000"
+    },
+    {
+      "address_space": "ram",
+      "end": "0x14016f200",
+      "image_base": "0x140000000",
+      "length": 512,
+      "name": ".tls",
+      "start": "0x14016f000"
+    },
+    {
+      "address_space": "ram",
+      "end": "0x140170200",
+      "image_base": "0x140000000",
+      "length": 512,
+      "name": ".rsrc",
+      "start": "0x140170000"
+    },
+    {
+      "address_space": "ram",
+      "end": "0x140173600",
+      "image_base": "0x140000000",
+      "length": 9728,
+      "name": ".reloc",
+      "start": "0x140171000"
+    },
+    {
+      "address_space": "ram",
+      "end": "0xff00001850",
+      "image_base": "0x140000000",
+      "length": 6224,
+      "name": "tdb",
+      "start": "0xff00000000"
+    }
+  ],
+  "string_count": 1472
+}

decomp/Agent_Release_x64/cpp/AgentProcessControl.cpp

@@ -0,0 +1,228 @@
+// AgentProcessControl.cpp — hand-lifted C++ reconstruction of Agent_Release_x64.exe
+// sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+//
+// Source of truth: Ghidra pseudocode in ../0x<addr>.pseudo.c and full/functions/.
+// This file is a READABLE RECONSTRUCTION, not recovered source:
+//   - control flow and Win32 calls are observed in the decompiled code;
+//   - all type/field/function names are inferred (no PDB) and marked so;
+//   - std::wstring temporaries, stack cookies and inlined string code are elided.
+// Static analysis only; runtime behaviour has not been observed.
+
+#include <windows.h>
+#include <tlhelp32.h>
+#include <process.h>
+#include <cstdio>
+#include <cwchar>
+#include <string>
+
+// ---------------------------------------------------------------------------
+// ServerEntry: per-managed-server record held in a hash map keyed by server
+// code (global at 0x140162d60, bucket array +0x38, bucket count +0x40,
+// element count +0x58). Offsets observed; names inferred.
+// ---------------------------------------------------------------------------
+struct ServerEntry {
+    /* +0x04 */ int32_t  code;        // hash key; sent in RMI notifications
+    /* +0x0c */ uint8_t  type;        // compared against server-type table; ==1 triggers extra step on exit
+    /* +0xa0 */ int32_t  unk_a0;      // zeroed when the process exits (purpose unknown)
+    /* +0xa4 */ DWORD    pid;         // set from CreateProcessW result
+    /* +0xb8..0xd7 */                  // 32 bytes copied into the RMI "server state" payload
+    /* +0xc4 */ int32_t  running;     // 1 = launched/launching, 0 = stopped
+    /* +0xd0 */ int32_t  unk_d0;      // >0 together with type==1 triggers FUN_140009f20 on exit
+    /* +0xd5 */ uint8_t  revive;      // relaunch on exit (inferred: XML key "revive_server")
+};
+// NOTE: layout shown as comments; real struct has unrecovered gaps.
+
+// Server-type table (global at 0x140162d58): vector of 0x30-byte records
+//   +0x00 uint8_t type; +0x08 std::wstring exePath (MSVC SSO, cap at +0x20)
+struct ServerTypeInfo { uint8_t type; std::wstring exePath; };
+
+// Agent options singleton (global at 0x140162d68). Observed fields:
+//   +0x030 std::wstring agentName (used in "FAILED SERVER ON %s")
+//   +0x152 bool  useCodeAsArgument   (true: arg = decimal server code)
+//   +0x171 bool  reviveAll           (global relaunch-on-exit)
+//   +0x178 double autoServerOnDelay  (seconds after start; <=0 disables)
+
+// ---------------------------------------------------------------------------
+// 0x1400100b0  AcquireSingleInstanceMutex   (observed)
+// ---------------------------------------------------------------------------
+bool AcquireSingleInstanceMutex(HANDLE* outMutex)
+{
+    *outMutex = CreateMutexW(nullptr, TRUE, L"Global\\RustyHearts_Agent");
+    DWORD err = GetLastError();
+    if (err == ERROR_ACCESS_DENIED)       wprintf(L"ERROR_ACCESS_DENIED!!! %s \n");   // format arg missing in binary
+    else if (err == ERROR_ALREADY_EXISTS) wprintf(L"ERROR_ALREADY_EXISTS!!! %s \n");
+    else return true;
+    Sleep(3000);
+    return false;
+}
+
+// ---------------------------------------------------------------------------
+// 0x140009780  KillProcessByName   (observed)
+// Terminates only the FIRST process whose image name matches (case-insensitive).
+// ---------------------------------------------------------------------------
+bool KillProcessByName(const wchar_t* exeName)
+{
+    if (!exeName) return false;
+    HANDLE snap = CreateToolhelp32Snapshot(TH32CS_SNAPPROCESS, 0);
+    PROCESSENTRY32W pe = { sizeof(pe) };
+    for (BOOL ok = Process32FirstW(snap, &pe); ok; ok = Process32NextW(snap, &pe)) {
+        if (_wcsicmp(exeName, pe.szExeFile) != 0) continue;
+        HANDLE h = OpenProcess(PROCESS_TERMINATE, FALSE, pe.th32ProcessID);
+        if (h != INVALID_HANDLE_VALUE) {          // binary compares to -1, not NULL
+            wprintf(L"Process Kill.!!! [%s] \n");    // format arg missing in binary
+            TerminateProcess(h, 0);
+            CloseHandle(h);
+            return true;                         // note: snapshot handle leaked on this path
+        }
+    }
+    CloseHandle(snap);
+    return false;
+}
+
+unsigned __stdcall ProcessWatchThread(void* arg);   // below
+
+// ---------------------------------------------------------------------------
+// 0x1400094e0  LaunchProcess   (observed)
+// Returns PID, or 0 on failure. Working directory = directory of the exe
+// (inferred: derived from cmdline by FUN_14002fe90).
+// ---------------------------------------------------------------------------
+DWORD LaunchProcess(const wchar_t* commandLine)
+{
+    wchar_t cmd[MAX_PATH] = {};
+    wchar_t workDir[MAX_PATH] = {};
+    wcscpy_s(cmd, commandLine);
+    /* workDir <- FUN_14002fe90(commandLine)  (inferred: path-of-exe helper) */
+
+    STARTUPINFOW si = {};
+    si.cb = sizeof(si);
+    si.dwFlags = STARTF_USESHOWWINDOW | STARTF_USESIZE | STARTF_USEFILLATTRIBUTE; // 0x13
+    si.dwXSize = 700;  si.dwYSize = 110;
+    si.dwFillAttribute = 0x17;                   // white on blue
+    si.wShowWindow = SW_SHOW;
+    PROCESS_INFORMATION pi = {};
+
+    DWORD pid = 0;
+    if (!CreateProcessW(nullptr, cmd, nullptr, nullptr, FALSE, CREATE_NEW_CONSOLE,
+                        nullptr, workDir, &si, &pi)) {
+        Log(L"=======Server Fail=======\n");
+        Log(L"Path\t: [%s] \n", workDir);
+        Log(L"File\t: [%s] \n", cmd);
+    } else {
+        CloseHandle(pi.hThread);
+        // passes a pointer to the STACK PROCESS_INFORMATION; the thread reads it
+        // immediately, so this relies on the 1 s Sleep below (latent race).
+        unsigned tid;
+        CloseHandle((HANDLE)_beginthreadex(nullptr, 0, ProcessWatchThread, &pi, 0, &tid));
+        Log(L"=======ServerOn=======\n");
+        pid = pi.dwProcessId;
+    }
+    printf("//////////////////////////////////////////////////////////////////////////\n");
+    Sleep(1000);
+    return pid;
+}
+
+// ---------------------------------------------------------------------------
+// 0x140008ea0  ServerOn(request)   (observed flow; names inferred)
+// request: +0x04 server code, +0x0c server type.
+// ---------------------------------------------------------------------------
+void ServerOn(void* self, const ServerRequest* req)
+{
+    ServerEntry* e = g_servers.Find(req->code);      // hash lookup
+    if (e->running == 0) {
+        e->running = 1;
+        AgentManagerSession* mgr = g_agentServer->managerSession; // 0x1400626f8 +0xa8
+
+        std::wstring cmd = g_serverTypes.ExePath(req->type) + L" ";
+        if (!g_options->useCodeAsArgument)
+            cmd += Widen(BuildLaunchArgs(g_options, req));  // FUN_140027540 — contents UNKNOWN
+        else
+            cmd += std::to_wstring(req->code);
+
+        DWORD pid = 0;
+        if (cmd.size() < MAX_PATH && (pid = LaunchProcess(cmd.c_str())) > 0) {
+            e->pid = pid;
+            e->running = 1;
+            // RMI to AgentManager, vtable slot +0x40 on proxy at session+0x68:
+            mgr->proxy.NotifyServerState(/*host*/1, /*rmiCtx*/g_rmiCtx, e->code, e->state, e->Serialize());
+        } else {
+            e->running = 0;
+        }
+        if (mgr && pid == 0)
+            mgr->SendLog(1, Format(L"FAILED SERVER ON %s ", g_options->agentName.c_str()));
+    }
+    ReleaseRequest(req);                              // FUN_140004e10
+}
+
+// ---------------------------------------------------------------------------
+// 0x140008c90  ProcessWatchThread   (observed)
+// ---------------------------------------------------------------------------
+unsigned __stdcall ProcessWatchThread(void* arg)
+{
+    auto* pi = static_cast<PROCESS_INFORMATION*>(arg);
+    HANDLE hProcess = pi->hProcess;
+    DWORD  pid      = pi->dwProcessId;
+    DWORD  code;
+    do { Sleep(10); GetExitCodeProcess(hProcess, &code); } while (code == STILL_ACTIVE);
+    // note: hProcess is never closed (handle leak per launch)
+
+    ServerEntry* e = g_servers.FindByPid(pid);       // FUN_14002c9a0
+    if (!e) { wprintf(L"NOT FIND PROCESS ID \n"); return 0; }
+
+    AgentManagerSession* mgr = g_agentServer->managerSession;
+    if (mgr) {
+        e->unk_a0 = 0;
+        e->running = 0;
+        mgr->proxy.NotifyServerState(1, g_rmiCtx, e->code, e->state, e->Serialize()); // slot +0x40
+        mgr->proxy.NotifyServerStopped(1, g_rmiCtx, /*flag*/1, e->code, /*?*/1);     // slot +0x50
+        if (e->revive || g_options->reviveAll) {
+            ServerOn(g_agentProcess, MakeRequest(e));
+            if (e->type == 1 && e->unk_d0 > 0) FUN_140009f20(g_agentProcess, e->code);
+        }
+    }
+    return 0;
+}
+
+// ---------------------------------------------------------------------------
+// 0x1400037a0  MagiAgentServer::Run   (observed; simplified)
+// ---------------------------------------------------------------------------
+int MagiAgentServer::Run()
+{
+    LogBanner(L"# Agent Startup #\n\n");
+    CoInitialize(nullptr);
+    Log(L"+ Prepare Startup\n");
+
+    network_        = new MagiAgentNetwork();          // 0xb8 bytes, FUN_140005020
+    managerSession_ = new MGAgentManagerSession(network_); // 0x68 bytes
+    /* if options map has entry type 0x15 (AgentManager address):
+         connect and pump until connected (FUN_1400023e0 loop) */
+    network_->Start();                                  // FUN_140005360
+    LogBanner(L"\n # Agent Running... #\n");
+
+    timer_ = new Magi::Timer(new TimeSourceHRWin32());  // QueryPerformanceCounter
+    g_options->Load();                                  // FUN_1400271e0
+    KillProcessByName(g_serverTypes.ExePath(0x18));     // kill stale process of type 0x18 (UNKNOWN which server)
+    StartConsoleThread();                               // FUN_140001dc0 (inferred: keyboard menu)
+
+    bool autoOnPending = true;
+    double lastSec = 0, lastTick = 0;
+    while (running_) {                                  // +0x60
+        clock_.Update();
+        double now = timer_->Now();
+        if (g_options->autoServerOnDelay > 0 && now > g_options->autoServerOnDelay && autoOnPending) {
+            autoOnPending = false;
+            printf("Start Auto Server On. \n");
+            AllServerOn();                              // FUN_140009bd0
+        }
+        managerSession_->Update(now);                   // FUN_140007da0
+        if (now - lastSec >= 1.0) { /* optional "[ %s ] FPS[ %d ]" print */ lastSec = now; }
+        if (now - lastTick >= 0.1) { Tick(); network_->Update(now); lastTick = now; } // 10 Hz
+        lastTime_ = now;
+        Sleep(1);
+    }
+    Log(L"+ Prepare Stop\n");
+    managerSession_->Stop();
+    delete network_->netServer_;
+    CoUninitialize();
+    LogBanner(L"# Agent Stoped... #\n");
+    return 0;
+}

decomp/Agent_Release_x64/cpp/classes.hpp

@@ -0,0 +1,463 @@
+// Auto-generated from RTTI vftables (full/vtables.tsv), Ghidra 12.1.2.
+// Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+// RECONSTRUCTION. Observed: class names (RTTI) and vftable slot -> function address.
+// Unknown (no PDB): method names, signatures, data members, base-class relationships.
+// A class with several vftables uses multiple inheritance (one vftable per base
+// subobject); which base each belongs to is not yet recovered, so slots are
+// grouped as vtN. Implementations: full/functions/<address>.c
+#pragma once
+
+// MBISingleton<CConsoleControl> (template instantiation) vftable 0x14011aff8: 0x140001300
+
+class CConsoleControl {
+public:
+    // vt0: vftable 0x14011afe8
+    virtual void vt0_0_vf_140001300();  // slot 0 -> 0x140001300
+};
+
+class MagiServerBase {
+public:
+    // vt0: vftable 0x14011b130
+    virtual void vt0_0_vf_140001b50();  // slot 0 -> 0x140001b50
+};
+
+class MagiCommonSession {
+public:
+    // vt0: vftable 0x14011b518
+    virtual void vt0_0_vf_1400020d0();  // slot 0 -> 0x1400020d0
+    virtual void vt0_pure1() = 0;  // slot 1 -> 0x14003b036 (_purecall)
+    virtual void vt0_pure2() = 0;  // slot 2 -> 0x14003b036 (_purecall)
+    virtual void vt0_pure3() = 0;  // slot 3 -> 0x14003b036 (_purecall)
+    virtual void vt0_pure4() = 0;  // slot 4 -> 0x14003b036 (_purecall)
+    virtual void vt0_pure5() = 0;  // slot 5 -> 0x14003b036 (_purecall)
+    virtual void vt0_6_vf_140006b80();  // slot 6 -> 0x140006b80
+    virtual void vt0_pure7() = 0;  // slot 7 -> 0x14003b036 (_purecall)
+    virtual void vt0_pure8() = 0;  // slot 8 -> 0x14003b036 (_purecall)
+    virtual void vt0_pure9() = 0;  // slot 9 -> 0x14003b036 (_purecall)
+    virtual void vt0_pure10() = 0;  // slot 10 -> 0x14003b036 (_purecall)
+    virtual void vt0_pure11() = 0;  // slot 11 -> 0x14003b036 (_purecall)
+    virtual void vt0_12_vf_140006b80();  // slot 12 -> 0x140006b80
+    virtual void vt0_pure13() = 0;  // slot 13 -> 0x14003b036 (_purecall)
+};
+
+// MBISingleton<MagiAgentServer> (template instantiation) vftable 0x14011bc00: 0x140004fc0
+
+class MagiAgentServer {
+public:
+    // vt0: vftable 0x14011bbc0
+    virtual void vt0_0_vf_140004c00();  // slot 0 -> 0x140004c00
+    // vt1: vftable 0x14011bbb0
+    virtual void vt1_0_vf_1400033f0();  // slot 0 -> 0x1400033f0
+};
+
+class MagiAgentNetwork {
+public:
+    // vt0: vftable 0x14011cb58
+    virtual void vt0_0_vf_140006b70();  // slot 0 -> 0x140006b70
+    virtual void vt0_1_vf_140006b60();  // slot 1 -> 0x140006b60
+    virtual void vt0_2_vf_140018120();  // slot 2 -> 0x140018120
+    virtual void vt0_3_vf_140006b80();  // slot 3 -> 0x140006b80
+    virtual void vt0_4_vf_140006b80();  // slot 4 -> 0x140006b80
+    virtual void vt0_5_vf_140006b30();  // slot 5 -> 0x140006b30
+    virtual void vt0_6_vf_140006b10();  // slot 6 -> 0x140006b10
+    virtual void vt0_7_vf_14000b970();  // slot 7 -> 0x14000b970
+    virtual void vt0_8_vf_14000bb00();  // slot 8 -> 0x14000bb00
+    virtual void vt0_9_vf_14000bd70();  // slot 9 -> 0x14000bd70
+    virtual void vt0_10_vf_14000c120();  // slot 10 -> 0x14000c120
+    virtual void vt0_11_vf_140006b20();  // slot 11 -> 0x140006b20
+    virtual void vt0_12_vf_14000be40();  // slot 12 -> 0x14000be40
+    virtual void vt0_13_vf_14000be80();  // slot 13 -> 0x14000be80
+    virtual void vt0_14_vf_14000bed0();  // slot 14 -> 0x14000bed0
+    virtual void vt0_15_vf_140006b20();  // slot 15 -> 0x140006b20
+    virtual void vt0_16_vf_14000bf00();  // slot 16 -> 0x14000bf00
+    virtual void vt0_17_vf_14000bf30();  // slot 17 -> 0x14000bf30
+    virtual void vt0_18_vf_14000bf50();  // slot 18 -> 0x14000bf50
+    // vt1: vftable 0x14011cab8
+    virtual void vt1_0_vf_140005100();  // slot 0 -> 0x140005100
+    virtual void vt1_1_vf_140005200();  // slot 1 -> 0x140005200
+    virtual void vt1_2_vf_1400052a0();  // slot 2 -> 0x1400052a0
+    virtual void vt1_3_vf_140006b80();  // slot 3 -> 0x140006b80
+    virtual void vt1_4_vf_140005340();  // slot 4 -> 0x140005340
+    virtual void vt1_5_vf_140006b80();  // slot 5 -> 0x140006b80
+    virtual void vt1_6_vf_140006b80();  // slot 6 -> 0x140006b80
+    virtual void vt1_7_vf_140005620();  // slot 7 -> 0x140005620
+    virtual void vt1_8_vf_1400056f0();  // slot 8 -> 0x1400056f0
+    virtual void vt1_9_vf_140005940();  // slot 9 -> 0x140005940
+    virtual void vt1_10_vf_140006b80();  // slot 10 -> 0x140006b80
+    virtual void vt1_11_vf_140006b80();  // slot 11 -> 0x140006b80
+    virtual void vt1_12_vf_140006b80();  // slot 12 -> 0x140006b80
+    virtual void vt1_13_vf_140006b80();  // slot 13 -> 0x140006b80
+    virtual void vt1_14_vf_140006b80();  // slot 14 -> 0x140006b80
+    virtual void vt1_15_vf_140006b80();  // slot 15 -> 0x140006b80
+    virtual void vt1_16_vf_140006b80();  // slot 16 -> 0x140006b80
+    virtual void vt1_17_vf_140006b80();  // slot 17 -> 0x140006b80
+};
+
+class MGAgentManagerSession {
+public:
+    // vt0: vftable 0x14011cf18
+    virtual void vt0_0_vf_140008c00();  // slot 0 -> 0x140008c00
+    virtual void vt0_1_vf_140008bf0();  // slot 1 -> 0x140008bf0
+    virtual void vt0_2_vf_14001d960();  // slot 2 -> 0x14001d960
+    virtual void vt0_3_vf_140006b80();  // slot 3 -> 0x140006b80
+    virtual void vt0_4_vf_140006b80();  // slot 4 -> 0x140006b80
+    virtual void vt0_5_vf_140006b30();  // slot 5 -> 0x140006b30
+    virtual void vt0_6_vf_140008be0();  // slot 6 -> 0x140008be0
+    virtual void vt0_7_vf_14000d780();  // slot 7 -> 0x14000d780
+    virtual void vt0_8_vf_14000df90();  // slot 8 -> 0x14000df90
+    virtual void vt0_9_vf_14000e410();  // slot 9 -> 0x14000e410
+    virtual void vt0_10_vf_14000e1e0();  // slot 10 -> 0x14000e1e0
+    virtual void vt0_11_vf_14000e460();  // slot 11 -> 0x14000e460
+    virtual void vt0_12_vf_14000e080();  // slot 12 -> 0x14000e080
+    virtual void vt0_13_vf_14000e0b0();  // slot 13 -> 0x14000e0b0
+    virtual void vt0_14_vf_14000e480();  // slot 14 -> 0x14000e480
+    virtual void vt0_15_vf_14000e4c0();  // slot 15 -> 0x14000e4c0
+    virtual void vt0_16_vf_14000e4f0();  // slot 16 -> 0x14000e4f0
+    virtual void vt0_17_vf_14000e520();  // slot 17 -> 0x14000e520
+    virtual void vt0_18_vf_14000e550();  // slot 18 -> 0x14000e550
+    virtual void vt0_19_vf_14000d140();  // slot 19 -> 0x14000d140
+    virtual void vt0_20_vf_14000d1d0();  // slot 20 -> 0x14000d1d0
+    virtual void vt0_21_vf_14000d320();  // slot 21 -> 0x14000d320
+    virtual void vt0_22_vf_14000d260();  // slot 22 -> 0x14000d260
+    virtual void vt0_23_vf_14000d3b0();  // slot 23 -> 0x14000d3b0
+    // vt1: vftable 0x14011ce98
+    virtual void vt1_0_vf_140007030();  // slot 0 -> 0x140007030
+    virtual void vt1_1_vf_140007120();  // slot 1 -> 0x140007120
+    virtual void vt1_2_vf_1400071c0();  // slot 2 -> 0x1400071c0
+    virtual void vt1_3_vf_140006b80();  // slot 3 -> 0x140006b80
+    virtual void vt1_4_vf_140007260();  // slot 4 -> 0x140007260
+    virtual void vt1_5_vf_140006b80();  // slot 5 -> 0x140006b80
+    virtual void vt1_6_vf_140006b80();  // slot 6 -> 0x140006b80
+    virtual void vt1_7_vf_140007280();  // slot 7 -> 0x140007280
+    virtual void vt1_8_vf_1400073a0();  // slot 8 -> 0x1400073a0
+    virtual void vt1_9_vf_140006b80();  // slot 9 -> 0x140006b80
+    virtual void vt1_10_vf_140006b80();  // slot 10 -> 0x140006b80
+    virtual void vt1_11_vf_140006b80();  // slot 11 -> 0x140006b80
+    virtual void vt1_12_vf_140006b80();  // slot 12 -> 0x140006b80
+    virtual void vt1_13_vf_140006b80();  // slot 13 -> 0x140006b80
+};
+
+// MBISingleton<MagiAgentProcess> (template instantiation) vftable 0x14011d240: 0x14000b910
+
+class MagiAgentProcess {
+public:
+    // vt0: vftable 0x14011d230
+    virtual void vt0_0_vf_140008c10();  // slot 0 -> 0x140008c10
+};
+
+// MBMultiThreadSync<MBCLog> (template instantiation) vftable 0x14011d748: 0x14000ebb0
+
+// MBISingleton<MBCLog> (template instantiation) vftable 0x14011d738: 0x14000eb70
+
+class MBCLog {
+public:
+    // vt0: vftable 0x14011d728
+    virtual void vt0_0_vf_14000ecb0();  // slot 0 -> 0x14000ecb0
+    // vt1: vftable 0x14011d718
+    virtual void vt1_0_vf_14000eb10();  // slot 0 -> 0x14000eb10
+};
+
+// MBISingleton<Clock> (template instantiation) vftable 0x14011e9e8: 0x140016290
+
+class Clock {
+public:
+    // vt0: vftable 0x14011e9d8
+    virtual void vt0_0_vf_1400162d0();  // slot 0 -> 0x1400162d0
+    // vt1: vftable 0x14011e9b0
+    virtual void vt1_0_vf_1400161b0();  // slot 0 -> 0x1400161b0
+    virtual void vt1_1_vf_1400161a0();  // slot 1 -> 0x1400161a0
+    virtual void vt1_2_vf_1400dc2d0();  // slot 2 -> 0x1400dc2d0
+    virtual void vt1_3_vf_1400dc230();  // slot 3 -> 0x1400dc230
+};
+
+class ISubject {
+public:
+    // vt0: vftable 0x14011e988
+    virtual void vt0_0_vf_140016170();  // slot 0 -> 0x140016170
+    virtual void vt0_pure1() = 0;  // slot 1 -> 0x14003b036 (_purecall)
+    virtual void vt0_pure2() = 0;  // slot 2 -> 0x14003b036 (_purecall)
+    virtual void vt0_pure3() = 0;  // slot 3 -> 0x14003b036 (_purecall)
+};
+
+class TimeSourceHRWin32 {
+public:
+    // vt0: vftable 0x14011ea10
+    virtual void vt0_0_vf_1400162e0();  // slot 0 -> 0x1400162e0
+    virtual void vt0_1_vf_1400dc130();  // slot 1 -> 0x1400dc130
+};
+
+class TimeSource {
+public:
+    // vt0: vftable 0x14011e9f8
+    virtual void vt0_0_vf_1400162e0();  // slot 0 -> 0x1400162e0
+    virtual void vt0_pure1() = 0;  // slot 1 -> 0x14003b036 (_purecall)
+};
+
+namespace Magi {
+class Timer {
+public:
+    // vt0: vftable 0x14011ea40
+    virtual void vt0_0_vf_140016350();  // slot 0 -> 0x140016350
+    virtual void vt0_1_vf_1400dc040();  // slot 1 -> 0x1400dc040
+};
+}
+
+class IObserver {
+public:
+    // vt0: vftable 0x14011ea28
+    virtual void vt0_0_vf_140016320();  // slot 0 -> 0x140016320
+    virtual void vt0_pure1() = 0;  // slot 1 -> 0x14003b036 (_purecall)
+};
+
+namespace RNP {
+class Server2AgentStub {
+public:
+    // vt0: vftable 0x14011f108
+    virtual void vt0_0_vf_140006b70();  // slot 0 -> 0x140006b70
+    virtual void vt0_1_vf_140006b60();  // slot 1 -> 0x140006b60
+    virtual void vt0_2_vf_140018120();  // slot 2 -> 0x140018120
+    virtual void vt0_3_vf_140006b80();  // slot 3 -> 0x140006b80
+    virtual void vt0_4_vf_140006b80();  // slot 4 -> 0x140006b80
+    virtual void vt0_5_vf_140006b30();  // slot 5 -> 0x140006b30
+    virtual void vt0_6_scalar_deleting_dtor();  // slot 6 -> 0x14001ac20
+    virtual void vt0_7_vf_140006b20();  // slot 7 -> 0x140006b20
+    virtual void vt0_8_vf_140006b20();  // slot 8 -> 0x140006b20
+    virtual void vt0_9_vf_140006b20();  // slot 9 -> 0x140006b20
+    virtual void vt0_10_vf_140006b20();  // slot 10 -> 0x140006b20
+    virtual void vt0_11_vf_140006b20();  // slot 11 -> 0x140006b20
+    virtual void vt0_12_vf_140006b20();  // slot 12 -> 0x140006b20
+    virtual void vt0_13_vf_140006b20();  // slot 13 -> 0x140006b20
+    virtual void vt0_14_vf_140006b20();  // slot 14 -> 0x140006b20
+    virtual void vt0_15_vf_140006b20();  // slot 15 -> 0x140006b20
+    virtual void vt0_16_vf_140006b20();  // slot 16 -> 0x140006b20
+    virtual void vt0_17_vf_140006b20();  // slot 17 -> 0x140006b20
+    virtual void vt0_18_vf_140006b20();  // slot 18 -> 0x140006b20
+};
+}
+
+namespace RNP {
+class Agent2ServerProxy {
+public:
+    // vt0: vftable 0x14011eff8
+    virtual void vt0_0_vf_1400163b0();  // slot 0 -> 0x1400163b0
+    virtual void vt0_1_vf_1400163c0();  // slot 1 -> 0x1400163c0
+    virtual void vt0_2_vf_140006b80();  // slot 2 -> 0x140006b80
+    virtual void vt0_3_vf_140082060();  // slot 3 -> 0x140082060
+    virtual void vt0_4_scalar_deleting_dtor();  // slot 4 -> 0x14001abd0
+    virtual void vt0_5_vf_1400165e0();  // slot 5 -> 0x1400165e0
+    virtual void vt0_6_vf_140016400();  // slot 6 -> 0x140016400
+    virtual void vt0_7_vf_1400168d0();  // slot 7 -> 0x1400168d0
+    virtual void vt0_8_vf_1400167f0();  // slot 8 -> 0x1400167f0
+    virtual void vt0_9_vf_140016aa0();  // slot 9 -> 0x140016aa0
+    virtual void vt0_10_vf_1400169b0();  // slot 10 -> 0x1400169b0
+    virtual void vt0_11_vf_140016c70();  // slot 11 -> 0x140016c70
+    virtual void vt0_12_vf_140016b90();  // slot 12 -> 0x140016b90
+    virtual void vt0_13_vf_140016e50();  // slot 13 -> 0x140016e50
+    virtual void vt0_14_vf_140016d50();  // slot 14 -> 0x140016d50
+    virtual void vt0_15_vf_140017040();  // slot 15 -> 0x140017040
+    virtual void vt0_16_vf_140016f60();  // slot 16 -> 0x140016f60
+    virtual void vt0_17_vf_140017210();  // slot 17 -> 0x140017210
+    virtual void vt0_18_vf_140017120();  // slot 18 -> 0x140017120
+    virtual void vt0_19_vf_1400173f0();  // slot 19 -> 0x1400173f0
+    virtual void vt0_20_vf_140017310();  // slot 20 -> 0x140017310
+    virtual void vt0_21_vf_1400175f0();  // slot 21 -> 0x1400175f0
+    virtual void vt0_22_vf_1400174d0();  // slot 22 -> 0x1400174d0
+    virtual void vt0_23_vf_140017810();  // slot 23 -> 0x140017810
+    virtual void vt0_24_vf_140017720();  // slot 24 -> 0x140017720
+    virtual void vt0_25_vf_1400179f0();  // slot 25 -> 0x1400179f0
+    virtual void vt0_26_vf_140017900();  // slot 26 -> 0x140017900
+    virtual void vt0_27_vf_140017bd0();  // slot 27 -> 0x140017bd0
+    virtual void vt0_28_vf_140017ae0();  // slot 28 -> 0x140017ae0
+    virtual void vt0_29_vf_140017dd0();  // slot 29 -> 0x140017dd0
+    virtual void vt0_30_vf_140017cc0();  // slot 30 -> 0x140017cc0
+    virtual void vt0_31_vf_140018000();  // slot 31 -> 0x140018000
+    virtual void vt0_32_vf_140017ef0();  // slot 32 -> 0x140017ef0
+};
+}
+
+namespace AGENT2SERVER_PROTOCOL {
+class Proxy {
+public:
+    // vt0: vftable 0x14011eee8
+    virtual void vt0_0_vf_1400163b0();  // slot 0 -> 0x1400163b0
+    virtual void vt0_1_vf_1400163c0();  // slot 1 -> 0x1400163c0
+    virtual void vt0_2_vf_140093300();  // slot 2 -> 0x140093300
+    virtual void vt0_3_vf_140082060();  // slot 3 -> 0x140082060
+    virtual void vt0_4_vf_1400163d0();  // slot 4 -> 0x1400163d0
+    virtual void vt0_5_vf_1400165e0();  // slot 5 -> 0x1400165e0
+    virtual void vt0_6_vf_140016400();  // slot 6 -> 0x140016400
+    virtual void vt0_7_vf_1400168d0();  // slot 7 -> 0x1400168d0
+    virtual void vt0_8_vf_1400167f0();  // slot 8 -> 0x1400167f0
+    virtual void vt0_9_vf_140016aa0();  // slot 9 -> 0x140016aa0
+    virtual void vt0_10_vf_1400169b0();  // slot 10 -> 0x1400169b0
+    virtual void vt0_11_vf_140016c70();  // slot 11 -> 0x140016c70
+    virtual void vt0_12_vf_140016b90();  // slot 12 -> 0x140016b90
+    virtual void vt0_13_vf_140016e50();  // slot 13 -> 0x140016e50
+    virtual void vt0_14_vf_140016d50();  // slot 14 -> 0x140016d50
+    virtual void vt0_15_vf_140017040();  // slot 15 -> 0x140017040
+    virtual void vt0_16_vf_140016f60();  // slot 16 -> 0x140016f60
+    virtual void vt0_17_vf_140017210();  // slot 17 -> 0x140017210
+    virtual void vt0_18_vf_140017120();  // slot 18 -> 0x140017120
+    virtual void vt0_19_vf_1400173f0();  // slot 19 -> 0x1400173f0
+    virtual void vt0_20_vf_140017310();  // slot 20 -> 0x140017310
+    virtual void vt0_21_vf_1400175f0();  // slot 21 -> 0x1400175f0
+    virtual void vt0_22_vf_1400174d0();  // slot 22 -> 0x1400174d0
+    virtual void vt0_23_vf_140017810();  // slot 23 -> 0x140017810
+    virtual void vt0_24_vf_140017720();  // slot 24 -> 0x140017720
+    virtual void vt0_25_vf_1400179f0();  // slot 25 -> 0x1400179f0
+    virtual void vt0_26_vf_140017900();  // slot 26 -> 0x140017900
+    virtual void vt0_27_vf_140017bd0();  // slot 27 -> 0x140017bd0
+    virtual void vt0_28_vf_140017ae0();  // slot 28 -> 0x140017ae0
+    virtual void vt0_29_vf_140017dd0();  // slot 29 -> 0x140017dd0
+    virtual void vt0_30_vf_140017cc0();  // slot 30 -> 0x140017cc0
+    virtual void vt0_31_vf_140018000();  // slot 31 -> 0x140018000
+    virtual void vt0_32_vf_140017ef0();  // slot 32 -> 0x140017ef0
+};
+}
+
+namespace RNP {
+class AgentManager2AgentStub {
+public:
+    // vt0: vftable 0x14011f448
+    virtual void vt0_0_vf_140008c00();  // slot 0 -> 0x140008c00
+    virtual void vt0_1_vf_140008bf0();  // slot 1 -> 0x140008bf0
+    virtual void vt0_2_vf_14001d960();  // slot 2 -> 0x14001d960
+    virtual void vt0_3_vf_140006b80();  // slot 3 -> 0x140006b80
+    virtual void vt0_4_vf_140006b80();  // slot 4 -> 0x140006b80
+    virtual void vt0_5_vf_140006b30();  // slot 5 -> 0x140006b30
+    virtual void vt0_6_scalar_deleting_dtor();  // slot 6 -> 0x140021110
+    virtual void vt0_7_vf_140006b20();  // slot 7 -> 0x140006b20
+    virtual void vt0_8_vf_140006b20();  // slot 8 -> 0x140006b20
+    virtual void vt0_9_vf_140006b20();  // slot 9 -> 0x140006b20
+    virtual void vt0_10_vf_140006b20();  // slot 10 -> 0x140006b20
+    virtual void vt0_11_vf_140006b20();  // slot 11 -> 0x140006b20
+    virtual void vt0_12_vf_140006b20();  // slot 12 -> 0x140006b20
+    virtual void vt0_13_vf_140006b20();  // slot 13 -> 0x140006b20
+    virtual void vt0_14_vf_140006b20();  // slot 14 -> 0x140006b20
+    virtual void vt0_15_vf_140006b20();  // slot 15 -> 0x140006b20
+    virtual void vt0_16_vf_140006b20();  // slot 16 -> 0x140006b20
+    virtual void vt0_17_vf_140006b20();  // slot 17 -> 0x140006b20
+    virtual void vt0_18_vf_140006b20();  // slot 18 -> 0x140006b20
+    virtual void vt0_19_vf_140006b20();  // slot 19 -> 0x140006b20
+    virtual void vt0_20_vf_140006b20();  // slot 20 -> 0x140006b20
+    virtual void vt0_21_vf_140006b20();  // slot 21 -> 0x140006b20
+    virtual void vt0_22_vf_140006b20();  // slot 22 -> 0x140006b20
+    virtual void vt0_23_vf_140006b20();  // slot 23 -> 0x140006b20
+};
+}
+
+namespace RNP {
+class Agent2AgentManagerProxy {
+public:
+    // vt0: vftable 0x14011f368
+    virtual void vt0_0_vf_14001c210();  // slot 0 -> 0x14001c210
+    virtual void vt0_1_vf_14001c220();  // slot 1 -> 0x14001c220
+    virtual void vt0_2_vf_140006b80();  // slot 2 -> 0x140006b80
+    virtual void vt0_3_vf_140082060();  // slot 3 -> 0x140082060
+    virtual void vt0_4_scalar_deleting_dtor();  // slot 4 -> 0x1400210c0
+    virtual void vt0_5_vf_14001c340();  // slot 5 -> 0x14001c340
+    virtual void vt0_6_vf_14001c230();  // slot 6 -> 0x14001c230
+    virtual void vt0_7_vf_14001c600();  // slot 7 -> 0x14001c600
+    virtual void vt0_8_vf_14001c470();  // slot 8 -> 0x14001c470
+    virtual void vt0_9_vf_14001c8a0();  // slot 9 -> 0x14001c8a0
+    virtual void vt0_10_vf_14001c7a0();  // slot 10 -> 0x14001c7a0
+    virtual void vt0_11_vf_14001cac0();  // slot 11 -> 0x14001cac0
+    virtual void vt0_12_vf_14001c9b0();  // slot 12 -> 0x14001c9b0
+    virtual void vt0_13_vf_14001ccf0();  // slot 13 -> 0x14001ccf0
+    virtual void vt0_14_vf_14001cbe0();  // slot 14 -> 0x14001cbe0
+    virtual void vt0_15_vf_14001cf30();  // slot 15 -> 0x14001cf30
+    virtual void vt0_16_vf_14001ce10();  // slot 16 -> 0x14001ce10
+    virtual void vt0_17_vf_14001d150();  // slot 17 -> 0x14001d150
+    virtual void vt0_18_vf_14001d060();  // slot 18 -> 0x14001d060
+    virtual void vt0_19_vf_14001d340();  // slot 19 -> 0x14001d340
+    virtual void vt0_20_vf_14001d250();  // slot 20 -> 0x14001d250
+    virtual void vt0_21_vf_14001d520();  // slot 21 -> 0x14001d520
+    virtual void vt0_22_vf_14001d430();  // slot 22 -> 0x14001d430
+    virtual void vt0_23_vf_14001d6f0();  // slot 23 -> 0x14001d6f0
+    virtual void vt0_24_vf_14001d610();  // slot 24 -> 0x14001d610
+    virtual void vt0_25_vf_14001d890();  // slot 25 -> 0x14001d890
+    virtual void vt0_26_vf_14001d7d0();  // slot 26 -> 0x14001d7d0
+};
+}
+
+namespace AGENT2AGENTMANAGER_PROTOCOL {
+class Proxy {
+public:
+    // vt0: vftable 0x14011f288
+    virtual void vt0_0_vf_14001c210();  // slot 0 -> 0x14001c210
+    virtual void vt0_1_vf_14001c220();  // slot 1 -> 0x14001c220
+    virtual void vt0_2_vf_140093300();  // slot 2 -> 0x140093300
+    virtual void vt0_3_vf_140082060();  // slot 3 -> 0x140082060
+    virtual void vt0_4_vf_1400163d0();  // slot 4 -> 0x1400163d0
+    virtual void vt0_5_vf_14001c340();  // slot 5 -> 0x14001c340
+    virtual void vt0_6_vf_14001c230();  // slot 6 -> 0x14001c230
+    virtual void vt0_7_vf_14001c600();  // slot 7 -> 0x14001c600
+    virtual void vt0_8_vf_14001c470();  // slot 8 -> 0x14001c470
+    virtual void vt0_9_vf_14001c8a0();  // slot 9 -> 0x14001c8a0
+    virtual void vt0_10_vf_14001c7a0();  // slot 10 -> 0x14001c7a0
+    virtual void vt0_11_vf_14001cac0();  // slot 11 -> 0x14001cac0
+    virtual void vt0_12_vf_14001c9b0();  // slot 12 -> 0x14001c9b0
+    virtual void vt0_13_vf_14001ccf0();  // slot 13 -> 0x14001ccf0
+    virtual void vt0_14_vf_14001cbe0();  // slot 14 -> 0x14001cbe0
+    virtual void vt0_15_vf_14001cf30();  // slot 15 -> 0x14001cf30
+    virtual void vt0_16_vf_14001ce10();  // slot 16 -> 0x14001ce10
+    virtual void vt0_17_vf_14001d150();  // slot 17 -> 0x14001d150
+    virtual void vt0_18_vf_14001d060();  // slot 18 -> 0x14001d060
+    virtual void vt0_19_vf_14001d340();  // slot 19 -> 0x14001d340
+    virtual void vt0_20_vf_14001d250();  // slot 20 -> 0x14001d250
+    virtual void vt0_21_vf_14001d520();  // slot 21 -> 0x14001d520
+    virtual void vt0_22_vf_14001d430();  // slot 22 -> 0x14001d430
+    virtual void vt0_23_vf_14001d6f0();  // slot 23 -> 0x14001d6f0
+    virtual void vt0_24_vf_14001d610();  // slot 24 -> 0x14001d610
+    virtual void vt0_25_vf_14001d890();  // slot 25 -> 0x14001d890
+    virtual void vt0_26_vf_14001d7d0();  // slot 26 -> 0x14001d7d0
+};
+}
+
+// MBISingleton<MagiServerOption> (template instantiation) vftable 0x14011ff98: 0x14002a780
+
+class MagiServerOption {
+public:
+    // vt0: vftable 0x14011fe48
+    virtual void vt0_0_vf_140022630();  // slot 0 -> 0x140022630
+};
+
+// MBISingleton<MagiServerFile> (template instantiation) vftable 0x14011fff8: 0x14002abf0
+
+class MagiServerFile {
+public:
+    // vt0: vftable 0x14011ffe8
+    virtual void vt0_0_vf_14002a7e0();  // slot 0 -> 0x14002a7e0
+};
+
+// MBISingleton<MagiCustomOption> (template instantiation) vftable 0x1401204f8: 0x14002c2f0
+
+class MagiCustomOption {
+public:
+    // vt0: vftable 0x1401204e8
+    virtual void vt0_0_vf_14002b7b0();  // slot 0 -> 0x14002b7b0
+};
+
+// MBISingleton<MagiServerManager> (template instantiation) vftable 0x140120600: 0x14002e180
+
+class MagiServerManager {
+public:
+    // vt0: vftable 0x1401205f0
+    virtual void vt0_0_vf_14002c390();  // slot 0 -> 0x14002c390
+};
+
+// MBISingleton<MagiAgentCommon> (template instantiation) vftable 0x140120620: 0x14002e410
+
+class MagiAgentCommon {
+public:
+    // vt0: vftable 0x140120610
+    virtual void vt0_0_vf_14002e330();  // slot 0 -> 0x14002e330
+};
+
+// MBISingleton<MagiRealTimeEventData> (template instantiation) vftable 0x140120640: 0x14002e5a0
+
+class MagiRealTimeEventData {
+public:
+    // vt0: vftable 0x140120630
+    virtual void vt0_0_vf_14002e470();  // slot 0 -> 0x14002e470
+};

decomp/Agent_Release_x64/evidence.md

@@ -0,0 +1,65 @@
+# Agent_Release_x64.exe — finding ledger
+
+- SHA-256 `6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469`, 1,472,512 bytes
+- PE32+ x86-64, Windows CUI, MSVC linker 10 (VS2010; imports MSVCR100/MSVCP100)
+- PDB reference `F:\work\Project\Output\Exe\Agent_Release_x64.pdb` (GUID a4775113-…, age 1) — PDB not available; names are Ghidra defaults
+- Ghidra 12.1.2 via REA 6.5.0; 6,814 procedures, 1,472 defined strings (`ev_9fe3a449…`)
+- Full Evidence: `evidence-bundle.json` (14 records). Static analysis only — nothing here was observed at runtime.
+
+## Status: first pass (process-control core). Network protocol and config parsing not yet decompiled.
+
+## Language: C++ (high confidence)
+Observed C++-only artifacts: MSVC RTTI type descriptors (`.?AV…@@`, incl. templates
+`MBISingleton<T>`, `CFastArray<T>`), vftables, `__CxxFrameHandler3` (C++ EH),
+`operator new/delete`, MSVCP100 `std::basic_ostream` imports. Multiple vftables
+per class (e.g. `MagiAgentNetwork`, `MGAgentManagerSession`) indicate multiple
+inheritance. Statically linked C++ libraries: ProudNet, TinyXML (`TiXml*`), ATL.
+
+## Outputs
+| Path | Content |
+|---|---|
+| `full/functions/<addr>.c` | Ghidra pseudocode for all 6,423 non-thunk functions (1 failed; see `full/index.tsv`). Includes library code (ProudNet, TinyXML, CRT) — not yet labelled. |
+| `full/index.tsv` | address, namespace, name, body size, decompile status |
+| `full/vtables.tsv` | 1,430 RTTI vftable slots → function addresses (all classes) |
+| `cpp/classes.hpp` | Generated C++ skeleton of 43 application classes from vftables (compiles); method names unknown |
+| `cpp/AgentProcessControl.cpp` | Hand-lifted C++ for the 6 analyzed functions; names inferred, not compilable as-is |
+| `../scripts/ExportDecomp.java`, `VTableMap.java` | Ghidra headless scripts that produced `full/` |
+
+Additional observations from the lift (`cpp/AgentProcessControl.cpp`):
+- Watcher thread never closes the process handle → handle leak per launch (observed).
+- `LaunchProcess` passes a stack `PROCESS_INFORMATION*` to the watcher thread; safe only because of the following `Sleep(1000)` (observed race, inference about intent).
+- `KillProcessByName` leaks the snapshot handle on the success path (observed).
+- RMI stubs give the protocol handler tables: `AgentManager2AgentStub` 24 slots, `Server2AgentStub` 19 (`full/vtables.tsv`).
+
+## Findings
+
+| # | Conclusion | Type | Evidence |
+|---|---|---|---|
+| 1 | Process supervisor for the other server EXEs: launches them, kills them, watches for exit | **Observed** (code) | `0x1400094e0`, `0x140009780`, `0x140008c90` below |
+| 2 | Launch: `CreateProcessW(NULL, cmdline, …, CREATE_NEW_CONSOLE (0x10), …, workdir, …)`; console 700×110, fill attr 0x17; closes thread handle, spawns watcher thread, returns PID (0 on failure, logs `=======Server Fail=======` + Path/File) | Observed | `0x1400094e0.pseudo.c`, `ev_e77cf4b5…` |
+| 3 | Command line = `<exe path for server type> + " " + <args>`; args either generated (`FUN_140027540`, a global option flag at `+0x152` selects) or the numeric server code. Logs `FAILED SERVER ON %s` on failure; reports result to AgentManager via RMI proxy | Observed (flow); arg contents **unknown** | `0x140008ea0.pseudo.c`, `ev_e87b1dd7…` |
+| 4 | Kill: Toolhelp32 snapshot, case-insensitive exe-name match, `OpenProcess(PROCESS_TERMINATE)`, `TerminateProcess(h,0)` — kills the **first** match only, by image name (not PID) | Observed | `0x140009780.pseudo.c`, `ev_ad71d730…` |
+| 5 | Watcher: polls `GetExitCodeProcess` every 10 ms while `STILL_ACTIVE` (0x103); on exit sends two RMI notifications to AgentManager; **relaunches** if per-server revive flag (`+0xd5`) or global flag (`+0x171`) is set | Observed; mapping of flags to `revive_server` XML key is **inference** | `0x140008c90.pseudo.c` |
+| 6 | Single instance via named mutex `Global\RustyHearts_Agent`; on ERROR_ALREADY_EXISTS / ACCESS_DENIED prints, sleeps 3 s, returns failure | Observed | `0x1400100b0.pseudo.c` |
+| 7 | Main run loop: startup banner, `CoInitialize`, builds network objects, kills a stale process by name before running (type `0x18` entry), loop `Sleep(1)` with 100 ms tick and 1 s FPS counter; optional delayed "Start Auto Server On" after a configured time (`+0x178`) | Observed | `0x1400037a0.pseudo.c`, `ev_2fa3bc1d…` |
+| 8 | Networking is **ProudNet** (Nettention) — `Proud::CNetServerImpl`, `CNetClientImpl`, RMI stubs/proxies | Observed (RTTI + assert strings) | strings `ev_47e1666c…` |
+| 9 | Agent is both a ProudNet server (for game servers: `SERVER2AGENT_PROTOCOL` stub, `AGENT2SERVER` proxy) and client of AgentManager (`AGENTMANAGER2AGENT` stub, `AGENT2AGENTMANAGER` proxy) | Inference from RTTI class names | strings `ev_47e1666c…` |
+| 10 | Config files: `option\agent_serveroption.xml`, `option\agent.xml`, `option\total_option.xml`, `option\patch.xml`, `option\customoption.xml`, `option\service_control.xml` | Observed (strings); which are actually read is **unknown** — `option\agent.xml` referenced from `FUN_1400f06e0` only | `ev_d4bb4bc3…` |
+| 11 | Crash reporting via BugTrap (`BT_*` imports) + `MiniDumpWriteDump`; also an HTTP error reporter `GET /PNReport/ReportError.php?Text=` (ProudNet's) | Observed (imports/strings); host contacted **unknown** | imports |
+
+## Named-function map (proposed, not applied in a persistent DB)
+
+| Address | Proposed name |
+|---|---|
+| `0x1400037a0` | `MagiAgentServer::Run` (main loop) |
+| `0x140008ea0` | `ServerOn(serverEntry)` |
+| `0x1400094e0` | `LaunchProcess(cmdline) -> pid` |
+| `0x140008c90` | `ProcessWatchThread` |
+| `0x140009780` | `KillProcessByName(name)` |
+| `0x1400100b0` | `AcquireSingleInstanceMutex` |
+
+## Open questions / next steps
+- Decode RMI message IDs/handlers for `AGENTMANAGER2AGENT` and `SERVER2AGENT` (commands: All Server On/Down/Kill, Server Info, Shutdown, Notice, Patch).
+- Parse config XML loaders (`FUN_1400f06e0`, `MagiServerOption`), and map fields (`start_server`, `revive_server`, ports) to struct offsets.
+- Identify `FUN_140027540` (argument builder) to learn exact launch arguments.
+- Locate ProudNet SDK version to label library code (likely large share of the 6,814 functions).

decomp/Agent_Release_x64/full/functions/0x140001020.c

@@ -0,0 +1,15 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001020 FUN_140001020
+ * Pseudocode, not original source. */
+
+exception * FUN_140001020(exception *param_1,uint param_2)
+
+{
+  *(undefined ***)param_1 = std::bad_alloc::vftable;
+  std::exception::~exception(param_1);
+  if ((param_2 & 1) != 0) {
+    operator_delete(param_1);
+  }
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001060.c

@@ -0,0 +1,65 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001060 FUN_140001060
+ * Pseudocode, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+
+undefined8 FUN_140001060(longlong param_1)
+
+{
+  PCONSOLE_SCREEN_BUFFER_INFO lpConsoleScreenBufferInfo;
+  DWORD DVar1;
+  BOOL BVar2;
+  wchar_t *pwVar3;
+  wchar_t *pwVar4;
+  ulonglong uVar5;
+  HANDLE pvVar6;
+  undefined1 auStack_268 [32];
+  undefined8 local_248;
+  undefined8 local_240;
+  WCHAR local_228;
+  undefined1 local_226 [526];
+  ulonglong local_18;
+  
+  local_18 = DAT_1401555a0 ^ (ulonglong)auStack_268;
+  DVar1 = GetCurrentProcessId();
+  *(DWORD *)(param_1 + 0x450) = DVar1;
+  local_228 = L'\0';
+  memset(local_226,0,0x206);
+  DVar1 = GetModuleFileNameW((HMODULE)0x0,&local_228,0x104);
+  if (0 < (int)DVar1) {
+    pwVar3 = wcsrchr(&local_228,L'\\');
+    pwVar4 = wcsrchr(&local_228,L'.');
+    uVar5 = (longlong)pwVar4 + (-2 - (longlong)pwVar3) >> 1;
+    if (0x104 < uVar5) {
+      uVar5 = 0x104;
+    }
+    memcpy((void *)(param_1 + 0x3c),pwVar3 + 1,uVar5 * 2);
+    FUN_140001260(param_1,param_1 + 0x3c);
+    pvVar6 = GetStdHandle(0xfffffff5);
+    *(HANDLE *)(param_1 + 8) = pvVar6;
+    if (pvVar6 != (HANDLE)0xffffffffffffffff) {
+      FUN_1400011d0(param_1);
+      pvVar6 = *(HANDLE *)(param_1 + 8);
+      if (pvVar6 != (HANDLE)0xffffffffffffffff) {
+        lpConsoleScreenBufferInfo = (PCONSOLE_SCREEN_BUFFER_INFO)(param_1 + 0x10);
+        local_248 = 0;
+        local_240 = 0;
+        (lpConsoleScreenBufferInfo->dwSize).X = 0;
+        (lpConsoleScreenBufferInfo->dwSize).Y = 0;
+        (lpConsoleScreenBufferInfo->dwCursorPosition).X = 0;
+        (lpConsoleScreenBufferInfo->dwCursorPosition).Y = 0;
+        *(undefined8 *)(param_1 + 0x18) = 0;
+        *(undefined4 *)(param_1 + 0x20) = 0;
+        *(undefined2 *)(param_1 + 0x24) = 0;
+        BVar2 = GetConsoleScreenBufferInfo(pvVar6,lpConsoleScreenBufferInfo);
+        if (BVar2 != 0) {
+          *(undefined2 *)(param_1 + 0x454) = *(undefined2 *)(param_1 + 0x18);
+        }
+      }
+      return 1;
+    }
+  }
+  return 0;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400011d0.c

@@ -0,0 +1,26 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400011d0 FUN_1400011d0
+ * Pseudocode, not original source. */
+
+BOOL FUN_1400011d0(longlong param_1)
+
+{
+  BOOL BVar1;
+  DWORD local_res10 [2];
+  
+  if (*(HANDLE *)(param_1 + 8) == (HANDLE)0xffffffffffffffff) {
+    return 0;
+  }
+  BVar1 = GetConsoleScreenBufferInfo
+                    (*(HANDLE *)(param_1 + 8),(PCONSOLE_SCREEN_BUFFER_INFO)(param_1 + 0x26));
+  if (BVar1 == 0) {
+    return 0;
+  }
+  FillConsoleOutputAttribute
+            (*(HANDLE *)(param_1 + 8),*(ushort *)(param_1 + 0x2e) & 0xf | 0x10,
+             (int)*(short *)(param_1 + 0x28) * (int)*(short *)(param_1 + 0x26),(COORD)0x0,
+             local_res10);
+  BVar1 = SetConsoleTextAttribute(*(HANDLE *)(param_1 + 8),0x17);
+  return BVar1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001260.c

@@ -0,0 +1,30 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001260 FUN_140001260
+ * Pseudocode, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+
+void FUN_140001260(longlong param_1,longlong param_2)
+
+{
+  longlong lVar1;
+  ulonglong uVar2;
+  undefined1 auStack_248 [32];
+  wchar_t local_228;
+  undefined1 local_226 [526];
+  ulonglong local_18;
+  
+  local_18 = DAT_1401555a0 ^ (ulonglong)auStack_248;
+  uVar2 = (ulonglong)*(uint *)(param_1 + 0x450);
+  lVar1 = param_1 + 0x3c;
+  if (param_2 != 0) {
+    lVar1 = param_2;
+  }
+  FUN_140001af0((wchar_t *)(param_1 + 0x246),L"%s [%d]",lVar1,uVar2);
+  local_228 = L'\0';
+  memset(local_226,0,0x206);
+  FUN_140001ac0(&local_228,L"%s",(wchar_t *)(param_1 + 0x246),uVar2);
+  SetConsoleTitleW(&local_228);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001300.c

@@ -0,0 +1,15 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001300 FUN_140001300
+ * Pseudocode, not original source. */
+
+undefined8 * FUN_140001300(undefined8 *param_1,byte param_2)
+
+{
+  DAT_1401626f0 = 0;
+  *param_1 = MBISingleton<CConsoleControl>::vftable;
+  if ((param_2 & 1) != 0) {
+    operator_delete(param_1);
+  }
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001340.c

@@ -0,0 +1,13 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001340 FUN_140001340
+ * Pseudocode, not original source. */
+
+void FUN_140001340(undefined8 param_1,undefined8 param_2,undefined8 param_3)
+
+{
+  FUN_1400de9f0(DAT_1401626e8,L"Invalid parameter detected in function %s. File: %s Line: %d\n",
+                param_2,param_3);
+  FUN_1400de9f0(DAT_1401626e8,L"Expression: %s\n",param_1,param_3);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001390.c

@@ -0,0 +1,89 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001390 FUN_140001390
+ * Pseudocode, not original source. */
+
+/* WARNING: Function: __chkstk replaced with injection: alloca_probe */
+
+undefined8 FUN_140001390(int param_1,longlong param_2,undefined8 param_3,uint *param_4)
+
+{
+  short sVar1;
+  undefined4 uVar2;
+  DWORD DVar3;
+  _invalid_parameter_handler _Handler;
+  undefined8 *puVar4;
+  ulonglong uVar5;
+  undefined8 **ProcessHeaps;
+  LPCWSTR pWVar6;
+  short *psVar7;
+  undefined8 **ppuVar8;
+  undefined8 **HeapInformation;
+  undefined8 *local_res18;
+  undefined8 local_res20;
+  undefined8 *local_2028;
+  undefined1 local_2020 [8192];
+  undefined8 uStack_20;
+  
+  uStack_20 = 0x14000139e;
+  DAT_140162cc0 = timeGetTime();
+  FUN_140010070(&local_res20);
+  uVar2 = FUN_1400100b0(&local_res20);
+  if ((char)uVar2 != '\0') {
+    FUN_140010120();
+    FUN_140001550();
+    FUN_140001060((longlong)DAT_1401626f0);
+    if (1 < param_1) {
+      uVar5 = 0xffffffffffffffff;
+      psVar7 = *(short **)(param_2 + 8);
+      do {
+        if (uVar5 == 0) break;
+        uVar5 = uVar5 - 1;
+        sVar1 = *psVar7;
+        psVar7 = psVar7 + 1;
+      } while (sVar1 != 0);
+      FUN_1400016e0((ulonglong *)&DAT_14015b048,*(short **)(param_2 + 8),~uVar5 - 1);
+    }
+    puVar4 = (undefined8 *)0x0;
+    local_2028 = (undefined8 *)0x0;
+    HeapInformation = (undefined8 **)0x2000;
+    memset(local_2020,0,0x2000);
+    ProcessHeaps = &local_2028;
+    DVar3 = GetProcessHeaps(0x400,ProcessHeaps);
+    if (DVar3 != 0) {
+      ppuVar8 = &local_2028;
+      uVar5 = (ulonglong)DVar3;
+      do {
+        local_res18 = (undefined8 *)CONCAT44(local_res18._4_4_,2);
+        param_4 = (uint *)0x4;
+        HeapInformation = &local_res18;
+        ProcessHeaps = (undefined8 **)0x0;
+        HeapSetInformation(*ppuVar8,HeapCompatibilityInformation,HeapInformation,4);
+        ppuVar8 = ppuVar8 + 1;
+        uVar5 = uVar5 - 1;
+      } while (uVar5 != 0);
+    }
+    _Handler = _set_invalid_parameter_handler(FUN_140001340);
+    local_res18 = operator_new(0xb0);
+    if (local_res18 != (undefined8 *)0x0) {
+      puVar4 = FUN_140003360(local_res18,ProcessHeaps,HeapInformation,param_4);
+    }
+    pWVar6 = (LPCWSTR)&DAT_14015b048;
+    if (7 < DAT_14015b060) {
+      pWVar6 = DAT_14015b048;
+    }
+    DAT_1401626f8 = puVar4;
+    FUN_1400034a0(pWVar6,ProcessHeaps,HeapInformation,param_4);
+    FUN_1400037a0((longlong)DAT_1401626f8,ProcessHeaps,HeapInformation,param_4);
+    FUN_1400036c0((longlong)DAT_1401626f8);
+    if (DAT_1401626f8 != (undefined8 *)0x0) {
+      (**(code **)*DAT_1401626f8)(DAT_1401626f8,1);
+    }
+    if (DAT_1401626f0 != (undefined8 *)0x0) {
+      (**(code **)*DAT_1401626f0)(DAT_1401626f0,1);
+    }
+    _set_invalid_parameter_handler(_Handler);
+  }
+  FUN_140010080(&local_res20);
+  return 0;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001550.c

@@ -0,0 +1,32 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001550 FUN_140001550
+ * Pseudocode, not original source. */
+
+void FUN_140001550(void)
+
+{
+  undefined8 *puVar1;
+  
+  puVar1 = operator_new(0x458);
+  if (puVar1 != (undefined8 *)0x0) {
+    puVar1[2] = 0;
+    *(undefined8 *)((longlong)puVar1 + 0x26) = 0;
+    puVar1[3] = 0;
+    *(undefined8 *)((longlong)puVar1 + 0x2e) = 0;
+    *(undefined4 *)(puVar1 + 4) = 0;
+    *(undefined4 *)((longlong)puVar1 + 0x36) = 0;
+    *(undefined2 *)((longlong)puVar1 + 0x24) = 0;
+    *(undefined2 *)((longlong)puVar1 + 0x3a) = 0;
+    *puVar1 = CConsoleControl::vftable;
+    puVar1[1] = 0xffffffffffffffff;
+    *(undefined4 *)(puVar1 + 0x8a) = 0;
+    memset((void *)((longlong)puVar1 + 0x3c),0,0x20a);
+    memset((void *)((longlong)puVar1 + 0x246),0,0x20a);
+    DAT_1401626f0 = puVar1;
+    *(undefined2 *)((longlong)puVar1 + 0x454) = 0x17;
+    return;
+  }
+  DAT_1401626f0 = (undefined8 *)0x0;
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001600.c

@@ -0,0 +1,48 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001600 FUN_140001600
+ * Pseudocode, not original source. */
+
+longlong * FUN_140001600(longlong *param_1,longlong *param_2,ulonglong param_3,ulonglong param_4)
+
+{
+  code *pcVar1;
+  char cVar2;
+  longlong *plVar3;
+  ulonglong uVar4;
+  
+  if (param_3 <= (ulonglong)param_2[2]) {
+    uVar4 = param_2[2] - param_3;
+    if (param_4 < uVar4) {
+      uVar4 = param_4;
+    }
+    if (param_1 == param_2) {
+      FUN_1400017d0(param_1,uVar4 + param_3,0xffffffffffffffff);
+      FUN_1400017d0(param_1,0,param_3);
+    }
+    else {
+      cVar2 = FUN_140001870(param_1,uVar4);
+      if (cVar2 != '\0') {
+        if (7 < (ulonglong)param_2[3]) {
+          param_2 = (longlong *)*param_2;
+        }
+        plVar3 = param_1;
+        if (7 < (ulonglong)param_1[3]) {
+          plVar3 = (longlong *)*param_1;
+        }
+        memcpy(plVar3,(void *)((longlong)param_2 + param_3 * 2),uVar4 * 2);
+        param_1[2] = uVar4;
+        plVar3 = param_1;
+        if (7 < (ulonglong)param_1[3]) {
+          plVar3 = (longlong *)*param_1;
+        }
+        *(undefined2 *)((longlong)plVar3 + uVar4 * 2) = 0;
+      }
+    }
+    return param_1;
+  }
+  std::_Xout_of_range("invalid string position");
+  pcVar1 = (code *)swi(3);
+  plVar3 = (longlong *)(*pcVar1)();
+  return plVar3;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400016e0.c

@@ -0,0 +1,51 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400016e0 FUN_1400016e0
+ * Pseudocode, not original source. */
+
+ulonglong * FUN_1400016e0(ulonglong *param_1,void *param_2,ulonglong param_3)
+
+{
+  ulonglong uVar1;
+  char cVar2;
+  ulonglong *puVar3;
+  
+  if (param_2 != (void *)0x0) {
+    uVar1 = param_1[3];
+    puVar3 = param_1;
+    if (7 < uVar1) {
+      puVar3 = (ulonglong *)*param_1;
+    }
+    if (puVar3 <= param_2) {
+      puVar3 = param_1;
+      if (7 < uVar1) {
+        puVar3 = (ulonglong *)*param_1;
+      }
+      if (param_2 < (void *)((longlong)puVar3 + param_1[2] * 2)) {
+        puVar3 = param_1;
+        if (7 < uVar1) {
+          puVar3 = (ulonglong *)*param_1;
+        }
+        puVar3 = (ulonglong *)
+                 FUN_140001600((longlong *)param_1,(longlong *)param_1,
+                               (longlong)param_2 - (longlong)puVar3 >> 1,param_3);
+        return puVar3;
+      }
+    }
+  }
+  cVar2 = FUN_140001870(param_1,param_3);
+  if (cVar2 != '\0') {
+    puVar3 = param_1;
+    if (7 < param_1[3]) {
+      puVar3 = (ulonglong *)*param_1;
+    }
+    memcpy(puVar3,param_2,param_3 * 2);
+    param_1[2] = param_3;
+    puVar3 = param_1;
+    if (7 < param_1[3]) {
+      puVar3 = (ulonglong *)*param_1;
+    }
+    *(undefined2 *)(param_3 * 2 + (longlong)puVar3) = 0;
+  }
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400017d0.c

@@ -0,0 +1,43 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400017d0 FUN_1400017d0
+ * Pseudocode, not original source. */
+
+undefined8 * FUN_1400017d0(undefined8 *param_1,ulonglong param_2,ulonglong param_3)
+
+{
+  longlong lVar1;
+  code *pcVar2;
+  undefined8 *puVar3;
+  undefined8 *puVar4;
+  ulonglong uVar5;
+  
+  if ((ulonglong)param_1[2] < param_2) {
+    std::_Xout_of_range("invalid string position");
+    pcVar2 = (code *)swi(3);
+    puVar3 = (undefined8 *)(*pcVar2)();
+    return puVar3;
+  }
+  uVar5 = param_1[2] - param_2;
+  if (uVar5 < param_3) {
+    param_3 = uVar5;
+  }
+  if (param_3 != 0) {
+    puVar4 = param_1;
+    puVar3 = param_1;
+    if (7 < (ulonglong)param_1[3]) {
+      puVar4 = (undefined8 *)*param_1;
+      puVar3 = (undefined8 *)*param_1;
+    }
+    memmove((void *)((longlong)puVar4 + param_2 * 2),
+            (void *)((longlong)puVar3 + (param_2 + param_3) * 2),(uVar5 - param_3) * 2);
+    lVar1 = param_1[2];
+    param_1[2] = lVar1 - param_3;
+    puVar3 = param_1;
+    if (7 < (ulonglong)param_1[3]) {
+      puVar3 = (undefined8 *)*param_1;
+    }
+    *(undefined2 *)((longlong)puVar3 + (lVar1 - param_3) * 2) = 0;
+  }
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001870.c

@@ -0,0 +1,30 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001870 FUN_140001870
+ * Pseudocode, not original source. */
+
+undefined1 FUN_140001870(undefined8 *param_1,ulonglong param_2)
+
+{
+  code *pcVar1;
+  undefined1 uVar2;
+  
+  if (0x7ffffffffffffffe < param_2) {
+    std::_Xlength_error("string too long");
+    pcVar1 = (code *)swi(3);
+    uVar2 = (*pcVar1)();
+    return uVar2;
+  }
+  if ((ulonglong)param_1[3] < param_2) {
+    FUN_1400018f0(param_1,param_2,param_1[2]);
+    return param_2 != 0;
+  }
+  if (param_2 == 0) {
+    param_1[2] = 0;
+    if (7 < (ulonglong)param_1[3]) {
+      param_1 = (undefined8 *)*param_1;
+    }
+    *(undefined2 *)param_1 = 0;
+  }
+  return param_2 != 0;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400018f0.c

@@ -0,0 +1,55 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400018f0 FUN_1400018f0
+ * Pseudocode, not original source. */
+
+void FUN_1400018f0(undefined8 *param_1,ulonglong param_2,longlong param_3)
+
+{
+  ulonglong uVar1;
+  undefined8 *_Dst;
+  ulonglong uVar2;
+  undefined8 *_Src;
+  ulonglong uVar3;
+  char *local_res20;
+  undefined **local_40 [3];
+  
+  uVar3 = param_2 | 7;
+  if (uVar3 < 0x7fffffffffffffff) {
+    uVar1 = param_1[3];
+    uVar2 = uVar1 >> 1;
+    param_2 = uVar3;
+    if ((uVar3 / 3 < uVar2) && (param_2 = uVar2 + uVar1, 0x7ffffffffffffffe - uVar2 < uVar1)) {
+      param_2 = 0x7ffffffffffffffe;
+    }
+  }
+  uVar3 = param_2 + 1;
+  _Dst = (undefined8 *)0x0;
+  if ((uVar3 != 0) &&
+     ((0x7fffffffffffffff < uVar3 || (_Dst = operator_new(uVar3 * 2), _Dst == (undefined8 *)0x0))))
+  {
+    local_res20 = (char *)0x0;
+    std::exception::exception((exception *)local_40,&local_res20);
+    local_40[0] = std::bad_alloc::vftable;
+                    /* WARNING: Subroutine does not return */
+    _CxxThrowException(local_40,(ThrowInfo *)&DAT_140151ad0);
+  }
+  if (param_3 != 0) {
+    _Src = param_1;
+    if (7 < (ulonglong)param_1[3]) {
+      _Src = (undefined8 *)*param_1;
+    }
+    memcpy(_Dst,_Src,param_3 * 2);
+  }
+  if (7 < (ulonglong)param_1[3]) {
+    operator_delete((void *)*param_1);
+  }
+  *param_1 = _Dst;
+  param_1[3] = param_2;
+  param_1[2] = param_3;
+  if (7 < param_2) {
+    param_1 = _Dst;
+  }
+  *(undefined2 *)((longlong)param_1 + param_3 * 2) = 0;
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001a50.c

@@ -0,0 +1,25 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001a50 FUN_140001a50
+ * Pseudocode, not original source. */
+
+void * FUN_140001a50(ulonglong param_1)
+
+{
+  void *pvVar1;
+  char *local_res8 [4];
+  undefined **local_28 [5];
+  
+  if (param_1 == 0) {
+    return (void *)0x0;
+  }
+  if ((param_1 < 0x8000000000000000) && (pvVar1 = operator_new(param_1 * 2), pvVar1 != (void *)0x0))
+  {
+    return pvVar1;
+  }
+  local_res8[0] = (char *)0x0;
+  std::exception::exception((exception *)local_28,local_res8);
+  local_28[0] = std::bad_alloc::vftable;
+                    /* WARNING: Subroutine does not return */
+  _CxxThrowException(local_28,(ThrowInfo *)&DAT_140151ad0);
+}
+

decomp/Agent_Release_x64/full/functions/0x140001ac0.c

@@ -0,0 +1,16 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001ac0 FUN_140001ac0
+ * Pseudocode, not original source. */
+
+void FUN_140001ac0(wchar_t *param_1,wchar_t *param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  undefined8 local_res18;
+  undefined8 local_res20;
+  
+  local_res18 = param_3;
+  local_res20 = param_4;
+  vswprintf_s(param_1,0x104,param_2,(va_list)&local_res18);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001af0.c

@@ -0,0 +1,16 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001af0 FUN_140001af0
+ * Pseudocode, not original source. */
+
+void FUN_140001af0(wchar_t *param_1,wchar_t *param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  undefined8 local_res18;
+  undefined8 local_res20;
+  
+  local_res18 = param_3;
+  local_res20 = param_4;
+  vswprintf_s(param_1,0x105,param_2,(va_list)&local_res18);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001b20.c

@@ -0,0 +1,12 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001b20 FUN_140001b20
+ * Pseudocode, not original source. */
+
+exception * FUN_140001b20(exception *param_1,exception *param_2)
+
+{
+  std::exception::exception(param_1,param_2);
+  *(undefined ***)param_1 = std::bad_alloc::vftable;
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001b50.c

@@ -0,0 +1,20 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001b50 FUN_140001b50
+ * Pseudocode, not original source. */
+
+undefined8 * FUN_140001b50(undefined8 *param_1,uint param_2)
+
+{
+  *param_1 = MagiServerBase::vftable;
+  if ((void *)param_1[2] != (void *)0x0) {
+    operator_delete((void *)param_1[2]);
+  }
+  param_1[2] = 0;
+  param_1[3] = 0;
+  param_1[4] = 0;
+  if ((param_2 & 1) != 0) {
+    operator_delete(param_1);
+  }
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001bb0.c

@@ -0,0 +1,17 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001bb0 FUN_140001bb0
+ * Pseudocode, not original source. */
+
+void FUN_140001bb0(undefined8 *param_1)
+
+{
+  *param_1 = MagiServerBase::vftable;
+  if ((void *)param_1[2] != (void *)0x0) {
+    operator_delete((void *)param_1[2]);
+  }
+  param_1[2] = 0;
+  param_1[3] = 0;
+  param_1[4] = 0;
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001bf0.c

@@ -0,0 +1,29 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001bf0 FUN_140001bf0
+ * Pseudocode, not original source. */
+
+void FUN_140001bf0(longlong param_1)
+
+{
+  FUN_140001ce0(param_1,0x15);
+  FUN_140001ce0(param_1,0xd);
+  FUN_140001ce0(param_1,0xc);
+  FUN_140001ce0(param_1,0x11);
+  FUN_140001ce0(param_1,0x12);
+  FUN_140001ce0(param_1,0x13);
+  FUN_140001ce0(param_1,10);
+  FUN_140001ce0(param_1,6);
+  FUN_140001ce0(param_1,0xb);
+  FUN_140001ce0(param_1,9);
+  FUN_140001ce0(param_1,7);
+  FUN_140001ce0(param_1,8);
+  FUN_140001ce0(param_1,5);
+  FUN_140001ce0(param_1,1);
+  FUN_140001ce0(param_1,2);
+  FUN_140001ce0(param_1,3);
+                    /* WARNING: Could not recover jumptable at 0x000140001cd2. Too many branches */
+                    /* WARNING: Treating indirect jump as call */
+  wprintf(L"\n------------------------------------------------------------------------------\n");
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001ce0.c

@@ -0,0 +1,53 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001ce0 FUN_140001ce0
+ * Pseudocode, not original source. */
+
+void FUN_140001ce0(longlong param_1,uint param_2)
+
+{
+  int iVar1;
+  longlong *plVar2;
+  ulonglong uVar3;
+  ulonglong uVar4;
+  ulonglong uVar5;
+  longlong lVar6;
+  ulonglong uVar7;
+  
+  uVar3 = 0;
+  iVar1 = (int)(*(longlong *)(param_1 + 0x18) - *(longlong *)(param_1 + 0x10) >> 3);
+  if (0 < iVar1) {
+    plVar2 = *(longlong **)(param_1 + 0x10);
+    uVar4 = uVar3;
+    uVar5 = uVar3;
+    lVar6 = (longlong)iVar1;
+    uVar7 = uVar3;
+    do {
+      if ((*plVar2 != 0) && (*(byte *)(*plVar2 + 0x40) == param_2)) {
+        uVar5 = (ulonglong)((int)uVar5 + 1);
+        uVar7 = uVar4;
+      }
+      uVar4 = (ulonglong)((int)uVar4 + 1);
+      plVar2 = plVar2 + 1;
+      lVar6 = lVar6 + -1;
+    } while (lVar6 != 0);
+    if ((int)uVar5 != 0) {
+      uVar4 = uVar3;
+      if ((int)uVar5 < 2) {
+        FUN_1400026f0((*(longlong **)(param_1 + 0x10))[(int)uVar7],-1);
+      }
+      else {
+        do {
+          if ((*(longlong *)(*(longlong *)(param_1 + 0x10) + uVar3 * 8) != 0) &&
+             (lVar6 = *(longlong *)(*(longlong *)(param_1 + 0x10) + uVar3 * 8),
+             *(byte *)(lVar6 + 0x40) == param_2)) {
+            FUN_1400026f0(lVar6,(int)uVar4);
+            uVar4 = (ulonglong)((int)uVar4 + 1);
+          }
+          uVar3 = uVar3 + 1;
+        } while ((longlong)uVar3 < (longlong)iVar1);
+      }
+    }
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001dc0.c

@@ -0,0 +1,28 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001dc0 FUN_140001dc0
+ * Pseudocode, not original source. */
+
+void FUN_140001dc0(longlong param_1)
+
+{
+  longlong lVar1;
+  bool bVar2;
+  undefined4 local_res8 [8];
+  
+  bVar2 = DAT_140162cc0 != 0;
+  local_res8[0] = 5;
+  *(undefined4 *)(param_1 + 8) = 5;
+  if (bVar2) {
+    printf("********************************\n");
+    timeGetTime();
+    printf("** Server Load Time : %d sec\n");
+    printf("********************************\n");
+  }
+  printf("STEP : SERVER_RUN \n");
+  lVar1 = *(longlong *)(param_1 + 0x30);
+  if ((lVar1 != 0) && (*(char *)(lVar1 + 0x1a) != '\0')) {
+    (**(code **)(*(longlong *)(lVar1 + 0x68) + 0xb0))(lVar1 + 0x68,1,&DAT_1401555d0,local_res8);
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001e70.c

@@ -0,0 +1,38 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001e70 FUN_140001e70
+ * Pseudocode, not original source. */
+
+void FUN_140001e70(longlong *param_1)
+
+{
+  code *pcVar1;
+  ulonglong uVar2;
+  ulonglong uVar3;
+  
+  uVar3 = param_1[1] - *param_1 >> 3;
+  if (0x1ffffffffffffffe < uVar3) {
+    std::_Xlength_error("vector<T> too long");
+    pcVar1 = (code *)swi(3);
+    (*pcVar1)();
+    return;
+  }
+  uVar3 = uVar3 + 1;
+  uVar2 = param_1[2] - *param_1 >> 3;
+  if (uVar2 < uVar3) {
+    if (0x1fffffffffffffff - (uVar2 >> 1) < uVar2) {
+      uVar2 = 0;
+      if (uVar3 != 0) {
+        uVar2 = uVar3;
+      }
+      FUN_140001f00(param_1,uVar2);
+      return;
+    }
+    uVar2 = uVar2 + (uVar2 >> 1);
+    if (uVar2 < uVar3) {
+      uVar2 = uVar3;
+    }
+    FUN_140001f00(param_1,uVar2);
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140001f00.c

@@ -0,0 +1,45 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140001f00 FUN_140001f00
+ * Pseudocode, not original source. */
+
+void FUN_140001f00(longlong *param_1,ulonglong param_2)
+
+{
+  void *pvVar1;
+  longlong lVar2;
+  code *pcVar3;
+  char *pcVar4;
+  char *local_res10;
+  undefined **local_20 [3];
+  
+  if (0x1fffffffffffffff < param_2) {
+    std::_Xlength_error("vector<T> too long");
+    pcVar3 = (code *)swi(3);
+    (*pcVar3)();
+    return;
+  }
+  if ((ulonglong)(param_1[2] - *param_1 >> 3) < param_2) {
+    local_res10 = (char *)0x0;
+    if (param_2 != 0) {
+      local_res10 = operator_new(param_2 * 8);
+      if (local_res10 == (char *)0x0) {
+        std::exception::exception((exception *)local_20,&local_res10);
+        local_20[0] = std::bad_alloc::vftable;
+                    /* WARNING: Subroutine does not return */
+        _CxxThrowException(local_20,(ThrowInfo *)&DAT_140151ad0);
+      }
+    }
+    pcVar4 = local_res10;
+    memmove(local_res10,(void *)*param_1,param_1[1] - *param_1 & 0xfffffffffffffff8);
+    pvVar1 = (void *)*param_1;
+    lVar2 = param_1[1];
+    if (pvVar1 != (void *)0x0) {
+      operator_delete(pvVar1);
+    }
+    param_1[2] = (longlong)(pcVar4 + param_2 * 8);
+    param_1[1] = (longlong)(pcVar4 + (lVar2 - (longlong)pvVar1 >> 3) * 8);
+    *param_1 = (longlong)pcVar4;
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140002010.c

@@ -0,0 +1,30 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140002010 FUN_140002010
+ * Pseudocode, not original source. */
+
+undefined8 *
+FUN_140002010(undefined8 *param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  *(undefined2 *)(param_1 + 1) = 0;
+  *param_1 = MagiCommonSession::vftable;
+  param_1[2] = 0;
+  *(undefined4 *)(param_1 + 3) = 0x1000001;
+  *(undefined1 *)((longlong)param_1 + 0x1c) = 1;
+  param_1[4] = 0;
+  param_1[5] = 0x4008000000000000;
+  FUN_140030200(param_1,param_2,param_3,param_4);
+  param_1[6] = PTR_DAT_140155010;
+  *(undefined8 *)((longlong)param_1 + 0x3c) = 0;
+  if ((DAT_14016319c & 1) == 0) {
+    DAT_14016319c = DAT_14016319c | 1;
+    FUN_1400de360();
+    atexit((_func_5014 *)&LAB_1400f13a0);
+  }
+  if (DAT_140162f60 == 1000) {
+    *(undefined1 *)((longlong)param_1 + 0x1c) = 0;
+    param_1[5] = 0x4024000000000000;
+  }
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400020d0.c

@@ -0,0 +1,18 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400020d0 FUN_1400020d0
+ * Pseudocode, not original source. */
+
+undefined8 *
+FUN_1400020d0(undefined8 *param_1,ulonglong param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  *param_1 = MagiCommonSession::vftable;
+  FUN_140003240(param_1 + 6,param_2,param_3,param_4);
+  *param_1 = Proud::INetClientEvent::vftable;
+  FUN_14003b5c0(param_1);
+  if ((param_2 & 1) != 0) {
+    operator_delete(param_1);
+  }
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140002130.c

@@ -0,0 +1,14 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140002130 FUN_140002130
+ * Pseudocode, not original source. */
+
+void FUN_140002130(undefined8 *param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  *param_1 = MagiCommonSession::vftable;
+  FUN_140003240(param_1 + 6,param_2,param_3,param_4);
+  *param_1 = Proud::INetClientEvent::vftable;
+  FUN_14003b5c0(param_1);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140002180.c

@@ -0,0 +1,108 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140002180 FUN_140002180
+ * Pseudocode, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
+
+void FUN_140002180(longlong param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  char cVar1;
+  undefined *puVar2;
+  int *piVar3;
+  int *piVar4;
+  undefined **ppuVar5;
+  int *piVar6;
+  undefined8 *puVar7;
+  undefined *puVar8;
+  undefined1 auStack_b8 [32];
+  int *local_98;
+  undefined1 local_90;
+  int *local_88;
+  undefined1 local_80;
+  undefined8 local_78;
+  undefined *local_68;
+  undefined2 local_60;
+  undefined4 local_5c;
+  undefined4 local_58;
+  undefined4 local_54;
+  undefined4 local_50;
+  undefined8 local_48 [6];
+  ulonglong local_18;
+  
+  local_78 = 0xfffffffffffffffe;
+  local_18 = DAT_1401555a0 ^ (ulonglong)auStack_b8;
+  puVar2 = *(undefined **)(param_1 + 0x30);
+  if ((((puVar2 != (undefined *)0x0) && (puVar2 != PTR_DAT_140155010)) &&
+      (0 < *(int *)(puVar2 + -8))) &&
+     (((*(char *)(param_1 + 0x18) != '\0' && (*(char *)(param_1 + 0x19) == '\0')) &&
+      ((*(char *)(param_1 + 0x1a) == '\0' && (*(longlong *)(param_1 + 0x10) != 0)))))) {
+    *(undefined2 *)(param_1 + 0x19) = 1;
+    ppuVar5 = &local_68;
+    FUN_14003b600(ppuVar5,param_2,param_3,param_4);
+    local_5c = DAT_140162d38;
+    local_58 = _DAT_140162d3c;
+    local_54 = _DAT_140162d40;
+    local_50 = _DAT_140162d44;
+    if (local_68 == (undefined *)0x0) {
+      local_68 = PTR_DAT_140155010;
+    }
+    if (*(undefined **)(param_1 + 0x30) != local_68) {
+      piVar3 = (int *)FUN_140030200(ppuVar5,param_2,param_3,param_4);
+      piVar6 = piVar3;
+      local_88 = piVar3;
+      FUN_14002e6e0(piVar3);
+      puVar2 = local_68;
+      local_80 = 1;
+      if (((local_68 != (undefined *)0x0) && (local_68 != PTR_DAT_140155010)) &&
+         (puVar8 = local_68 + -8, puVar8 != (undefined *)0x0)) {
+        piVar4 = (int *)FUN_140030200(piVar6,param_2,param_3,param_4);
+        local_98 = piVar4;
+        FUN_14002e6e0(piVar4);
+        local_90 = 1;
+        piVar6 = (int *)(puVar2 + -4);
+        *piVar6 = *piVar6 + -1;
+        if (*piVar6 == 0) {
+          FUN_1400302f0(puVar8);
+        }
+        FUN_14002e770((longlong)piVar4);
+      }
+      local_68 = *(undefined **)(param_1 + 0x30);
+      if (((local_68 != PTR_DAT_140155010) && (local_68 != (undefined *)0x0)) &&
+         (local_68 != (undefined *)0x8)) {
+        *(int *)(local_68 + -4) = *(int *)(local_68 + -4) + 1;
+      }
+      FUN_14002e770((longlong)piVar3);
+    }
+    local_60 = *(undefined2 *)(param_1 + 0x38);
+    (**(code **)(**(longlong **)(param_1 + 0x10) + 0x88))();
+    ppuVar5 = &local_68;
+    (**(code **)(**(longlong **)(param_1 + 0x10) + 0x78))();
+    cVar1 = *(char *)(param_1 + 0x19);
+    while (cVar1 != '\0') {
+      Sleep(10);
+      ppuVar5 = (undefined **)0x0;
+      (**(code **)(**(longlong **)(param_1 + 0x10) + 0x98))();
+      cVar1 = *(char *)(param_1 + 0x19);
+    }
+    puVar7 = local_48;
+    FUN_14003b870(puVar7);
+    puVar2 = local_68;
+    if (((local_68 != (undefined *)0x0) && (local_68 != PTR_DAT_140155010)) &&
+       (puVar8 = local_68 + -8, puVar8 != (undefined *)0x0)) {
+      piVar3 = (int *)FUN_140030200(puVar7,ppuVar5,param_3,param_4);
+      local_98 = piVar3;
+      FUN_14002e6e0(piVar3);
+      local_90 = 1;
+      piVar6 = (int *)(puVar2 + -4);
+      *piVar6 = *piVar6 + -1;
+      if (*piVar6 == 0) {
+        FUN_1400302f0(puVar8);
+      }
+      FUN_14002e770((longlong)piVar3);
+    }
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400023b0.c

@@ -0,0 +1,12 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400023b0 FUN_1400023b0
+ * Pseudocode, not original source. */
+
+void FUN_1400023b0(longlong *param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  FUN_14003b870(param_1 + 4);
+  FUN_140003240(param_1,param_2,param_3,param_4);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400023e0.c

@@ -0,0 +1,55 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400023e0 FUN_1400023e0
+ * Pseudocode, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+
+void FUN_1400023e0(longlong param_1)
+
+{
+  undefined2 *puVar1;
+  undefined *puVar2;
+  ulonglong uVar3;
+  undefined1 auStack_68 [32];
+  undefined8 local_48;
+  undefined2 local_40;
+  undefined6 uStack_3e;
+  undefined8 local_30;
+  ulonglong local_28;
+  ulonglong local_18;
+  
+  local_48 = 0xfffffffffffffffe;
+  local_18 = DAT_1401555a0 ^ (ulonglong)auStack_68;
+  puVar2 = *(undefined **)(param_1 + 0x30);
+  if ((((puVar2 != (undefined *)0x0) && (puVar2 != PTR_DAT_140155010)) &&
+      (0 < *(int *)(puVar2 + -8))) && (*(char *)(param_1 + 0x18) != '\0')) {
+    if (*(char *)(param_1 + 0x1b) == '\0') {
+      if ((*(char *)(param_1 + 0x1a) != '\0') && (*(longlong *)(param_1 + 0x10) != 0)) {
+        (**(code **)(**(longlong **)(param_1 + 0x10) + 0x98))(*(longlong **)(param_1 + 0x10),0);
+      }
+    }
+    else if (*(char *)(param_1 + 0x1c) != '\0') {
+      Sleep((DWORD)(longlong)*(double *)(param_1 + 0x28));
+      local_28 = 7;
+      local_30 = 0;
+      local_40 = 0;
+      FUN_140002990(param_1,(ulonglong *)&local_40);
+      puVar2 = *(undefined **)(param_1 + 0x30);
+      if (*(undefined **)(param_1 + 0x30) == (undefined *)0x0) {
+        puVar2 = PTR_DAT_140155010;
+      }
+      puVar1 = &local_40;
+      if (7 < local_28) {
+        puVar1 = (undefined2 *)CONCAT62(uStack_3e,local_40);
+      }
+      uVar3 = (ulonglong)*(ushort *)(param_1 + 0x38);
+      wprintf(L"%s : RETRY CONNECT : IP[ %s ] PORT[ %d ]\n");
+      FUN_140002180(param_1,puVar1,puVar2,uVar3);
+      if (7 < local_28) {
+        operator_delete((void *)CONCAT62(uStack_3e,local_40));
+      }
+    }
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400024f0.c

@@ -0,0 +1,70 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400024f0 FUN_1400024f0
+ * Pseudocode, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+
+void FUN_1400024f0(longlong param_1,double param_2)
+
+{
+  longlong *plVar1;
+  undefined2 *puVar2;
+  undefined *puVar3;
+  ulonglong uVar4;
+  double dVar5;
+  undefined1 auStack_68 [32];
+  undefined8 local_48;
+  undefined2 local_40;
+  undefined6 uStack_3e;
+  undefined8 local_30;
+  ulonglong local_28;
+  ulonglong local_18;
+  
+  local_48 = 0xfffffffffffffffe;
+  local_18 = DAT_1401555a0 ^ (ulonglong)auStack_68;
+  puVar3 = *(undefined **)(param_1 + 0x30);
+  if (((puVar3 != (undefined *)0x0) && (puVar3 != PTR_DAT_140155010)) && (0 < *(int *)(puVar3 + -8))
+     ) {
+    if (*(char *)(param_1 + 0x18) == '\0') {
+      if (*(char *)(param_1 + 0x1a) != '\0') {
+        plVar1 = *(longlong **)(param_1 + 0x10);
+        if (plVar1 != (longlong *)0x0) {
+          (**(code **)(*plVar1 + 0x98))(plVar1,0);
+        }
+        Sleep(100);
+      }
+    }
+    else if (*(char *)(param_1 + 0x1b) == '\0') {
+      if ((*(char *)(param_1 + 0x1a) != '\0') &&
+         (plVar1 = *(longlong **)(param_1 + 0x10), plVar1 != (longlong *)0x0)) {
+        (**(code **)(*plVar1 + 0x98))(plVar1,0);
+      }
+    }
+    else {
+      dVar5 = param_2 - *(double *)(param_1 + 0x20);
+      if ((*(double *)(param_1 + 0x28) <= dVar5 && dVar5 != *(double *)(param_1 + 0x28)) &&
+         (*(double *)(param_1 + 0x20) = param_2, *(char *)(param_1 + 0x1c) != '\0')) {
+        local_28 = 7;
+        local_30 = 0;
+        local_40 = 0;
+        FUN_140002990(param_1,(ulonglong *)&local_40);
+        puVar3 = *(undefined **)(param_1 + 0x30);
+        if (*(undefined **)(param_1 + 0x30) == (undefined *)0x0) {
+          puVar3 = PTR_DAT_140155010;
+        }
+        puVar2 = &local_40;
+        if (7 < local_28) {
+          puVar2 = (undefined2 *)CONCAT62(uStack_3e,local_40);
+        }
+        uVar4 = (ulonglong)*(ushort *)(param_1 + 0x38);
+        wprintf(L"%s : RETRY CONNECT : ADDRESS[ %s ] PORT[ %d ]\n");
+        FUN_140002180(param_1,puVar2,puVar3,uVar4);
+        if (7 < local_28) {
+          operator_delete((void *)CONCAT62(uStack_3e,local_40));
+        }
+      }
+    }
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140002640.c

@@ -0,0 +1,35 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140002640 FUN_140002640
+ * Pseudocode, not original source. */
+
+void FUN_140002640(longlong param_1,undefined4 *param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  uint uVar1;
+  undefined *puVar2;
+  undefined **ppuVar3;
+  short *psVar4;
+  ulonglong uVar5;
+  undefined *local_res8;
+  undefined **local_res10;
+  
+  psVar4 = (short *)(param_2 + 0xc);
+  if (7 < *(ulonglong *)(param_2 + 0x12)) {
+    psVar4 = *(short **)psVar4;
+  }
+  FUN_140030200(param_1,param_2,param_3,param_4);
+  local_res8 = PTR_DAT_140155010;
+  uVar1 = FUN_140030080(psVar4);
+  puVar2 = FUN_140002f90((longlong *)&local_res8,uVar1);
+  uVar5 = (ulonglong)uVar1;
+  FUN_1400300b0(puVar2,psVar4,uVar1);
+  FUN_140003070((longlong *)&local_res8);
+  local_res10 = &local_res8;
+  ppuVar3 = &local_res8;
+  FUN_140003170((longlong *)(param_1 + 0x30),(longlong *)ppuVar3,uVar5,param_4);
+  FUN_140003240((longlong *)&local_res8,ppuVar3,uVar5,param_4);
+  *(undefined2 *)(param_1 + 0x38) = *(undefined2 *)(param_2 + 1);
+  *(undefined4 *)(param_1 + 0x3c) = *param_2;
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400026f0.c

@@ -0,0 +1,131 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400026f0 FUN_1400026f0
+ * Pseudocode, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+/* WARNING: Type propagation algorithm not settling */
+
+void FUN_1400026f0(longlong param_1,int param_2)
+
+{
+  ulonglong uVar1;
+  code *pcVar2;
+  undefined2 *puVar3;
+  undefined2 *puVar4;
+  wchar_t *pwVar5;
+  ulonglong uVar6;
+  undefined1 auStack_e8 [32];
+  uint local_c8;
+  uint local_c0;
+  undefined8 local_b8;
+  ulonglong local_b0 [2];
+  ulonglong local_a0;
+  ulonglong local_98;
+  undefined2 local_88;
+  undefined6 uStack_86;
+  undefined8 local_78;
+  ulonglong local_70;
+  ulonglong local_60 [2];
+  ulonglong local_50;
+  ulonglong local_48;
+  ulonglong local_38;
+  
+  local_b8 = 0xfffffffffffffffe;
+  local_38 = DAT_1401555a0 ^ (ulonglong)auStack_e8;
+  local_48 = 7;
+  local_50 = 0;
+  local_60[0]._0_2_ = 0;
+  local_70 = 7;
+  local_78 = 0;
+  local_88 = 0;
+  local_98 = 7;
+  local_a0 = 0;
+  local_b0[0]._0_2_ = 0;
+  FUN_140002990(param_1,local_60);
+  uVar6 = 0xffffffffffffffff;
+  if (local_50 != 0xffffffffffffffff) {
+    uVar6 = local_50;
+  }
+  if (-local_a0 - 1 <= uVar6) {
+    std::_Xlength_error("string too long");
+    pcVar2 = (code *)swi(3);
+    (*pcVar2)();
+    return;
+  }
+  if (uVar6 != 0) {
+    uVar1 = local_a0 + uVar6;
+    if (0x7ffffffffffffffe < uVar1) {
+      std::_Xlength_error("string too long");
+      pcVar2 = (code *)swi(3);
+      (*pcVar2)();
+      return;
+    }
+    if (local_98 < uVar1) {
+      FUN_1400018f0(local_b0,uVar1,local_a0);
+    }
+    else if (uVar1 == 0) {
+      local_a0 = 0;
+      puVar4 = (undefined2 *)local_b0;
+      if (7 < local_98) {
+        puVar4 = (undefined2 *)CONCAT62(local_b0[0]._2_6_,(undefined2)local_b0[0]);
+      }
+      *puVar4 = 0;
+    }
+    if (uVar1 != 0) {
+      puVar4 = (undefined2 *)local_60;
+      if (7 < local_48) {
+        puVar4 = (undefined2 *)CONCAT62(local_60[0]._2_6_,(undefined2)local_60[0]);
+      }
+      puVar3 = (undefined2 *)local_b0;
+      if (7 < local_98) {
+        puVar3 = (undefined2 *)CONCAT62(local_b0[0]._2_6_,(undefined2)local_b0[0]);
+      }
+      memcpy(puVar3 + local_a0,puVar4,uVar6 * 2);
+      puVar4 = (undefined2 *)local_b0;
+      if (7 < local_98) {
+        puVar4 = (undefined2 *)CONCAT62(local_b0[0]._2_6_,(undefined2)local_b0[0]);
+      }
+      local_a0 = uVar1;
+      puVar4[uVar1] = 0;
+    }
+  }
+  FUN_140002bc0(local_b0,9);
+  if (*(char *)(param_1 + 0x18) == '\0') {
+    uVar6 = 10;
+    pwVar5 = L"[ DisUse ]";
+  }
+  else {
+    uVar6 = 7;
+    pwVar5 = L"[ Use ]";
+  }
+  FUN_1400016e0((ulonglong *)&local_88,pwVar5,uVar6);
+  if (param_2 < 1) {
+    wprintf(L"\n-%s %s---------------------------------------------------------\n");
+  }
+  local_c8 = *(uint *)(param_1 + 0x3c);
+  if (param_2 == -1) {
+    wprintf(L"Session S[ %d ] : ADDRESS[ %s ] PORT[ %d ] CODE[ %d ]\n");
+  }
+  else {
+    local_c0 = local_c8;
+    local_c8 = (uint)*(ushort *)(param_1 + 0x38);
+    wprintf(L"Session [%d] S[ %d ] : ADDRESS[ %s ] PORT[ %d ] CODE[ %d ]\n");
+  }
+  if (7 < local_98) {
+    operator_delete((void *)CONCAT62(local_b0[0]._2_6_,(undefined2)local_b0[0]));
+  }
+  local_98 = 7;
+  local_a0 = 0;
+  local_b0[0]._0_2_ = 0;
+  if (7 < local_70) {
+    operator_delete((void *)CONCAT62(uStack_86,local_88));
+  }
+  local_70 = 7;
+  local_78 = 0;
+  local_88 = 0;
+  if (7 < local_48) {
+    operator_delete((void *)CONCAT62(local_60[0]._2_6_,(undefined2)local_60[0]));
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140002990.c

@@ -0,0 +1,71 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140002990 FUN_140002990
+ * Pseudocode, not original source. */
+
+void FUN_140002990(longlong param_1,ulonglong *param_2)
+
+{
+  wchar_t *pwVar1;
+  
+  switch(*(undefined1 *)(param_1 + 0x40)) {
+  case 1:
+    FUN_1400016e0(param_2,L"Lobby",5);
+    return;
+  case 2:
+    FUN_1400016e0(param_2,L"Dungeon",7);
+    return;
+  case 3:
+    FUN_1400016e0(param_2,&DAT_14011b3f0,3);
+    return;
+  case 4:
+    FUN_1400016e0(param_2,&DAT_14011b3f8,3);
+    return;
+  case 5:
+    FUN_1400016e0(param_2,L"Guild",5);
+    return;
+  case 6:
+    FUN_1400016e0(param_2,L"Message",7);
+    return;
+  case 7:
+    FUN_1400016e0(param_2,&DAT_14011b420,2);
+    return;
+  case 8:
+    FUN_1400016e0(param_2,L"Gate",4);
+    return;
+  case 9:
+    FUN_1400016e0(param_2,L"Manager",7);
+    return;
+  case 10:
+    FUN_1400016e0(param_2,L"Auction",7);
+    return;
+  case 0xb:
+    FUN_1400016e0(param_2,L"Match",5);
+    return;
+  case 0xc:
+    pwVar1 = L"DBC_GAME";
+    break;
+  case 0xd:
+    FUN_1400016e0(param_2,L"Agent",5);
+    return;
+  default:
+    goto switchD_1400029b9_caseD_d;
+  case 0x11:
+    FUN_1400016e0(param_2,L"DBC_LOG",7);
+    return;
+  case 0x12:
+    pwVar1 = L"DBC_CHAT";
+    break;
+  case 0x13:
+    FUN_1400016e0(param_2,L"DBC_EMERGENCY",0xd);
+    return;
+  case 0x15:
+    FUN_1400016e0(param_2,L"Agentmanager",0xc);
+    return;
+  case 0x16:
+    pwVar1 = L"MiniGame";
+  }
+  FUN_1400016e0(param_2,pwVar1,8);
+switchD_1400029b9_caseD_d:
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140002bc0.c

@@ -0,0 +1,59 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140002bc0 FUN_140002bc0
+ * Pseudocode, not original source. */
+
+ulonglong * FUN_140002bc0(ulonglong *param_1,ulonglong param_2)
+
+{
+  ulonglong uVar1;
+  code *pcVar2;
+  char cVar3;
+  ulonglong *puVar4;
+  
+  uVar1 = param_1[3];
+  puVar4 = param_1;
+  if (7 < uVar1) {
+    puVar4 = (ulonglong *)*param_1;
+  }
+  if (puVar4 < (ulonglong *)((longlong)L" Sessoion" + 1U)) {
+    puVar4 = param_1;
+    if (7 < uVar1) {
+      puVar4 = (ulonglong *)*param_1;
+    }
+    if (L" Sessoion" < (wchar_t *)((longlong)puVar4 + param_1[2] * 2)) {
+      puVar4 = param_1;
+      if (7 < uVar1) {
+        puVar4 = (ulonglong *)*param_1;
+      }
+      puVar4 = (ulonglong *)
+               FUN_140002cd0((longlong *)param_1,param_1,
+                             (longlong)L" Sessoion" - (longlong)puVar4 >> 1,param_2);
+      return puVar4;
+    }
+  }
+  if (param_2 < -param_1[2] - 1) {
+    if (param_2 != 0) {
+      uVar1 = param_1[2] + param_2;
+      cVar3 = FUN_140001870(param_1,uVar1);
+      if (cVar3 != '\0') {
+        puVar4 = param_1;
+        if (7 < param_1[3]) {
+          puVar4 = (ulonglong *)*param_1;
+        }
+        memcpy((void *)((longlong)puVar4 + param_1[2] * 2),L" Sessoion",param_2 * 2);
+        param_1[2] = uVar1;
+        puVar4 = param_1;
+        if (7 < param_1[3]) {
+          puVar4 = (ulonglong *)*param_1;
+        }
+        *(undefined2 *)((longlong)puVar4 + uVar1 * 2) = 0;
+      }
+    }
+    return param_1;
+  }
+  std::_Xlength_error("string too long");
+  pcVar2 = (code *)swi(3);
+  puVar4 = (ulonglong *)(*pcVar2)();
+  return puVar4;
+}
+

decomp/Agent_Release_x64/full/functions/0x140002cd0.c

@@ -0,0 +1,52 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140002cd0 FUN_140002cd0
+ * Pseudocode, not original source. */
+
+longlong * FUN_140002cd0(longlong *param_1,undefined8 *param_2,ulonglong param_3,ulonglong param_4)
+
+{
+  code *pcVar1;
+  char cVar2;
+  longlong *plVar3;
+  ulonglong uVar4;
+  
+  if ((ulonglong)param_2[2] < param_3) {
+    std::_Xout_of_range("invalid string position");
+    pcVar1 = (code *)swi(3);
+    plVar3 = (longlong *)(*pcVar1)();
+    return plVar3;
+  }
+  uVar4 = param_2[2] - param_3;
+  if (uVar4 < param_4) {
+    param_4 = uVar4;
+  }
+  if (param_4 < -param_1[2] - 1U) {
+    if (param_4 != 0) {
+      uVar4 = param_1[2] + param_4;
+      cVar2 = FUN_140001870(param_1,uVar4);
+      if (cVar2 != '\0') {
+        if (7 < (ulonglong)param_2[3]) {
+          param_2 = (undefined8 *)*param_2;
+        }
+        plVar3 = param_1;
+        if (7 < (ulonglong)param_1[3]) {
+          plVar3 = (longlong *)*param_1;
+        }
+        memcpy((void *)((longlong)plVar3 + param_1[2] * 2),(void *)((longlong)param_2 + param_3 * 2)
+               ,param_4 * 2);
+        param_1[2] = uVar4;
+        plVar3 = param_1;
+        if (7 < (ulonglong)param_1[3]) {
+          plVar3 = (longlong *)*param_1;
+        }
+        *(undefined2 *)((longlong)plVar3 + uVar4 * 2) = 0;
+      }
+    }
+    return param_1;
+  }
+  std::_Xlength_error("string too long");
+  pcVar1 = (code *)swi(3);
+  plVar3 = (longlong *)(*pcVar1)();
+  return plVar3;
+}
+

decomp/Agent_Release_x64/full/functions/0x140002dc0.c

@@ -0,0 +1,76 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140002dc0 FUN_140002dc0
+ * Pseudocode, not original source. */
+
+void FUN_140002dc0(longlong *param_1,int param_2)
+
+{
+  undefined *puVar1;
+  int *piVar2;
+  int iVar3;
+  undefined4 in_register_00000014;
+  undefined *puVar4;
+  undefined8 in_R8;
+  ulonglong uVar5;
+  undefined8 in_R9;
+  
+  puVar4 = PTR_DAT_140155010;
+  puVar1 = (undefined *)*param_1;
+  if ((undefined *)*param_1 == (undefined *)0x0) {
+    puVar1 = PTR_DAT_140155010;
+  }
+  *param_1 = (longlong)puVar1;
+  if (param_2 < 0) {
+                    /* WARNING: Subroutine does not return */
+    FUN_14002f590();
+  }
+  if (param_2 == 0) {
+    FUN_140003240(param_1,CONCAT44(in_register_00000014,param_2),in_R8,in_R9);
+    return;
+  }
+  iVar3 = 0;
+  if (puVar1 != (undefined *)0x0) {
+    if (puVar1 == puVar4) {
+      iVar3 = 0;
+    }
+    else {
+      iVar3 = *(int *)(puVar1 + -8);
+    }
+  }
+  if (param_2 != iVar3) {
+    piVar2 = (int *)FUN_140030280((longlong)param_2 * 2 + 10);
+    if (piVar2 != (int *)0x0) {
+      *piVar2 = 0;
+      piVar2[1] = 1;
+    }
+    puVar1 = PTR_DAT_140155010;
+    *piVar2 = param_2;
+    puVar4 = (undefined *)*param_1;
+    if (puVar4 == (undefined *)0x0) {
+      iVar3 = 0;
+    }
+    else if (puVar4 == puVar1) {
+      iVar3 = 0;
+    }
+    else {
+      iVar3 = *(int *)(puVar4 + -8);
+    }
+    if (iVar3 <= param_2) {
+      if ((puVar4 == (undefined *)0x0) || (puVar4 == puVar1)) {
+        param_2 = 0;
+      }
+      else {
+        param_2 = *(int *)(puVar4 + -8);
+      }
+    }
+    if (puVar4 == (undefined *)0x0) {
+      puVar4 = puVar1;
+    }
+    uVar5 = (ulonglong)(uint)param_2;
+    FUN_1400300b0(piVar2 + 2,puVar4,param_2);
+    FUN_140003240(param_1,puVar4,uVar5,in_R9);
+    *param_1 = (longlong)(piVar2 + 2);
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140002ea0.c

@@ -0,0 +1,73 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140002ea0 FUN_140002ea0
+ * Pseudocode, not original source. */
+
+void FUN_140002ea0(longlong *param_1)
+
+{
+  int iVar1;
+  undefined *puVar2;
+  undefined8 *puVar3;
+  uint *puVar4;
+  uint uVar5;
+  uint uVar6;
+  undefined *puVar7;
+  ulonglong uVar8;
+  undefined8 in_R9;
+  
+  puVar7 = (undefined *)*param_1;
+  if (puVar7 == (undefined *)0x0) {
+    *param_1 = (longlong)PTR_DAT_140155010;
+  }
+  else if ((puVar7 != PTR_DAT_140155010) && ((int *)(puVar7 + -8) != (int *)0x0)) {
+    if (*(int *)(puVar7 + -4) < 2) {
+      return;
+    }
+    iVar1 = *(int *)(puVar7 + -8);
+    if (iVar1 < 0) {
+                    /* WARNING: Subroutine does not return */
+      FUN_14002f590();
+    }
+    puVar4 = (uint *)FUN_140030280((longlong)iVar1 * 2 + 10);
+    uVar5 = 0;
+    if (puVar4 != (uint *)0x0) {
+      *puVar4 = 0;
+      puVar4[1] = 1;
+    }
+    puVar2 = PTR_DAT_140155010;
+    puVar7 = (undefined *)*param_1;
+    if (puVar7 == (undefined *)0x0) {
+      uVar6 = 0;
+    }
+    else {
+      uVar6 = uVar5;
+      if (puVar7 != PTR_DAT_140155010) {
+        uVar6 = *(uint *)(puVar7 + -8);
+      }
+    }
+    *puVar4 = uVar6;
+    puVar7 = (undefined *)*param_1;
+    if ((puVar7 != (undefined *)0x0) && (puVar7 != puVar2)) {
+      uVar5 = *(uint *)(puVar7 + -8);
+    }
+    if (puVar7 == (undefined *)0x0) {
+      puVar7 = puVar2;
+    }
+    uVar8 = (ulonglong)uVar5;
+    FUN_1400300b0(puVar4 + 2,puVar7,uVar5);
+    FUN_140003240(param_1,puVar7,uVar8,in_R9);
+    *param_1 = (longlong)(puVar4 + 2);
+    return;
+  }
+  puVar3 = (undefined8 *)FUN_140030280(10);
+  *puVar3 = 0;
+  *(undefined2 *)(puVar3 + 1) = 0;
+  if (puVar3 != (undefined8 *)0x0) {
+    *(undefined4 *)puVar3 = 0;
+    *(undefined4 *)((longlong)puVar3 + 4) = 1;
+  }
+  *(undefined2 *)(puVar3 + 1) = 0;
+  *param_1 = (longlong)(puVar3 + 1);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140002f90.c

@@ -0,0 +1,39 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140002f90 FUN_140002f90
+ * Pseudocode, not original source. */
+
+undefined * FUN_140002f90(longlong *param_1,int param_2)
+
+{
+  int iVar1;
+  undefined *puVar2;
+  int iVar3;
+  
+  puVar2 = (undefined *)*param_1;
+  iVar3 = 0;
+  if ((puVar2 != (undefined *)0x0) && (puVar2 != PTR_DAT_140155010)) {
+    iVar3 = *(int *)(puVar2 + -8);
+  }
+  if (((param_2 <= iVar3) && (param_2 = 0, puVar2 != (undefined *)0x0)) &&
+     (puVar2 != PTR_DAT_140155010)) {
+    param_2 = *(int *)(puVar2 + -8);
+  }
+  iVar3 = 1;
+  if (1 < param_2) {
+    iVar3 = param_2;
+  }
+  iVar1 = 0;
+  if ((puVar2 != (undefined *)0x0) && (iVar1 = 0, puVar2 != PTR_DAT_140155010)) {
+    iVar1 = *(int *)(puVar2 + -8);
+  }
+  if (iVar1 < iVar3) {
+    FUN_140002dc0(param_1,iVar3);
+  }
+  FUN_140002ea0(param_1);
+  puVar2 = (undefined *)*param_1;
+  if ((undefined *)*param_1 == (undefined *)0x0) {
+    puVar2 = PTR_DAT_140155010;
+  }
+  return puVar2;
+}
+

decomp/Agent_Release_x64/full/functions/0x140003010.c

@@ -0,0 +1,34 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140003010 FUN_140003010
+ * Pseudocode, not original source. */
+
+void FUN_140003010(longlong *param_1,int param_2)
+
+{
+  undefined *puVar1;
+  int iVar2;
+  int iVar3;
+  
+  puVar1 = (undefined *)*param_1;
+  iVar3 = 0;
+  if (0 < param_2) {
+    iVar3 = param_2;
+  }
+  iVar2 = 0;
+  if ((puVar1 != (undefined *)0x0) && (iVar2 = 0, puVar1 != PTR_DAT_140155010)) {
+    iVar2 = *(int *)(puVar1 + -8);
+  }
+  if ((iVar2 <= iVar3) && (iVar3 = 0, puVar1 != (undefined *)0x0)) {
+    if (puVar1 == PTR_DAT_140155010) {
+      return;
+    }
+    iVar3 = *(int *)(puVar1 + -8);
+  }
+  if (((puVar1 != PTR_DAT_140155010) && (puVar1 != (undefined *)0x0)) &&
+     ((int *)(puVar1 + -8) != (int *)0x0)) {
+    *(int *)(puVar1 + -8) = iVar3;
+    *(undefined2 *)(puVar1 + (longlong)iVar3 * 2) = 0;
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140003070.c

@@ -0,0 +1,40 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140003070 FUN_140003070
+ * Pseudocode, not original source. */
+
+void FUN_140003070(longlong *param_1)
+
+{
+  undefined *puVar1;
+  int iVar2;
+  int iVar3;
+  short *psVar4;
+  
+  psVar4 = (short *)*param_1;
+  if ((short *)*param_1 == (short *)0x0) {
+    psVar4 = (short *)PTR_DAT_140155010;
+  }
+  iVar2 = FUN_140030080(psVar4);
+  iVar3 = 0;
+  if (0 < iVar2) {
+    iVar3 = iVar2;
+  }
+  puVar1 = (undefined *)*param_1;
+  iVar2 = 0;
+  if ((puVar1 != (undefined *)0x0) && (iVar2 = 0, puVar1 != PTR_DAT_140155010)) {
+    iVar2 = *(int *)(puVar1 + -8);
+  }
+  if ((iVar2 <= iVar3) && (iVar3 = 0, puVar1 != (undefined *)0x0)) {
+    if (puVar1 == PTR_DAT_140155010) {
+      return;
+    }
+    iVar3 = *(int *)(puVar1 + -8);
+  }
+  if (((puVar1 != PTR_DAT_140155010) && (puVar1 != (undefined *)0x0)) &&
+     ((int *)(puVar1 + -8) != (int *)0x0)) {
+    *(int *)(puVar1 + -8) = iVar3;
+    *(undefined2 *)(puVar1 + (longlong)iVar3 * 2) = 0;
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400030f0.c

@@ -0,0 +1,26 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400030f0 FUN_1400030f0
+ * Pseudocode, not original source. */
+
+longlong * FUN_1400030f0(longlong *param_1,short *param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  int iVar1;
+  undefined *puVar2;
+  int iVar3;
+  int iVar4;
+  
+  FUN_140030200(param_1,param_2,param_3,param_4);
+  *param_1 = (longlong)PTR_DAT_140155010;
+  iVar1 = FUN_140030080(param_2);
+  iVar3 = (int)param_3;
+  iVar4 = iVar1;
+  if ((0 < iVar3) && (iVar4 = iVar3, iVar1 < iVar3)) {
+    iVar4 = iVar1;
+  }
+  puVar2 = FUN_140002f90(param_1,iVar4);
+  FUN_1400300b0(puVar2,param_2,iVar4);
+  FUN_140003070(param_1);
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140003170.c

@@ -0,0 +1,32 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140003170 FUN_140003170
+ * Pseudocode, not original source. */
+
+void FUN_140003170(longlong *param_1,longlong *param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  undefined *puVar1;
+  int *piVar2;
+  longlong *plVar3;
+  
+  puVar1 = (undefined *)*param_1;
+  if ((undefined *)*param_1 == (undefined *)0x0) {
+    puVar1 = PTR_DAT_140155010;
+  }
+  *param_1 = (longlong)puVar1;
+  if ((undefined *)*param_2 != puVar1) {
+    plVar3 = param_2;
+    piVar2 = (int *)FUN_140030200(param_1,param_2,param_3,param_4);
+    FUN_14002e6e0(piVar2);
+    FUN_140003240(param_1,plVar3,param_3,param_4);
+    puVar1 = (undefined *)*param_2;
+    *param_1 = (longlong)puVar1;
+    if (((puVar1 != PTR_DAT_140155010) && (puVar1 != (undefined *)0x0)) &&
+       (puVar1 != (undefined *)0x8)) {
+      *(int *)(puVar1 + -4) = *(int *)(puVar1 + -4) + 1;
+    }
+    FUN_14002e770((longlong)piVar2);
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140003210.c

@@ -0,0 +1,14 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140003210 FUN_140003210
+ * Pseudocode, not original source. */
+
+void FUN_140003210(longlong *param_1)
+
+{
+  if ((char)param_1[1] != '\0') {
+    FUN_14002e770(*param_1);
+    *(undefined1 *)(param_1 + 1) = 0;
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140003240.c

@@ -0,0 +1,30 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140003240 FUN_140003240
+ * Pseudocode, not original source. */
+
+void FUN_140003240(longlong *param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  int *piVar1;
+  undefined *puVar2;
+  int *piVar3;
+  
+  puVar2 = (undefined *)*param_1;
+  if (((puVar2 == (undefined *)0x0) || (puVar2 == PTR_DAT_140155010)) ||
+     (puVar2 + -8 == (undefined *)0x0)) {
+    *param_1 = (longlong)PTR_DAT_140155010;
+  }
+  else {
+    piVar3 = (int *)FUN_140030200(puVar2,param_2,param_3,param_4);
+    FUN_14002e6e0(piVar3);
+    piVar1 = (int *)(puVar2 + -4);
+    *piVar1 = *piVar1 + -1;
+    if (*piVar1 == 0) {
+      FUN_1400302f0(puVar2 + -8);
+    }
+    FUN_14002e770((longlong)piVar3);
+    *param_1 = (longlong)PTR_DAT_140155010;
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400032e0.c

@@ -0,0 +1,12 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400032e0 FUN_1400032e0
+ * Pseudocode, not original source. */
+
+void FUN_1400032e0(undefined8 *param_1)
+
+{
+  *param_1 = Proud::INetClientEvent::vftable;
+  FUN_14003b5c0(param_1);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400032f0.c

@@ -0,0 +1,14 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400032f0 FUN_1400032f0
+ * Pseudocode, not original source. */
+
+undefined8 * FUN_1400032f0(undefined8 *param_1,uint param_2)
+
+{
+  FUN_14003b5c0(param_1);
+  if ((param_2 & 1) != 0) {
+    operator_delete(param_1);
+  }
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140003320.c

@@ -0,0 +1,21 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140003320 std::bad_alloc::`scalar_deleting_destructor'
+ * Pseudocode, not original source. */
+
+/* Library Function - Single Match
+    public: virtual void * __ptr64 __cdecl std::bad_alloc::`scalar deleting destructor'(unsigned
+   int) __ptr64
+   
+   Libraries: Visual Studio 2012 Release, Visual Studio 2015 Release */
+
+void * __thiscall std::bad_alloc::_scalar_deleting_destructor_(bad_alloc *this,uint param_1)
+
+{
+  *(undefined ***)this = Proud::INetClientEvent::vftable;
+  FUN_14003b5c0((undefined8 *)this);
+  if ((param_1 & 1) != 0) {
+    operator_delete(this);
+  }
+  return this;
+}
+

decomp/Agent_Release_x64/full/functions/0x140003360.c

@@ -0,0 +1,31 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140003360 FUN_140003360
+ * Pseudocode, not original source. */
+
+undefined8 *
+FUN_140003360(undefined8 *param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  ulonglong uVar1;
+  undefined7 uVar2;
+  
+  uVar2 = (undefined7)((ulonglong)param_3 >> 8);
+  *(undefined4 *)(param_1 + 2) = 0;
+  param_1[3] = 0;
+  param_1[4] = 0;
+  param_1[5] = 0;
+  param_1[7] = 0;
+  param_1[8] = 0;
+  *param_1 = MagiAgentServer::vftable;
+  param_1[1] = MagiAgentServer::vftable;
+  *(undefined1 *)(param_1 + 9) = 0;
+  param_1[10] = 0;
+  param_1[0xb] = 0;
+  *(undefined1 *)(param_1 + 0xc) = 1;
+  uVar1 = FUN_14002e790();
+  FUN_14002e600((undefined4 *)(param_1 + 0xd),uVar1 & 0xffffffff,CONCAT71(uVar2,1),param_4);
+  param_1[0x14] = 0;
+  param_1[0x15] = 0;
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400033f0.c

@@ -0,0 +1,15 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400033f0 FUN_1400033f0
+ * Pseudocode, not original source. */
+
+undefined8 *
+FUN_1400033f0(undefined8 *param_1,ulonglong param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  FUN_140003420(param_1,param_2,param_3,param_4);
+  if ((param_2 & 1) != 0) {
+    operator_delete(param_1);
+  }
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140003420.c

@@ -0,0 +1,22 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140003420 FUN_140003420
+ * Pseudocode, not original source. */
+
+void FUN_140003420(undefined8 *param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  *param_1 = MagiAgentServer::vftable;
+  param_1[1] = MagiAgentServer::vftable;
+  FUN_14002e7a0((undefined4 *)(param_1 + 0xd),param_2,param_3,param_4);
+  param_1[1] = MagiServerBase::vftable;
+  if ((void *)param_1[3] != (void *)0x0) {
+    operator_delete((void *)param_1[3]);
+  }
+  param_1[3] = 0;
+  param_1[4] = 0;
+  param_1[5] = 0;
+  *param_1 = MBISingleton<MagiAgentServer>::vftable;
+  DAT_1401626f8 = 0;
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400034a0.c

@@ -0,0 +1,85 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400034a0 FUN_1400034a0
+ * Pseudocode, not original source. */
+
+void FUN_1400034a0(LPCWSTR param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  longlong lVar1;
+  char *pcVar2;
+  undefined8 *puVar3;
+  ulonglong uVar4;
+  undefined8 *puVar5;
+  wchar_t *pwVar6;
+  undefined8 uVar7;
+  
+  if ((DAT_14016319c & 1) == 0) {
+    DAT_14016319c = DAT_14016319c | 1;
+    FUN_1400de360();
+    atexit((_func_5014 *)&LAB_1400f13a0);
+    if ((DAT_14016319c & 1) == 0) {
+      DAT_14016319c = DAT_14016319c | 1;
+      FUN_1400de360();
+      atexit((_func_5014 *)&LAB_1400f13a0);
+    }
+  }
+  if ((DAT_140162f60 != 200) && (DAT_140162f60 != 100)) {
+    if ((DAT_14016319c & 1) == 0) {
+      DAT_14016319c = DAT_14016319c | 1;
+      FUN_1400de360();
+      atexit((_func_5014 *)&LAB_1400f13a0);
+    }
+    if (DAT_140162f60 != 1000) goto LAB_140003556;
+  }
+  setlocale(0,"kor");
+LAB_140003556:
+  pcVar2 = setlocale(0,(char *)0x0);
+  printf("Locale is: %s\n");
+  puVar3 = operator_new(0x60);
+  if (puVar3 == (undefined8 *)0x0) {
+    puVar3 = (undefined8 *)0x0;
+  }
+  else {
+    *puVar3 = MagiAgentProcess::vftable;
+    puVar3[1] = 0;
+    puVar3[2] = 0;
+    puVar3[3] = 0;
+    uVar4 = FUN_14002e790();
+    pcVar2 = (char *)(uVar4 & 0xffffffff);
+    param_3 = CONCAT71((int7)((ulonglong)param_3 >> 8),1);
+    FUN_14002e600((undefined4 *)(puVar3 + 5),(ulonglong)pcVar2,param_3,param_4);
+  }
+  DAT_140162d78 = puVar3;
+  puVar5 = operator_new(8);
+  puVar3 = (undefined8 *)0x0;
+  if (puVar5 != (undefined8 *)0x0) {
+    puVar3 = FUN_14002e1c0(puVar5,pcVar2,param_3,param_4);
+  }
+  lVar1 = DAT_140162d68;
+  DAT_140162d70 = puVar3;
+  *(undefined1 *)(DAT_140162d68 + 0x1e8) = 0xd;
+  FUN_1400227e0(lVar1,param_1,param_3,param_4);
+  _wmkdir(L"Log");
+  puVar5 = operator_new(0xe8);
+  puVar3 = (undefined8 *)0x0;
+  if (puVar5 != (undefined8 *)0x0) {
+    puVar3 = FUN_1400de890(puVar5);
+  }
+  DAT_1401626e8 = puVar3;
+  FUN_1400deb60((longlong)puVar3,param_1,param_3,param_4);
+  puVar3 = DAT_1401626e8;
+  EnterCriticalSection(DAT_140162d80);
+  uVar7 = 0x12;
+  pwVar6 = L"Log\\Protocol_Agent";
+  FUN_1400016e0(puVar3 + 3,L"Log\\Protocol_Agent",0x12);
+  LeaveCriticalSection(DAT_140162d80);
+  puVar3 = operator_new(0x98);
+  if (puVar3 == (undefined8 *)0x0) {
+    DAT_140162d50 = (undefined8 *)0x0;
+  }
+  else {
+    DAT_140162d50 = FUN_1400dc730(puVar3,pwVar6,uVar7,param_4);
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400036c0.c

@@ -0,0 +1,48 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400036c0 FUN_1400036c0
+ * Pseudocode, not original source. */
+
+void FUN_1400036c0(longlong param_1)
+
+{
+  FILE *_File;
+  undefined8 *puVar1;
+  longlong lVar2;
+  
+  puVar1 = *(undefined8 **)(param_1 + 0x50);
+  if (puVar1 != (undefined8 *)0x0) {
+    (**(code **)*puVar1)(puVar1,1);
+  }
+  puVar1 = DAT_140162d50;
+  *(undefined8 *)(param_1 + 0x50) = 0;
+  if (puVar1 != (undefined8 *)0x0) {
+    (**(code **)*puVar1)(puVar1,1);
+  }
+  if (DAT_140162d70 != (undefined8 *)0x0) {
+    (**(code **)*DAT_140162d70)(DAT_140162d70,1);
+  }
+  puVar1 = DAT_1401626e8;
+  EnterCriticalSection(DAT_140162d80);
+  _File = (FILE *)puVar1[0x17];
+  if (_File != (FILE *)0x0) {
+    fclose(_File);
+  }
+  puVar1 = puVar1 + 0x19;
+  lVar2 = 4;
+  do {
+    if ((FILE *)*puVar1 != (FILE *)0x0) {
+      fclose((FILE *)*puVar1);
+    }
+    puVar1 = puVar1 + 1;
+    lVar2 = lVar2 + -1;
+  } while (lVar2 != 0);
+  LeaveCriticalSection(DAT_140162d80);
+  if (DAT_1401626e8 != (undefined8 *)0x0) {
+    (**(code **)*DAT_1401626e8)(DAT_1401626e8,1);
+  }
+  if (DAT_140162d78 != (undefined8 *)0x0) {
+    (**(code **)*DAT_140162d78)(DAT_140162d78,1);
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400037a0.c

@@ -0,0 +1,385 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400037a0 FUN_1400037a0
+ * Pseudocode, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
+
+undefined8 FUN_1400037a0(longlong param_1,undefined8 **param_2,undefined8 *param_3,uint *param_4)
+
+{
+  int *piVar1;
+  double dVar2;
+  char cVar3;
+  undefined8 *puVar4;
+  undefined1 auVar5 [16];
+  bool bVar6;
+  bool bVar7;
+  longlong *plVar8;
+  BOOL BVar9;
+  wchar_t *pwVar10;
+  wchar_t *pwVar11;
+  ulonglong uVar12;
+  longlong *plVar13;
+  wchar_t *pwVar14;
+  char *pcVar15;
+  ulonglong *puVar16;
+  longlong *plVar17;
+  undefined2 *puVar18;
+  wchar_t *pwVar19;
+  longlong lVar20;
+  undefined4 uVar21;
+  undefined4 uVar22;
+  undefined4 uVar23;
+  undefined4 uVar24;
+  undefined4 uVar25;
+  undefined1 auStack_2a8 [32];
+  longlong *local_288;
+  wchar_t *local_280;
+  LARGE_INTEGER local_278;
+  undefined8 *local_270;
+  wchar_t *local_268;
+  wchar_t *local_260;
+  int *local_258;
+  undefined1 local_250;
+  undefined8 local_248;
+  undefined2 local_238;
+  undefined1 local_236 [158];
+  undefined1 local_198 [160];
+  undefined8 *local_f8;
+  undefined2 local_f0;
+  undefined6 uStack_ee;
+  undefined8 local_e0;
+  ulonglong local_d8;
+  undefined2 local_c8;
+  undefined6 uStack_c6;
+  undefined8 local_b8;
+  ulonglong local_b0;
+  ulonglong local_98;
+  
+  local_248 = 0xfffffffffffffffe;
+  local_98 = DAT_1401555a0 ^ (ulonglong)auStack_2a8;
+  FUN_140010960(L"# Agent Startup #\n\n",param_2,param_3,param_4);
+  CoInitialize((LPVOID)0x0);
+  FUN_140010aa0(L"+ Prepare Startup\n",param_2,param_3,param_4);
+  local_278 = (LARGE_INTEGER)operator_new(0xb8);
+  pwVar19 = (wchar_t *)0x0;
+  pwVar10 = pwVar19;
+  if ((undefined8 *)local_278.QuadPart != (undefined8 *)0x0) {
+    pwVar10 = (wchar_t *)FUN_140005020((undefined8 *)local_278,param_2,param_3,param_4);
+  }
+  if (pwVar10 == (wchar_t *)0x0) {
+    local_288 = (longlong *)0x0;
+  }
+  else {
+    local_288 = (longlong *)FUN_140030280(0x10);
+    local_288[1] = 1;
+    *local_288 = (longlong)pwVar10;
+  }
+  plVar17 = local_288;
+  pwVar11 = operator_new(0x68);
+  pwVar10 = pwVar19;
+  local_280 = pwVar11;
+  if (pwVar11 != (wchar_t *)0x0) {
+    if (plVar17 != (longlong *)0x0) {
+      pwVar10 = (wchar_t *)*plVar17;
+    }
+    *(wchar_t **)pwVar11 = pwVar10;
+    pwVar11[4] = L'\0';
+    pwVar11[5] = L'\0';
+    pwVar11[6] = L'\0';
+    pwVar11[7] = L'\0';
+    pwVar11[8] = L'\0';
+    pwVar11[9] = L'\0';
+    pwVar11[10] = L'\0';
+    pwVar11[0xb] = L'\0';
+    pwVar11[0xc] = L'\0';
+    pwVar11[0xd] = L'\0';
+    pwVar11[0xe] = L'\0';
+    pwVar11[0xf] = L'\0';
+    uVar12 = FUN_14002e790();
+    param_2 = (undefined8 **)(uVar12 & 0xffffffff);
+    param_3 = (undefined8 *)CONCAT71((int7)((ulonglong)param_3 >> 8),1);
+    FUN_14002e600((undefined4 *)(pwVar11 + 0x14),(ulonglong)param_2,param_3,param_4);
+    FUN_140007960((longlong)pwVar11);
+    pwVar10 = pwVar11;
+  }
+  if (pwVar10 == (wchar_t *)0x0) {
+    local_280 = (wchar_t *)0x0;
+  }
+  else {
+    local_280 = (wchar_t *)FUN_140030280(0x10);
+    *(undefined8 *)((longlong)local_280 + 8) = 1;
+    *(wchar_t **)local_280 = pwVar10;
+  }
+  pwVar10 = local_280;
+  pwVar11 = pwVar19;
+  if (plVar17 != (longlong *)0x0) {
+    pwVar11 = (wchar_t *)*plVar17;
+  }
+  *(wchar_t **)(param_1 + 0xa0) = pwVar11;
+  pwVar11 = pwVar19;
+  if (local_280 != (wchar_t *)0x0) {
+    pwVar11 = *(wchar_t **)local_280;
+  }
+  *(wchar_t **)(param_1 + 0xa8) = pwVar11;
+  pwVar11 = pwVar19;
+  if (local_280 != (wchar_t *)0x0) {
+    pwVar11 = *(wchar_t **)local_280;
+  }
+  FUN_140007960((longlong)pwVar11);
+  local_f8 = (undefined8 *)0x0;
+  local_d8 = 7;
+  local_e0 = 0;
+  local_f0 = 0;
+  local_b0 = 7;
+  local_b8 = 0;
+  local_c8 = 0;
+  if (*(longlong *)(DAT_140162d68 + 0x1c8) != 0) {
+    auVar5._8_8_ = 0;
+    auVar5._0_8_ = *(ulonglong *)(DAT_140162d68 + 0x1b0);
+    param_2 = SUB168((ZEXT816(0) << 0x40 | ZEXT816(0x15)) % auVar5,0);
+    local_270 = (undefined8 *)(*(longlong *)(DAT_140162d68 + 0x1a8) + (longlong)param_2 * 8);
+    for (local_268 = (wchar_t *)*local_270; local_268 != (wchar_t *)0x0;
+        local_268 = *(wchar_t **)local_268) {
+      if ((char)local_268[4] == '\x15') {
+        if (local_268 != (wchar_t *)0x0) goto LAB_1400039c4;
+        break;
+      }
+    }
+  }
+  local_270 = (undefined8 *)0x0;
+  local_268 = pwVar19;
+LAB_1400039c4:
+  if ((local_268 != (wchar_t *)0x0) &&
+     (puVar4 = *(undefined8 **)(local_268 + 8), puVar4 != *(undefined8 **)(local_268 + 0xc))) {
+    local_f8 = (undefined8 *)*puVar4;
+    FUN_140001600((longlong *)&local_f0,puVar4 + 1,0,0xffffffffffffffff);
+    param_4 = (uint *)0xffffffffffffffff;
+    param_3 = (undefined8 *)0x0;
+    FUN_140001600((longlong *)&local_c8,puVar4 + 6,0,0xffffffffffffffff);
+    param_2 = &local_f8;
+    FUN_140007a80(*(undefined8 **)(param_1 + 0xa8),param_2,param_3,(undefined8 *)param_4);
+    lVar20 = *(longlong *)(param_1 + 0xa8);
+    piVar1 = (int *)(lVar20 + 0x28);
+    local_258 = piVar1;
+    FUN_14002e6e0(piVar1);
+    plVar13 = *(longlong **)(lVar20 + 8);
+    if (*plVar13 == 0) {
+      FUN_14002e770((longlong)piVar1);
+      local_250 = 0;
+    }
+    else {
+      lVar20 = *plVar13;
+      FUN_14002e770((longlong)piVar1);
+      local_250 = 0;
+      if (lVar20 != 0) {
+        cVar3 = *(char *)(lVar20 + 0x88);
+        while (cVar3 == '\0') {
+          FUN_1400023e0(lVar20);
+          cVar3 = *(char *)(lVar20 + 0x88);
+        }
+      }
+    }
+  }
+  pwVar11 = pwVar19;
+  if (plVar17 != (longlong *)0x0) {
+    pwVar11 = (wchar_t *)*plVar17;
+  }
+  FUN_140005360((longlong)pwVar11,param_2,param_3,(longlong)param_4);
+  pwVar11 = pwVar19;
+  if (plVar17 != (longlong *)0x0) {
+    pwVar11 = (wchar_t *)*plVar17;
+  }
+  *(undefined8 *)(pwVar11 + 0x24) = *(undefined8 *)(param_1 + 0xa8);
+  FUN_140010960(L"\n # Agent Running... #\n",param_2,param_3,param_4);
+  plVar13 = operator_new(0x18);
+  if (plVar13 == (longlong *)0x0) {
+    plVar13 = (longlong *)0x0;
+  }
+  else {
+    *plVar13 = (longlong)TimeSourceHRWin32::vftable;
+    BVar9 = QueryPerformanceFrequency(&local_278);
+    if (BVar9 == 0) {
+      *(undefined1 *)(plVar13 + 2) = 0;
+      GetLastError();
+    }
+    else {
+      *(undefined1 *)(plVar13 + 2) = 1;
+      plVar13[1] = (longlong)(1.0 / (double)local_278.QuadPart);
+    }
+  }
+  plVar8 = DAT_140162d50;
+  if ((undefined8 *)DAT_140162d50[2] != (undefined8 *)0x0) {
+    (*(code *)**(undefined8 **)DAT_140162d50[2])();
+  }
+  plVar8[2] = (longlong)plVar13;
+  if (plVar13 != (longlong *)0x0) {
+    lVar20 = (**(code **)(*plVar13 + 8))(plVar13);
+    plVar8[6] = lVar20;
+    plVar8[7] = lVar20;
+  }
+  plVar8[0x12] = 0x3ff0000000000000;
+  pwVar14 = operator_new(0x28);
+  pwVar11 = pwVar19;
+  local_260 = pwVar14;
+  if (pwVar14 != (wchar_t *)0x0) {
+    *(undefined ***)pwVar14 = Magi::Timer::vftable;
+    plVar13 = DAT_140162d50;
+    *(longlong **)(pwVar14 + 4) = DAT_140162d50;
+    pwVar14[8] = L'\0';
+    pwVar14[9] = L'\0';
+    pwVar14[10] = L'\0';
+    pwVar14[0xb] = L'\0';
+    pwVar14[0xc] = L'\0';
+    pwVar14[0xd] = L'\0';
+    pwVar14[0xe] = L'\0';
+    pwVar14[0xf] = L'\0';
+    *(undefined1 *)(pwVar14 + 0x10) = 0;
+    pwVar14[0x12] = L'\0';
+    pwVar14[0x13] = L'㾀';
+    (**(code **)(*plVar13 + 0x10))();
+    pwVar11 = pwVar14;
+  }
+  *(wchar_t **)(param_1 + 0x50) = pwVar11;
+  bVar6 = true;
+  local_238 = 0;
+  memset(local_236,0,0x9e);
+  puVar16 = (ulonglong *)0x0;
+  puVar18 = (undefined2 *)0xa0;
+  memset(local_198,0,0xa0);
+  uVar21 = 0;
+  uVar23 = 0;
+  FUN_1400271e0(DAT_140162d68);
+  pcVar15 = *(char **)(DAT_140162d58 + 8);
+  do {
+    pwVar11 = pwVar19;
+    if (pcVar15 == *(char **)(DAT_140162d58 + 0x10)) {
+LAB_140003c4a:
+      FUN_140009780(pwVar11);
+      FUN_140001dc0(param_1 + 8);
+      bVar7 = false;
+      cVar3 = *(char *)(param_1 + 0x60);
+      uVar24 = uVar21;
+      uVar25 = uVar23;
+      while (cVar3 != '\0') {
+        FUN_1400dc520((longlong)DAT_140162d50);
+        dVar2 = *(double *)(*(longlong *)(param_1 + 0x50) + 0x10);
+        if (((0.0 < *(double *)(DAT_140162d68 + 0x178)) &&
+            (0.0 < dVar2 - *(double *)(DAT_140162d68 + 0x178))) && (bVar6)) {
+          bVar6 = false;
+          pcVar15 = "Start Auto Server On. \n";
+          printf("Start Auto Server On. \n");
+          FUN_140009bd0(pcVar15,puVar16,puVar18,param_4);
+        }
+        FUN_140007da0(*(longlong *)(param_1 + 0xa8),dVar2);
+        uVar22 = (undefined4)((ulonglong)dVar2 >> 0x20);
+        if (1.0 <= dVar2 - (double)CONCAT44(uVar23,uVar21)) {
+          if (DAT_140162cc4 != 0) {
+            puVar16 = (ulonglong *)&DAT_14011b7b4;
+            if (bVar7) {
+              puVar16 = (ulonglong *)&DAT_14011b7b0;
+            }
+            puVar18 = (undefined2 *)(ulonglong)DAT_140162cc8;
+            printf("[ %s ] FPS[ %d ]\n");
+            bVar7 = !bVar7;
+          }
+          _DAT_140162ccc = DAT_140162cc8;
+          DAT_140162cc8 = 0;
+          uVar21 = SUB84(dVar2,0);
+          uVar23 = uVar22;
+        }
+        if (0.10000000149011612 <= dVar2 - (double)CONCAT44(uVar25,uVar24)) {
+          DAT_140162cc8 = DAT_140162cc8 + 1;
+          FUN_140003f30(param_1,puVar16,puVar18,param_4);
+          pwVar11 = pwVar19;
+          if (plVar17 != (longlong *)0x0) {
+            pwVar11 = (wchar_t *)*plVar17;
+          }
+          FUN_1400053e0((longlong)pwVar11,dVar2);
+          uVar24 = SUB84(dVar2,0);
+          uVar25 = uVar22;
+        }
+        *(double *)(param_1 + 0x58) = dVar2;
+        Sleep(1);
+        cVar3 = *(char *)(param_1 + 0x60);
+      }
+      FUN_140010aa0(L"+ Prepare Stop\n",puVar16,puVar18,param_4);
+      FUN_1400079d0(*(longlong *)(param_1 + 0xa8));
+      lVar20 = *(longlong *)(param_1 + 0xa0);
+      puVar4 = *(undefined8 **)(lVar20 + 0x28);
+      if (puVar4 != (undefined8 *)0x0) {
+        puVar16 = (ulonglong *)0x1;
+        (**(code **)*puVar4)();
+      }
+      *(undefined8 *)(lVar20 + 0x28) = 0;
+      CoUninitialize();
+      FUN_140010960(L"# Agent Stoped... #\n",puVar16,puVar18,param_4);
+      if (7 < local_b0) {
+        operator_delete((void *)CONCAT62(uStack_c6,local_c8));
+      }
+      local_b0 = 7;
+      local_b8 = 0;
+      local_c8 = 0;
+      if (7 < local_d8) {
+        operator_delete((void *)CONCAT62(uStack_ee,local_f0));
+      }
+      pwVar19 = local_280;
+      local_d8 = 7;
+      local_e0 = 0;
+      local_f0 = 0;
+      if (pwVar10 != (wchar_t *)0x0) {
+        plVar13 = (longlong *)((longlong)pwVar10 + 8);
+        *plVar13 = *plVar13 + -1;
+        plVar17 = local_288;
+        if (*plVar13 == 0) {
+          pwVar10 = *(wchar_t **)local_280;
+          local_260 = pwVar10;
+          if (pwVar10 != (wchar_t *)0x0) {
+            FUN_14002e7a0((undefined4 *)(pwVar10 + 0x14),puVar16,puVar18,param_4);
+            if (*(void **)(pwVar10 + 4) != (void *)0x0) {
+              operator_delete(*(void **)(pwVar10 + 4));
+            }
+            pwVar10[4] = L'\0';
+            pwVar10[5] = L'\0';
+            pwVar10[6] = L'\0';
+            pwVar10[7] = L'\0';
+            pwVar10[8] = L'\0';
+            pwVar10[9] = L'\0';
+            pwVar10[10] = L'\0';
+            pwVar10[0xb] = L'\0';
+            pwVar10[0xc] = L'\0';
+            pwVar10[0xd] = L'\0';
+            pwVar10[0xe] = L'\0';
+            pwVar10[0xf] = L'\0';
+            operator_delete(pwVar10);
+          }
+          FUN_1400302f0(pwVar19);
+          plVar17 = local_288;
+        }
+      }
+      plVar13 = local_288;
+      if (plVar17 != (longlong *)0x0) {
+        plVar17 = plVar17 + 1;
+        *plVar17 = *plVar17 + -1;
+        if (*plVar17 == 0) {
+          puVar4 = (undefined8 *)*local_288;
+          if (puVar4 != (undefined8 *)0x0) {
+            (**(code **)*puVar4)(puVar4,1);
+          }
+          FUN_1400302f0(plVar13);
+        }
+      }
+      return 0;
+    }
+    if (*pcVar15 == '\x18') {
+      pwVar11 = (wchar_t *)(pcVar15 + 8);
+      if (7 < *(ulonglong *)(pcVar15 + 0x20)) {
+        pwVar11 = *(wchar_t **)(pcVar15 + 8);
+      }
+      goto LAB_140003c4a;
+    }
+    pcVar15 = pcVar15 + 0x30;
+  } while( true );
+}
+

decomp/Agent_Release_x64/full/functions/0x140003f30.c

@@ -0,0 +1,417 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140003f30 FUN_140003f30
+ * Pseudocode, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+
+undefined8 FUN_140003f30(longlong param_1,ulonglong *param_2,undefined2 *param_3,uint *param_4)
+
+{
+  byte bVar1;
+  longlong lVar2;
+  ulonglong *puVar3;
+  ulonglong *puVar4;
+  ushort uVar5;
+  int iVar6;
+  int iVar7;
+  BOOL BVar8;
+  HANDLE hProcess;
+  undefined2 *puVar9;
+  char *pcVar10;
+  longlong *plVar11;
+  wchar_t *_Format;
+  ulonglong *puVar12;
+  undefined **ppuVar13;
+  undefined2 *puVar14;
+  bool bVar15;
+  undefined1 auStack_2f8 [32];
+  DWORD local_2d8 [2];
+  uint local_2d0 [2];
+  undefined8 local_2c8;
+  undefined8 local_2c0;
+  undefined8 local_2b8;
+  undefined8 local_2b0;
+  undefined8 local_2a8;
+  undefined8 local_2a0;
+  undefined8 local_298;
+  undefined8 local_290;
+  undefined8 local_288;
+  undefined8 local_280;
+  undefined4 local_278;
+  undefined8 local_268;
+  ulonglong *local_260;
+  ulonglong *local_258;
+  undefined8 local_250;
+  ulonglong local_248;
+  undefined4 local_238 [10];
+  void *local_210;
+  ulonglong local_1f8;
+  undefined2 local_1e8;
+  undefined6 uStack_1e6;
+  undefined8 local_1d8;
+  ulonglong local_1d0;
+  undefined2 local_1c0;
+  undefined6 uStack_1be;
+  undefined8 local_1b0;
+  ulonglong local_1a8;
+  undefined4 local_198;
+  uint local_194;
+  void *local_160;
+  undefined8 local_158;
+  undefined8 local_150;
+  undefined4 local_138 [10];
+  undefined2 local_110;
+  undefined6 uStack_10e;
+  undefined8 local_100;
+  ulonglong local_f8;
+  undefined2 local_e8;
+  undefined6 uStack_e6;
+  undefined8 local_d8;
+  ulonglong local_d0;
+  undefined2 local_c0;
+  undefined6 uStack_be;
+  undefined8 local_b0;
+  ulonglong local_a8;
+  int local_74;
+  void *local_60;
+  undefined8 local_58;
+  undefined8 local_50;
+  ulonglong local_38;
+  
+  local_268 = 0xfffffffffffffffe;
+  local_38 = DAT_1401555a0 ^ (ulonglong)auStack_2f8;
+  iVar6 = _kbhit();
+  if (iVar6 != 0) {
+    puVar14 = (undefined2 *)0x0;
+    do {
+      iVar6 = _getch();
+      iVar6 = (int)(char)iVar6;
+      if (*(char *)(param_1 + 0x48) != '\0') {
+        iVar7 = toupper(iVar6);
+        if (iVar7 == 0x55) {
+          printf("Keyboard UnLocked\n");
+          *(undefined1 *)(param_1 + 0x48) = 0;
+          ppuVar13 = &PTR_s_Server_Shutdown__14015aee8;
+          do {
+            uVar5 = GetAsyncKeyState(0xa0);
+            if (((uVar5 & 0x8001) != 0) || (*(char *)(ppuVar13 + 1) == '\0')) {
+              param_3 = (undefined2 *)*ppuVar13;
+              param_2 = (ulonglong *)(ulonglong)(uint)(int)*(char *)(ppuVar13 + -1);
+              printf(" \'%c\'\t: %s\n");
+            }
+            ppuVar13 = ppuVar13 + 3;
+          } while ((longlong)ppuVar13 < 0x14015b050);
+        }
+        goto LAB_1400047ca;
+      }
+      iVar7 = toupper(iVar6);
+      switch(iVar7) {
+      case 0x30:
+        bVar15 = *(char *)(DAT_140162d68 + 0x171) == '\0';
+        *(bool *)(DAT_140162d68 + 0x171) = bVar15;
+        pcVar10 = "Auto Revive On !!!\n";
+        if (!bVar15) {
+          pcVar10 = "Auto Revive Off !!!\n";
+        }
+        printf(pcVar10);
+        param_2 = (ulonglong *)0x7;
+        FUN_140006940(*(longlong *)(param_1 + 0xa0),7,param_3,(longlong)param_4);
+        break;
+      case 0x31:
+        pcVar10 = "All Server On. \n";
+        printf("All Server On. \n");
+        FUN_140009890(pcVar10,param_2,param_3,param_4);
+        param_2 = (ulonglong *)PTR_s_All_Server_On__14015afa8;
+        printf("%s\n");
+        break;
+      case 0x32:
+        pcVar10 = "Disconnect Server On. \n";
+        printf("Disconnect Server On. \n");
+        FUN_140009bd0(pcVar10,param_2,param_3,param_4);
+        param_2 = (ulonglong *)PTR_s_Disconnect_Server_On__14015afc0;
+        printf("%s\n");
+        break;
+      default:
+        printf("........... Message : Unknown Control Command.\n");
+        break;
+      case 0x35:
+        local_260 = (ulonglong *)0x0;
+        local_258 = (ulonglong *)0x0;
+        local_250 = 0;
+        FUN_14002ce60(DAT_140162d60,(ulonglong *)&local_260);
+        puVar4 = local_258;
+        puVar3 = local_260;
+        param_2 = (ulonglong *)PTR_s_All_Server_Down__14015afd8;
+        for (puVar12 = local_260; PTR_s_All_Server_Down__14015afd8 = (undefined *)param_2,
+            puVar12 != puVar4; puVar12 = puVar12 + 0x1f) {
+          FUN_140004950(local_238,(undefined4 *)puVar12);
+          local_2d0[0] = 1;
+          plVar11 = (longlong *)(*(longlong *)(param_1 + 0xa0) + 0x50);
+          param_4 = local_2d0;
+          param_3 = (undefined2 *)&DAT_1401555d0;
+          (**(code **)(*plVar11 + 0x40))(plVar11,local_198);
+          if (local_160 != (void *)0x0) {
+            operator_delete(local_160);
+          }
+          local_160 = (void *)0x0;
+          local_158 = 0;
+          local_150 = 0;
+          if (7 < local_1a8) {
+            operator_delete((void *)CONCAT62(uStack_1be,local_1c0));
+          }
+          local_1a8 = 7;
+          local_1b0 = 0;
+          local_1c0 = 0;
+          if (7 < local_1d0) {
+            operator_delete((void *)CONCAT62(uStack_1e6,local_1e8));
+          }
+          local_1d0 = 7;
+          local_1d8 = 0;
+          local_1e8 = 0;
+          if (7 < local_1f8) {
+            operator_delete(local_210);
+          }
+          param_2 = (ulonglong *)PTR_s_All_Server_Down__14015afd8;
+        }
+        if (puVar3 != (ulonglong *)0x0) {
+          FUN_140004b30(puVar3,puVar4);
+          operator_delete(puVar3);
+          param_2 = (ulonglong *)PTR_s_All_Server_Down__14015afd8;
+        }
+        goto LAB_140004442;
+      case 0x38:
+        local_260 = (ulonglong *)0x0;
+        local_258 = (ulonglong *)0x0;
+        local_250 = 0;
+        FUN_14002ce60(DAT_140162d60,(ulonglong *)&local_260);
+        puVar4 = local_258;
+        puVar3 = local_260;
+        for (puVar12 = local_260; puVar12 != puVar4; puVar12 = puVar12 + 0x1f) {
+          FUN_140004950(local_138,(undefined4 *)puVar12);
+          if (local_74 == 0) {
+            _Format = L"OFF  - ";
+LAB_1400044dc:
+            wprintf(_Format);
+          }
+          else {
+            if (local_74 == 1) {
+              _Format = L"LOAD - ";
+              goto LAB_1400044dc;
+            }
+            if (local_74 == 2) {
+              _Format = L"BAD  - ";
+              goto LAB_1400044dc;
+            }
+            if (local_74 == 3) {
+              _Format = L"GOOD - ";
+              goto LAB_1400044dc;
+            }
+          }
+          param_3 = &local_c0;
+          if (7 < local_a8) {
+            param_3 = (undefined2 *)CONCAT62(uStack_be,local_c0);
+          }
+          wprintf(L"\tCODE:[ %d ]\tNAME:[ %s ] \n");
+          if (local_60 != (void *)0x0) {
+            operator_delete(local_60);
+          }
+          local_60 = (void *)0x0;
+          local_58 = 0;
+          local_50 = 0;
+          if (7 < local_a8) {
+            operator_delete((void *)CONCAT62(uStack_be,local_c0));
+          }
+          local_a8 = 7;
+          local_b0 = 0;
+          local_c0 = 0;
+          if (7 < local_d0) {
+            operator_delete((void *)CONCAT62(uStack_e6,local_e8));
+          }
+          local_d0 = 7;
+          local_d8 = 0;
+          local_e8 = 0;
+          if (7 < local_f8) {
+            operator_delete((void *)CONCAT62(uStack_10e,local_110));
+          }
+          local_f8 = 7;
+          local_100 = 0;
+          local_110 = 0;
+        }
+        wprintf(L"ConnectServer Count : [ %d ] \n");
+        param_2 = (ulonglong *)PTR_s_Server_Information__14015aff0;
+        if (puVar3 != (ulonglong *)0x0) {
+          FUN_140004b30(puVar3,puVar4);
+          operator_delete(puVar3);
+          param_2 = (ulonglong *)PTR_s_Server_Information__14015aff0;
+        }
+LAB_140004442:
+        printf("%s\n");
+        break;
+      case 0x39:
+        local_260 = (ulonglong *)0x0;
+        local_258 = (ulonglong *)0x0;
+        local_250 = 0;
+        FUN_14002ce60(DAT_140162d60,(ulonglong *)&local_260);
+        puVar4 = local_258;
+        puVar3 = local_260;
+        for (puVar12 = local_260; puVar12 != puVar4; puVar12 = puVar12 + 0x1f) {
+          FUN_140004950(local_238,(undefined4 *)puVar12);
+          param_3 = (undefined2 *)(ulonglong)local_194;
+          hProcess = OpenProcess(0x1f0fff,0,local_194);
+          if (hProcess != (HANDLE)0x0) {
+            BVar8 = GetExitCodeProcess(hProcess,local_2d8);
+            if ((BVar8 != 0) && (local_2d8[0] == 0x103)) {
+              TerminateProcess(hProcess,0);
+            }
+            CloseHandle(hProcess);
+          }
+          if (local_160 != (void *)0x0) {
+            operator_delete(local_160);
+          }
+          local_160 = (void *)0x0;
+          local_158 = 0;
+          local_150 = 0;
+          if (7 < local_1a8) {
+            operator_delete((void *)CONCAT62(uStack_1be,local_1c0));
+          }
+          local_1a8 = 7;
+          local_1b0 = 0;
+          local_1c0 = 0;
+          if (7 < local_1d0) {
+            operator_delete((void *)CONCAT62(uStack_1e6,local_1e8));
+          }
+          local_1d0 = 7;
+          local_1d8 = 0;
+          local_1e8 = 0;
+          if (7 < local_1f8) {
+            operator_delete(local_210);
+          }
+        }
+        if (puVar3 != (ulonglong *)0x0) {
+          FUN_140004b30(puVar3,puVar4);
+          operator_delete(puVar3);
+        }
+        param_2 = (ulonglong *)PTR_s_All_Server_Kill__14015b008;
+        printf("%s\n");
+        break;
+      case 0x45:
+        *(undefined1 *)(param_1 + 0x60) = 0;
+        printf("%s\n");
+        return 0;
+      case 0x46:
+        wprintf(L"-AGENT SERVER [CODE:%d]---------------------------------\n");
+        param_3 = (undefined2 *)(ulonglong)*(uint *)(*(longlong *)(param_1 + 0xa0) + 0x38);
+        wprintf(L"PRIVATE NETWORK : ADDRESS[ %s ] PORT[ %d ]\n");
+        FUN_140001bf0(param_1 + 8);
+        param_2 = (ulonglong *)PTR_s_Server_Info__14015af30;
+        printf("%s\n");
+        break;
+      case 0x4c:
+        *(undefined1 *)(param_1 + 0x48) = 1;
+        param_2 = (ulonglong *)PTR_s_Keyboard_Locked__14015af00;
+        printf("%s\n");
+        break;
+      case 0x4d:
+        FUN_14002b820(DAT_140162d48);
+        lVar2 = *(longlong *)(param_1 + 0xa8);
+        if (lVar2 != 0) {
+          bVar1 = *(byte *)(DAT_140162d48 + 0x17);
+          param_4 = (uint *)(ulonglong)bVar1;
+          puVar9 = puVar14;
+          param_3 = puVar14;
+          if (*(longlong *)(lVar2 + 0x10) - *(longlong *)(lVar2 + 8) >> 3 != 0) {
+            do {
+              *(byte *)(*(longlong *)(*(longlong *)(lVar2 + 8) + (longlong)puVar9) + 0x18) = bVar1;
+              param_3 = (undefined2 *)(ulonglong)((int)param_3 + 1);
+              puVar9 = puVar9 + 4;
+            } while (param_3 < (undefined2 *)
+                               (*(longlong *)(lVar2 + 0x10) - *(longlong *)(lVar2 + 8) >> 3));
+          }
+        }
+        param_2 = (ulonglong *)PTR_s_CustomOption_Init__14015af90;
+        printf("%s\n");
+        break;
+      case 0x50:
+        lVar2 = *(longlong *)(param_1 + 0xa0);
+        if (lVar2 != 0) {
+          local_288 = 0;
+          local_2c0 = 0;
+          local_2c8 = 0;
+          local_2b0 = 0;
+          local_2b8 = 0;
+          local_290 = 0;
+          local_298 = 0;
+          local_2a0 = 0;
+          local_2a8 = 0;
+          local_280 = 0;
+          local_278 = 0;
+          if (*(longlong *)(lVar2 + 0x28) != 0) {
+            (**(code **)(**(longlong **)(lVar2 + 0x28) + 0xb0))
+                      (*(longlong **)(lVar2 + 0x28),&local_2c8);
+            printf("--------------------------------------------------\n");
+            printf("%I64d totalTcpReceiveCount\n");
+            printf("%I64d totalTcpReceiveBytes\n");
+            printf("%I64d totalTcpSendCount\n");
+            printf("%I64d totalTcpSendBytes\n");
+            printf("%d p2pConnectionPairCount\n");
+            printf("%d p2pDirectConnectionPairCount\n");
+            printf("%d clientCount\n");
+            printf("--------------------------------------------------\n");
+          }
+        }
+        param_2 = (ulonglong *)PTR_s_Network_Status__14015af48;
+        printf("%s\n");
+        break;
+      case 0x52:
+        DAT_140162cc4 = (uint)(DAT_140162cc4 == 0);
+        param_3 = (undefined2 *)&DAT_14011b9ac;
+        if (DAT_140162cc4 != 0) {
+          param_3 = (undefined2 *)&DAT_14011b9a8;
+        }
+        param_2 = (ulonglong *)PTR_s_ShowFPS__14015af60;
+        printf("%s %s\n");
+        break;
+      case 0x54:
+        printf("RetryConnectSession\n");
+        iVar7 = (int)(*(longlong *)(param_1 + 0x20) - *(longlong *)(param_1 + 0x18) >> 3);
+        puVar9 = puVar14;
+        if (0 < iVar7) {
+          do {
+            if (*(longlong *)(*(longlong *)(param_1 + 0x18) + (longlong)puVar9 * 8) != 0) {
+              *(undefined1 *)
+               (*(longlong *)(*(longlong *)(param_1 + 0x18) + (longlong)puVar9 * 8) + 0x1c) = 1;
+            }
+            puVar9 = (undefined2 *)((longlong)puVar9 + 1);
+          } while ((longlong)puVar9 < (longlong)iVar7);
+        }
+        param_2 = (ulonglong *)PTR_s_AgentManager_Retry__14015af18;
+        printf("%s\n");
+      }
+LAB_1400047ca:
+      iVar6 = toupper(iVar6);
+      if (iVar6 == 0x49) {
+        printf("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n");
+        GetCurrentProcessId();
+        printf("ProcessID : %d\n");
+        printf("SVN : %d\n");
+        printf("Resource : %d\n");
+        printf("Build Date : %s\n");
+        param_2 = FUN_1400dcb80((ulonglong *)&local_260);
+        if (0xf < param_2[3]) {
+          param_2 = (ulonglong *)*param_2;
+        }
+        printf("PROTOCOL : %s\n");
+        if (0xf < local_248) {
+          operator_delete(local_260);
+        }
+        local_248 = 0xf;
+        local_250 = 0;
+        local_260 = (ulonglong *)((ulonglong)local_260 & 0xffffffffffffff00);
+        printf("=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=-=\n");
+      }
+      iVar6 = _kbhit();
+    } while (iVar6 != 0);
+  }
+  return 2;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004950.c

@@ -0,0 +1,19 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004950 FUN_140004950
+ * Pseudocode, not original source. */
+
+undefined4 * FUN_140004950(undefined4 *param_1,undefined4 *param_2)
+
+{
+  FUN_140004ea0(param_1,param_2);
+  *(undefined8 *)(param_1 + 0x28) = *(undefined8 *)(param_2 + 0x28);
+  *(undefined8 *)(param_1 + 0x2a) = *(undefined8 *)(param_2 + 0x2a);
+  *(undefined8 *)(param_1 + 0x2c) = *(undefined8 *)(param_2 + 0x2c);
+  *(undefined8 *)(param_1 + 0x2e) = *(undefined8 *)(param_2 + 0x2e);
+  *(undefined8 *)(param_1 + 0x30) = *(undefined8 *)(param_2 + 0x30);
+  *(undefined8 *)(param_1 + 0x32) = *(undefined8 *)(param_2 + 0x32);
+  *(undefined8 *)(param_1 + 0x34) = *(undefined8 *)(param_2 + 0x34);
+  FUN_140004d60((undefined8 *)(param_1 + 0x36),(longlong *)(param_2 + 0x36));
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004a00.c

@@ -0,0 +1,23 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004a00 FUN_140004a00
+ * Pseudocode, not original source. */
+
+void FUN_140004a00(longlong *param_1)
+
+{
+  longlong *plVar1;
+  undefined8 *puVar2;
+  
+  if ((*param_1 != 0) &&
+     (*(longlong *)(*param_1 + 8) = *(longlong *)(*param_1 + 8) + -1,
+     *(longlong *)(*param_1 + 8) == 0)) {
+    plVar1 = (longlong *)*param_1;
+    puVar2 = (undefined8 *)*plVar1;
+    if (puVar2 != (undefined8 *)0x0) {
+      (**(code **)*puVar2)(puVar2,1);
+    }
+    FUN_1400302f0(plVar1);
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004a60.c

@@ -0,0 +1,31 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004a60 FUN_140004a60
+ * Pseudocode, not original source. */
+
+void FUN_140004a60(longlong *param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  undefined8 *puVar1;
+  void *pvVar2;
+  
+  if (*param_1 != 0) {
+    *(longlong *)(*param_1 + 8) = *(longlong *)(*param_1 + 8) + -1;
+    if (*(longlong *)(*param_1 + 8) == 0) {
+      puVar1 = (undefined8 *)*param_1;
+      pvVar2 = (void *)*puVar1;
+      if (pvVar2 != (void *)0x0) {
+        FUN_14002e7a0((undefined4 *)((longlong)pvVar2 + 0x28),0,param_3,param_4);
+        if (*(void **)((longlong)pvVar2 + 8) != (void *)0x0) {
+          operator_delete(*(void **)((longlong)pvVar2 + 8));
+        }
+        *(undefined8 *)((longlong)pvVar2 + 8) = 0;
+        *(undefined8 *)((longlong)pvVar2 + 0x10) = 0;
+        *(undefined8 *)((longlong)pvVar2 + 0x18) = 0;
+        operator_delete(pvVar2);
+      }
+      FUN_1400302f0(puVar1);
+    }
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004af0.c

@@ -0,0 +1,17 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004af0 FUN_140004af0
+ * Pseudocode, not original source. */
+
+void FUN_140004af0(undefined8 *param_1)
+
+{
+  if ((ulonglong *)*param_1 != (ulonglong *)0x0) {
+    FUN_140004b30((ulonglong *)*param_1,(ulonglong *)param_1[1]);
+    operator_delete((void *)*param_1);
+  }
+  *param_1 = 0;
+  param_1[1] = 0;
+  param_1[2] = 0;
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004b30.c

@@ -0,0 +1,44 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004b30 FUN_140004b30
+ * Pseudocode, not original source. */
+
+void FUN_140004b30(ulonglong *param_1,ulonglong *param_2)
+
+{
+  ulonglong *puVar1;
+  ulonglong *puVar2;
+  
+  if (param_1 != param_2) {
+    puVar2 = param_1 + 0x12;
+    do {
+      if ((void *)puVar2[9] != (void *)0x0) {
+        operator_delete((void *)puVar2[9]);
+      }
+      puVar2[9] = 0;
+      puVar2[10] = 0;
+      puVar2[0xb] = 0;
+      if (7 < *puVar2) {
+        operator_delete((void *)puVar2[-3]);
+      }
+      *puVar2 = 7;
+      puVar2[-1] = 0;
+      *(undefined2 *)(puVar2 + -3) = 0;
+      if (7 < puVar2[-5]) {
+        operator_delete((void *)puVar2[-8]);
+      }
+      puVar2[-5] = 7;
+      puVar2[-6] = 0;
+      *(undefined2 *)(puVar2 + -8) = 0;
+      if (7 < puVar2[-10]) {
+        operator_delete((void *)puVar2[-0xd]);
+      }
+      puVar2[-10] = 7;
+      puVar2[-0xb] = 0;
+      *(undefined2 *)(puVar2 + -0xd) = 0;
+      puVar1 = puVar2 + 0xd;
+      puVar2 = puVar2 + 0x1f;
+    } while (puVar1 != param_2);
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004c00.c

@@ -0,0 +1,11 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004c00 FUN_140004c00
+ * Pseudocode, not original source. */
+
+void FUN_140004c00(longlong param_1,ulonglong param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  FUN_1400033f0((undefined8 *)(param_1 + -8),param_2,param_3,param_4);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004c10.c

@@ -0,0 +1,16 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004c10 FUN_140004c10
+ * Pseudocode, not original source. */
+
+void FUN_140004c10(undefined8 *param_1)
+
+{
+  if ((void *)*param_1 != (void *)0x0) {
+    operator_delete((void *)*param_1);
+  }
+  *param_1 = 0;
+  param_1[1] = 0;
+  param_1[2] = 0;
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004c40.c

@@ -0,0 +1,25 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004c40 FUN_140004c40
+ * Pseudocode, not original source. */
+
+void * FUN_140004c40(undefined8 param_1,ulonglong param_2)
+
+{
+  void *pvVar1;
+  char *local_res10 [3];
+  undefined **local_28 [5];
+  
+  if (param_2 == 0) {
+    return (void *)0x0;
+  }
+  if ((param_2 < 0x4000000000000000) && (pvVar1 = operator_new(param_2 * 4), pvVar1 != (void *)0x0))
+  {
+    return pvVar1;
+  }
+  local_res10[0] = (char *)0x0;
+  std::exception::exception((exception *)local_28,local_res10);
+  local_28[0] = std::bad_alloc::vftable;
+                    /* WARNING: Subroutine does not return */
+  _CxxThrowException(local_28,(ThrowInfo *)&DAT_140151ad0);
+}
+

decomp/Agent_Release_x64/full/functions/0x140004cb0.c

@@ -0,0 +1,32 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004cb0 FUN_140004cb0
+ * Pseudocode, not original source. */
+
+undefined8 FUN_140004cb0(undefined8 *param_1,ulonglong param_2)
+
+{
+  code *pcVar1;
+  undefined8 uVar2;
+  void *pvVar3;
+  
+  uVar2 = 0;
+  *param_1 = 0;
+  param_1[1] = 0;
+  param_1[2] = 0;
+  if (param_2 != 0) {
+    if (0x3fffffffffffffff < param_2) {
+      std::_Xlength_error("vector<T> too long");
+      pcVar1 = (code *)swi(3);
+      uVar2 = (*pcVar1)();
+      return uVar2;
+    }
+    pvVar3 = FUN_140004c40(param_1 + 3,param_2);
+    *param_1 = pvVar3;
+    param_1[1] = pvVar3;
+    pvVar3 = (void *)((longlong)pvVar3 + param_2 * 4);
+    param_1[2] = pvVar3;
+    uVar2 = CONCAT71((int7)((ulonglong)pvVar3 >> 8),1);
+  }
+  return uVar2;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004d20.c

@@ -0,0 +1,16 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004d20 FUN_140004d20
+ * Pseudocode, not original source. */
+
+undefined4 * FUN_140004d20(undefined4 *param_1,undefined4 *param_2,undefined4 *param_3)
+
+{
+  for (; param_1 != param_2; param_1 = param_1 + 1) {
+    if (param_3 != (undefined4 *)0x0) {
+      *param_3 = *param_1;
+    }
+    param_3 = param_3 + 1;
+  }
+  return param_3;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004d60.c

@@ -0,0 +1,36 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004d60 FUN_140004d60
+ * Pseudocode, not original source. */
+
+undefined8 * FUN_140004d60(undefined8 *param_1,longlong *param_2)
+
+{
+  code *pcVar1;
+  undefined8 *puVar2;
+  undefined4 *puVar3;
+  ulonglong uVar4;
+  
+  *param_1 = 0;
+  param_1[1] = 0;
+  param_1[2] = 0;
+  uVar4 = param_2[1] - *param_2 >> 2;
+  *param_1 = 0;
+  param_1[1] = 0;
+  param_1[2] = 0;
+  if (uVar4 != 0) {
+    if (0x3fffffffffffffff < uVar4) {
+      std::_Xlength_error("vector<T> too long");
+      pcVar1 = (code *)swi(3);
+      puVar2 = (undefined8 *)(*pcVar1)();
+      return puVar2;
+    }
+    puVar3 = FUN_140004c40(param_1 + 3,uVar4);
+    *param_1 = puVar3;
+    param_1[1] = puVar3;
+    param_1[2] = puVar3 + uVar4;
+    puVar3 = FUN_140004d20((undefined4 *)*param_2,(undefined4 *)param_2[1],puVar3);
+    param_1[1] = puVar3;
+  }
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004e10.c

@@ -0,0 +1,28 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004e10 FUN_140004e10
+ * Pseudocode, not original source. */
+
+void FUN_140004e10(longlong param_1)
+
+{
+  if (7 < *(ulonglong *)(param_1 + 0x90)) {
+    operator_delete(*(void **)(param_1 + 0x78));
+  }
+  *(undefined8 *)(param_1 + 0x90) = 7;
+  *(undefined8 *)(param_1 + 0x88) = 0;
+  *(undefined2 *)(param_1 + 0x78) = 0;
+  if (7 < *(ulonglong *)(param_1 + 0x68)) {
+    operator_delete(*(void **)(param_1 + 0x50));
+  }
+  *(undefined8 *)(param_1 + 0x68) = 7;
+  *(undefined8 *)(param_1 + 0x60) = 0;
+  *(undefined2 *)(param_1 + 0x50) = 0;
+  if (7 < *(ulonglong *)(param_1 + 0x40)) {
+    operator_delete(*(void **)(param_1 + 0x28));
+  }
+  *(undefined8 *)(param_1 + 0x40) = 7;
+  *(undefined8 *)(param_1 + 0x38) = 0;
+  *(undefined2 *)(param_1 + 0x28) = 0;
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004ea0.c

@@ -0,0 +1,31 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004ea0 FUN_140004ea0
+ * Pseudocode, not original source. */
+
+undefined4 * FUN_140004ea0(undefined4 *param_1,undefined4 *param_2)
+
+{
+  *param_1 = *param_2;
+  param_1[1] = param_2[1];
+  param_1[2] = param_2[2];
+  *(undefined1 *)(param_1 + 3) = *(undefined1 *)(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];
+  *(undefined1 *)(param_1 + 8) = *(undefined1 *)(param_2 + 8);
+  *(undefined8 *)(param_1 + 0x10) = 7;
+  *(undefined8 *)(param_1 + 0xe) = 0;
+  *(undefined2 *)(param_1 + 10) = 0;
+  FUN_140001600((longlong *)(param_1 + 10),(longlong *)(param_2 + 10),0,0xffffffffffffffff);
+  *(undefined8 *)(param_1 + 0x1a) = 7;
+  *(undefined8 *)(param_1 + 0x18) = 0;
+  *(undefined2 *)(param_1 + 0x14) = 0;
+  FUN_140001600((longlong *)(param_1 + 0x14),(longlong *)(param_2 + 0x14),0,0xffffffffffffffff);
+  *(undefined8 *)(param_1 + 0x24) = 7;
+  *(undefined8 *)(param_1 + 0x22) = 0;
+  *(undefined2 *)(param_1 + 0x1e) = 0;
+  FUN_140001600((longlong *)(param_1 + 0x1e),(longlong *)(param_2 + 0x1e),0,0xffffffffffffffff);
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004f80.c

@@ -0,0 +1,16 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004f80 FUN_140004f80
+ * Pseudocode, not original source. */
+
+void FUN_140004f80(undefined8 *param_1)
+
+{
+  if (0xf < (ulonglong)param_1[3]) {
+    operator_delete((void *)*param_1);
+  }
+  param_1[3] = 0xf;
+  param_1[2] = 0;
+  *(undefined1 *)param_1 = 0;
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140004fc0.c

@@ -0,0 +1,15 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140004fc0 FUN_140004fc0
+ * Pseudocode, not original source. */
+
+undefined8 * FUN_140004fc0(undefined8 *param_1,byte param_2)
+
+{
+  DAT_1401626f8 = 0;
+  *param_1 = MBISingleton<MagiAgentServer>::vftable;
+  if ((param_2 & 1) != 0) {
+    operator_delete(param_1);
+  }
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140005000.c

@@ -0,0 +1,12 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140005000 FUN_140005000
+ * Pseudocode, not original source. */
+
+void FUN_140005000(undefined8 *param_1)
+
+{
+  DAT_1401626f8 = 0;
+  *param_1 = MBISingleton<MagiAgentServer>::vftable;
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140005020.c

@@ -0,0 +1,38 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140005020 FUN_140005020
+ * Pseudocode, not original source. */
+
+undefined8 *
+FUN_140005020(undefined8 *param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  undefined8 *puVar1;
+  ulonglong uVar2;
+  undefined7 uVar3;
+  
+  uVar3 = (undefined7)((ulonglong)param_3 >> 8);
+  param_1[5] = 0;
+  FUN_140030200(param_1,param_2,param_3,param_4);
+  param_1[6] = PTR_DAT_140155010;
+  param_1[7] = 0;
+  *(undefined4 *)(param_1 + 8) = 0;
+  *param_1 = Proud::INetServerEvent::vftable;
+  FUN_140085230(param_1 + 1);
+  *param_1 = MagiAgentNetwork::vftable;
+  param_1[1] = MagiAgentNetwork::vftable;
+  param_1[9] = 0;
+  puVar1 = param_1 + 10;
+  FUN_140081fb0(puVar1);
+  *puVar1 = AGENT2SERVER_PROTOCOL::Proxy::vftable;
+  if (*(int *)((longlong)param_1 + 100) != 1) {
+    FUN_14002fa10((wchar_t *)PTR_u_PIDL_compiler_is_incompatible_to_140156790);
+  }
+  *puVar1 = RNP::Agent2ServerProxy::vftable;
+  *(undefined1 *)(param_1 + 0xd) = 0;
+  uVar2 = FUN_14002e790();
+  FUN_14002e600((undefined4 *)(param_1 + 0xe),uVar2 & 0xffffffff,CONCAT71(uVar3,1),param_4);
+  param_1[0x15] = 0;
+  param_1[0x16] = 0;
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140005100.c

@@ -0,0 +1,15 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140005100 FUN_140005100
+ * Pseudocode, not original source. */
+
+undefined8 *
+FUN_140005100(undefined8 *param_1,ulonglong param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  FUN_140005130(param_1,param_2,param_3,param_4);
+  if ((param_2 & 1) != 0) {
+    operator_delete(param_1);
+  }
+  return param_1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140005130.c

@@ -0,0 +1,33 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140005130 FUN_140005130
+ * Pseudocode, not original source. */
+
+void FUN_140005130(undefined8 *param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  longlong *plVar1;
+  
+  *param_1 = MagiAgentNetwork::vftable;
+  param_1[1] = MagiAgentNetwork::vftable;
+  plVar1 = param_1 + 5;
+  if ((undefined8 *)*plVar1 != (undefined8 *)0x0) {
+    param_2 = 1;
+    (*(code *)**(undefined8 **)*plVar1)();
+  }
+  *plVar1 = 0;
+  FUN_14002e7a0((undefined4 *)(param_1 + 0xe),param_2,param_3,param_4);
+  param_1[10] = RNP::Agent2ServerProxy::vftable;
+  FUN_140081fe0(param_1 + 10);
+  param_1[1] = RNP::Server2AgentStub::vftable;
+  FUN_140085260(param_1 + 1);
+  *param_1 = Proud::INetServerEvent::vftable;
+  FUN_14003b5c0(param_1);
+  if ((undefined8 *)*plVar1 != (undefined8 *)0x0) {
+    param_2 = 1;
+    (*(code *)**(undefined8 **)*plVar1)();
+  }
+  *plVar1 = 0;
+  FUN_140003240(param_1 + 6,param_2,param_3,param_4);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140005200.c

@@ -0,0 +1,35 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140005200 FUN_140005200
+ * Pseudocode, not original source. */
+
+void FUN_140005200(undefined8 param_1,int *param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  int *piVar1;
+  longlong *plVar2;
+  int *piVar3;
+  wchar_t *pwVar4;
+  undefined *puVar5;
+  undefined *local_res18 [2];
+  
+  plVar2 = FUN_14003c240(param_2,(longlong *)local_res18,param_3,param_4);
+  puVar5 = (undefined *)*plVar2;
+  if ((undefined *)*plVar2 == (undefined *)0x0) {
+    puVar5 = PTR_DAT_140155010;
+  }
+  pwVar4 = L"OnError MagiAgentNetwork : %s";
+  FUN_140010d30(L"OnError MagiAgentNetwork : %s",puVar5,param_3,param_4);
+  if (((local_res18[0] != (undefined *)0x0) && (local_res18[0] != PTR_DAT_140155010)) &&
+     (local_res18[0] + -8 != (undefined *)0x0)) {
+    piVar3 = (int *)FUN_140030200(pwVar4,puVar5,param_3,param_4);
+    FUN_14002e6e0(piVar3);
+    piVar1 = (int *)(local_res18[0] + -4);
+    *piVar1 = *piVar1 + -1;
+    if (*piVar1 == 0) {
+      FUN_1400302f0(local_res18[0] + -8);
+    }
+    FUN_14002e770((longlong)piVar3);
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400052a0.c

@@ -0,0 +1,35 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400052a0 FUN_1400052a0
+ * Pseudocode, not original source. */
+
+void FUN_1400052a0(undefined8 param_1,int *param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  int *piVar1;
+  longlong *plVar2;
+  int *piVar3;
+  wchar_t *pwVar4;
+  undefined *puVar5;
+  undefined *local_res18 [2];
+  
+  plVar2 = FUN_14003c240(param_2,(longlong *)local_res18,param_3,param_4);
+  puVar5 = (undefined *)*plVar2;
+  if ((undefined *)*plVar2 == (undefined *)0x0) {
+    puVar5 = PTR_DAT_140155010;
+  }
+  pwVar4 = L"OnWarning MagiAgentNetwork : %s";
+  FUN_140010d30(L"OnWarning MagiAgentNetwork : %s",puVar5,param_3,param_4);
+  if (((local_res18[0] != (undefined *)0x0) && (local_res18[0] != PTR_DAT_140155010)) &&
+     (local_res18[0] + -8 != (undefined *)0x0)) {
+    piVar3 = (int *)FUN_140030200(pwVar4,puVar5,param_3,param_4);
+    FUN_14002e6e0(piVar3);
+    piVar1 = (int *)(local_res18[0] + -4);
+    *piVar1 = *piVar1 + -1;
+    if (*piVar1 == 0) {
+      FUN_1400302f0(local_res18[0] + -8);
+    }
+    FUN_14002e770((longlong)piVar3);
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140005340.c

@@ -0,0 +1,14 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140005340 FUN_140005340
+ * Pseudocode, not original source. */
+
+void FUN_140005340(undefined8 param_1,longlong *param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  undefined8 uVar1;
+  
+  uVar1 = (**(code **)(*param_2 + 8))(param_2);
+  FUN_140010be0("OnException MagiAgentNetwork : %s",uVar1,param_3,param_4);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140005360.c

@@ -0,0 +1,29 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140005360 FUN_140005360
+ * Pseudocode, not original source. */
+
+void FUN_140005360(longlong param_1,undefined8 param_2,undefined8 param_3,longlong param_4)
+
+{
+  longlong lVar1;
+  longlong *plVar2;
+  short *psVar3;
+  longlong lVar4;
+  
+  plVar2 = FUN_14005c290(param_1,param_2,param_3,param_4);
+  *(longlong **)(param_1 + 0x28) = plVar2;
+  lVar4 = *plVar2;
+  (**(code **)(lVar4 + 0x10))(plVar2,param_1 + 8);
+  (**(code **)(**(longlong **)(param_1 + 0x28) + 8))(*(longlong **)(param_1 + 0x28),param_1 + 0x50);
+  (**(code **)(**(longlong **)(param_1 + 0x28) + 0x130))(*(longlong **)(param_1 + 0x28),param_1);
+  lVar1 = DAT_140162d68;
+  psVar3 = (short *)(DAT_140162d68 + 0x30);
+  *(undefined4 *)(param_1 + 0x38) = *(undefined4 *)(DAT_140162d68 + 0x80);
+  if (7 < *(ulonglong *)(lVar1 + 0x48)) {
+    psVar3 = *(short **)psVar3;
+  }
+  FUN_140006c60((longlong *)(param_1 + 0x30),psVar3,lVar4,param_4);
+  FUN_14002ac70((undefined8 *)(param_1 + 0x28),psVar3,lVar4,param_4);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400053e0.c

@@ -0,0 +1,110 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400053e0 FUN_1400053e0
+ * Pseudocode, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+
+void FUN_1400053e0(longlong param_1,double param_2)
+
+{
+  ulonglong *puVar1;
+  ulonglong *puVar2;
+  ulonglong *puVar3;
+  ulonglong *puVar4;
+  undefined1 auStack_198 [32];
+  undefined4 local_178 [2];
+  ulonglong *local_170;
+  ulonglong *local_168;
+  undefined8 local_160;
+  undefined8 local_150;
+  undefined4 local_148 [10];
+  undefined2 local_120;
+  undefined6 uStack_11e;
+  undefined8 local_110;
+  ulonglong local_108;
+  undefined2 local_f8;
+  undefined6 uStack_f6;
+  undefined8 local_e8;
+  ulonglong local_e0;
+  undefined2 local_d0;
+  undefined6 uStack_ce;
+  undefined8 local_c0;
+  ulonglong local_b8;
+  ulonglong local_a8;
+  ulonglong uStack_a0;
+  ulonglong local_98;
+  ulonglong local_90;
+  ulonglong local_88;
+  ulonglong local_80;
+  ulonglong local_78;
+  void *local_70;
+  undefined8 local_68;
+  undefined8 local_60;
+  ulonglong local_48;
+  
+  local_150 = 0xfffffffffffffffe;
+  local_48 = DAT_1401555a0 ^ (ulonglong)auStack_198;
+  if ((0.0 < *(double *)(DAT_140162d68 + 0x168)) &&
+     (*(double *)(DAT_140162d68 + 0x168) < param_2 - *(double *)(param_1 + 0xa8))) {
+    *(double *)(param_1 + 0xa8) = param_2;
+    local_170 = (ulonglong *)0x0;
+    local_168 = (ulonglong *)0x0;
+    local_160 = 0;
+    FUN_14002ce60(DAT_140162d60,(ulonglong *)&local_170);
+    puVar3 = local_168;
+    puVar2 = local_170;
+    if (local_170 != local_168) {
+      puVar4 = local_170 + 0x17;
+      do {
+        FUN_140004ea0(local_148,(undefined4 *)(puVar4 + -0x17));
+        local_a8 = puVar4[-3];
+        uStack_a0 = puVar4[-2];
+        local_98 = puVar4[-1];
+        local_90 = *puVar4;
+        local_88 = puVar4[1];
+        local_80 = puVar4[2];
+        local_78 = puVar4[3];
+        FUN_140004d60(&local_70,(longlong *)(puVar4 + 4));
+        local_178[0] = 8;
+        (**(code **)(*(longlong *)(param_1 + 0x50) + 0x40))
+                  (param_1 + 0x50,local_a8 & 0xffffffff,&DAT_1401555d0,local_178);
+        if (local_70 != (void *)0x0) {
+          operator_delete(local_70);
+        }
+        local_70 = (void *)0x0;
+        local_68 = 0;
+        local_60 = 0;
+        if (7 < local_b8) {
+          operator_delete((void *)CONCAT62(uStack_ce,local_d0));
+        }
+        local_b8 = 7;
+        local_c0 = 0;
+        local_d0 = 0;
+        if (7 < local_e0) {
+          operator_delete((void *)CONCAT62(uStack_f6,local_f8));
+        }
+        local_e0 = 7;
+        local_e8 = 0;
+        local_f8 = 0;
+        if (7 < local_108) {
+          operator_delete((void *)CONCAT62(uStack_11e,local_120));
+        }
+        local_108 = 7;
+        local_110 = 0;
+        local_120 = 0;
+        puVar1 = puVar4 + 8;
+        puVar4 = puVar4 + 0x1f;
+      } while (puVar1 != puVar3);
+    }
+    if (puVar2 != (ulonglong *)0x0) {
+      FUN_140004b30(puVar2,puVar3);
+      operator_delete(puVar2);
+    }
+  }
+  if (1.0 < param_2 - *(double *)(param_1 + 0xb0)) {
+    *(double *)(param_1 + 0xb0) = param_2;
+    FUN_14002c560(DAT_140162d60);
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140005620.c

@@ -0,0 +1,39 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140005620 FUN_140005620
+ * Pseudocode, not original source. */
+
+void FUN_140005620(longlong param_1,undefined8 *param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  int *piVar1;
+  longlong *plVar2;
+  int *piVar3;
+  wchar_t *pwVar4;
+  ulonglong uVar5;
+  undefined *puVar6;
+  undefined *local_res8;
+  
+  FUN_14002e6e0((int *)(param_1 + 0x70));
+  plVar2 = (longlong *)(**(code **)*param_2)(param_2,&local_res8);
+  puVar6 = (undefined *)*plVar2;
+  if ((undefined *)*plVar2 == (undefined *)0x0) {
+    puVar6 = PTR_DAT_140155010;
+  }
+  uVar5 = (ulonglong)*(uint *)(param_2 + 6);
+  pwVar4 = L"NEW SERVER : HostID:[%d][%s] \n";
+  wprintf(L"NEW SERVER : HostID:[%d][%s] \n");
+  if (((local_res8 != (undefined *)0x0) && (local_res8 != PTR_DAT_140155010)) &&
+     (local_res8 + -8 != (undefined *)0x0)) {
+    piVar3 = (int *)FUN_140030200(pwVar4,uVar5,puVar6,param_4);
+    FUN_14002e6e0(piVar3);
+    piVar1 = (int *)(local_res8 + -4);
+    *piVar1 = *piVar1 + -1;
+    if (*piVar1 == 0) {
+      FUN_1400302f0(local_res8 + -8);
+    }
+    FUN_14002e770((longlong)piVar3);
+  }
+  FUN_14002e770(param_1 + 0x70);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400056f0.c

@@ -0,0 +1,114 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400056f0 FUN_1400056f0
+ * Pseudocode, not original source. */
+
+void FUN_1400056f0(longlong param_1,undefined8 *param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  int *piVar1;
+  int *piVar2;
+  undefined4 uVar3;
+  longlong *plVar4;
+  int *piVar5;
+  longlong lVar6;
+  wchar_t *pwVar7;
+  ulonglong uVar8;
+  longlong lVar9;
+  longlong lVar10;
+  undefined *puVar11;
+  longlong local_res8;
+  undefined8 *local_res10;
+  int *local_c8;
+  undefined1 local_c0;
+  undefined8 local_b8;
+  undefined8 local_b0;
+  undefined8 local_a8;
+  undefined8 local_a0;
+  int *local_98;
+  undefined1 local_90;
+  undefined8 local_88;
+  undefined8 local_80 [9];
+  
+  local_88 = 0xfffffffffffffffe;
+  piVar1 = (int *)(param_1 + 0x70);
+  local_res8 = param_1;
+  local_98 = piVar1;
+  FUN_14002e6e0(piVar1);
+  local_90 = 1;
+  plVar4 = (longlong *)(**(code **)*param_2)(param_2,&local_res10);
+  puVar11 = (undefined *)*plVar4;
+  if ((undefined *)*plVar4 == (undefined *)0x0) {
+    puVar11 = PTR_DAT_140155010;
+  }
+  uVar8 = (ulonglong)*(uint *)(param_2 + 6);
+  pwVar7 = L"DELETE SERVER : HostID:[%d][%s] \n";
+  wprintf(L"DELETE SERVER : HostID:[%d][%s] \n");
+  if (((local_res10 != (undefined8 *)0x0) && (local_res10 != (undefined8 *)PTR_DAT_140155010)) &&
+     (param_1 = local_res8, local_res10 + -1 != (undefined8 *)0x0)) {
+    piVar5 = (int *)FUN_140030200(pwVar7,uVar8,puVar11,param_4);
+    local_c8 = piVar5;
+    FUN_14002e6e0(piVar5);
+    local_c0 = 1;
+    piVar2 = (int *)((longlong)local_res10 + -4);
+    *piVar2 = *piVar2 + -1;
+    if (*piVar2 == 0) {
+      FUN_1400302f0(local_res10 + -1);
+    }
+    FUN_14002e770((longlong)piVar5);
+    param_1 = local_res8;
+  }
+  local_res10 = (undefined8 *)PTR_DAT_140155010;
+  lVar6 = FUN_14002c920(DAT_140162d60,*(int *)(param_2 + 6));
+  if (lVar6 != 0) {
+    lVar10 = 0;
+    *(undefined4 *)(lVar6 + 0xa0) = 0;
+    *(undefined4 *)(lVar6 + 0xc4) = 0;
+    local_res10 = local_80;
+    piVar5 = (int *)FUN_140006c30(lVar6,local_80);
+    local_b8 = *(undefined8 *)(lVar6 + 0xb8);
+    local_b0 = *(undefined8 *)(lVar6 + 0xc0);
+    local_a8 = *(undefined8 *)(lVar6 + 200);
+    local_a0 = *(undefined8 *)(lVar6 + 0xd0);
+    uVar3 = *(undefined4 *)(lVar6 + 4);
+    lVar9 = *(longlong *)(param_1 + 0x48);
+    piVar2 = (int *)(lVar9 + 0x28);
+    local_c8 = piVar5;
+    FUN_14002e6e0(piVar2);
+    plVar4 = *(longlong **)(lVar9 + 8);
+    if (*plVar4 == 0) {
+      FUN_14002e770((longlong)piVar2);
+      lVar9 = lVar10;
+    }
+    else {
+      lVar9 = *plVar4;
+      FUN_14002e770((longlong)piVar2);
+    }
+    local_res10 = (undefined8 *)CONCAT44(local_res10._4_4_,uVar3);
+    (**(code **)(*(longlong *)(lVar9 + 0x68) + 0x40))
+              ((longlong *)(lVar9 + 0x68),1,&DAT_1401555d0,&local_res10,&local_b8,piVar5);
+    if (*(void **)piVar5 != (void *)0x0) {
+      operator_delete(*(void **)piVar5);
+    }
+    piVar5[0] = 0;
+    piVar5[1] = 0;
+    piVar5[2] = 0;
+    piVar5[3] = 0;
+    piVar5[4] = 0;
+    piVar5[5] = 0;
+    uVar3 = *(undefined4 *)(lVar6 + 4);
+    lVar6 = *(longlong *)(local_res8 + 0x48);
+    FUN_14002e6e0((int *)(lVar6 + 0x28));
+    if (**(longlong **)(lVar6 + 8) != 0) {
+      lVar10 = **(longlong **)(lVar6 + 8);
+    }
+    FUN_14002e770(lVar6 + 0x28);
+    local_c8 = (int *)CONCAT44(local_c8._4_4_,1);
+    local_res10 = (undefined8 *)CONCAT44(local_res10._4_4_,uVar3);
+    local_res8 = CONCAT71(local_res8._1_7_,1);
+    (**(code **)(*(longlong *)(lVar10 + 0x68) + 0x50))
+              ((longlong *)(lVar10 + 0x68),1,&DAT_1401555d0,&local_res8,&local_c8,&local_res10);
+  }
+  FUN_14002e770((longlong)piVar1);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140005940.c

@@ -0,0 +1,10 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140005940 FUN_140005940
+ * Pseudocode, not original source. */
+
+undefined1 FUN_140005940(void)
+
+{
+  return 1;
+}
+

decomp/Agent_Release_x64/full/functions/0x140005950.c

@@ -0,0 +1,179 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140005950 FUN_140005950
+ * Pseudocode, not original source. */
+
+/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
+
+void FUN_140005950(longlong param_1,short *param_2,undefined8 param_3,uint *param_4)
+
+{
+  ulonglong *puVar1;
+  ulonglong *puVar2;
+  ulonglong *puVar3;
+  BOOL BVar4;
+  HANDLE hProcess;
+  longlong lVar5;
+  char *_Format;
+  short *psVar6;
+  wchar_t *pwVar7;
+  ulonglong *puVar8;
+  short *psVar9;
+  wchar_t *pwVar10;
+  bool bVar11;
+  undefined1 auStack_188 [32];
+  DWORD local_168 [2];
+  ulonglong *local_160;
+  ulonglong *local_158;
+  undefined8 local_150;
+  undefined8 local_140;
+  undefined4 local_138 [10];
+  void *local_110;
+  ulonglong local_f8;
+  undefined2 local_e8;
+  undefined6 uStack_e6;
+  undefined8 local_d8;
+  ulonglong local_d0;
+  undefined2 local_c0;
+  undefined6 uStack_be;
+  undefined8 local_b0;
+  ulonglong local_a8;
+  undefined8 local_98;
+  ulonglong uStack_90;
+  ulonglong local_88;
+  ulonglong local_80;
+  ulonglong local_78;
+  ulonglong local_70;
+  ulonglong local_68;
+  void *local_60;
+  undefined8 local_58;
+  undefined8 local_50;
+  ulonglong local_38;
+  
+  local_140 = 0xfffffffffffffffe;
+  local_38 = DAT_1401555a0 ^ (ulonglong)auStack_188;
+  bVar11 = local_38 == 0;
+  lVar5 = 7;
+  pwVar7 = param_2;
+  pwVar10 = L"update";
+  do {
+    if (lVar5 == 0) break;
+    lVar5 = lVar5 + -1;
+    bVar11 = *pwVar7 == *pwVar10;
+    pwVar7 = pwVar7 + 1;
+    pwVar10 = pwVar10 + 1;
+  } while (bVar11);
+  if (!bVar11) {
+    lVar5 = 5;
+    psVar6 = param_2;
+    psVar9 = &DAT_14011ca78;
+    do {
+      if (lVar5 == 0) break;
+      lVar5 = lVar5 + -1;
+      bVar11 = *psVar6 == *psVar9;
+      psVar6 = psVar6 + 1;
+      psVar9 = psVar9 + 1;
+    } while (bVar11);
+    if (bVar11) {
+      local_160 = (ulonglong *)0x0;
+      local_158 = (ulonglong *)0x0;
+      local_150 = 0;
+      FUN_14002ce60(DAT_140162d60,(ulonglong *)&local_160);
+      puVar3 = local_158;
+      puVar2 = local_160;
+      if (local_160 != local_158) {
+        puVar8 = local_160 + 0x17;
+        do {
+          FUN_140004ea0(local_138,(undefined4 *)(puVar8 + -0x17));
+          local_98 = puVar8[-3];
+          uStack_90 = puVar8[-2];
+          local_88 = puVar8[-1];
+          local_80 = *puVar8;
+          local_78 = puVar8[1];
+          local_70 = puVar8[2];
+          local_68 = puVar8[3];
+          FUN_140004d60(&local_60,(longlong *)(puVar8 + 4));
+          hProcess = OpenProcess(0x1f0fff,0,local_98._4_4_);
+          if (hProcess != (HANDLE)0x0) {
+            BVar4 = GetExitCodeProcess(hProcess,local_168);
+            if ((BVar4 != 0) && (local_168[0] == 0x103)) {
+              TerminateProcess(hProcess,0);
+            }
+            CloseHandle(hProcess);
+          }
+          if (local_60 != (void *)0x0) {
+            operator_delete(local_60);
+          }
+          local_60 = (void *)0x0;
+          local_58 = 0;
+          local_50 = 0;
+          if (7 < local_a8) {
+            operator_delete((void *)CONCAT62(uStack_be,local_c0));
+          }
+          local_a8 = 7;
+          local_b0 = 0;
+          local_c0 = 0;
+          if (7 < local_d0) {
+            operator_delete((void *)CONCAT62(uStack_e6,local_e8));
+          }
+          local_d0 = 7;
+          local_d8 = 0;
+          local_e8 = 0;
+          if (7 < local_f8) {
+            operator_delete(local_110);
+          }
+          puVar1 = puVar8 + 8;
+          puVar8 = puVar8 + 0x1f;
+        } while (puVar1 != puVar3);
+      }
+      if (puVar2 != (ulonglong *)0x0) {
+        FUN_140004b30(puVar2,puVar3);
+        operator_delete(puVar2);
+      }
+    }
+    else {
+      lVar5 = 5;
+      psVar6 = param_2;
+      psVar9 = &DAT_14011ca88;
+      do {
+        if (lVar5 == 0) break;
+        lVar5 = lVar5 + -1;
+        bVar11 = *psVar6 == *psVar9;
+        psVar6 = psVar6 + 1;
+        psVar9 = psVar9 + 1;
+      } while (bVar11);
+      if (bVar11) {
+        bVar11 = *(char *)(DAT_140162d68 + 0x171) == '\0';
+        *(bool *)(DAT_140162d68 + 0x171) = bVar11;
+        _Format = "Auto Revive On !!!\n";
+        if (!bVar11) {
+          _Format = "Auto Revive Off !!!\n";
+        }
+        printf(_Format);
+        FUN_140006940(param_1,7,param_3,(longlong)param_4);
+        if (*(longlong *)(DAT_1401626f8 + 0xa8) != 0) {
+          FUN_140008a40(*(longlong *)(DAT_1401626f8 + 0xa8));
+        }
+      }
+      else {
+        lVar5 = 9;
+        pwVar7 = param_2;
+        pwVar10 = L"serveron";
+        do {
+          if (lVar5 == 0) break;
+          lVar5 = lVar5 + -1;
+          bVar11 = *pwVar7 == *pwVar10;
+          pwVar7 = pwVar7 + 1;
+          pwVar10 = pwVar10 + 1;
+        } while (bVar11);
+        if (bVar11) {
+          FUN_140009890(lVar5,param_2,param_3,param_4);
+        }
+        else {
+          FUN_140006520(param_1,param_2,param_3,(longlong)param_4);
+        }
+      }
+    }
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140005bf0.c

@@ -0,0 +1,202 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140005bf0 FUN_140005bf0
+ * Pseudocode, not original source. */
+
+void FUN_140005bf0(longlong param_1,ulonglong param_2,uint param_3,ulonglong param_4,short *param_5)
+
+{
+  uint uVar1;
+  uint uVar2;
+  uint uVar3;
+  int *piVar4;
+  uint *puVar5;
+  longlong lVar6;
+  longlong *plVar7;
+  undefined ***pppuVar8;
+  uint *puVar9;
+  LPVOID pvVar10;
+  uint uVar11;
+  ulonglong uVar12;
+  LPVOID pvVar13;
+  undefined *puVar14;
+  uint uVar15;
+  uint *local_68;
+  undefined8 local_60;
+  int *local_58;
+  undefined1 local_50;
+  undefined **local_48;
+  longlong *local_40;
+  LPVOID local_38;
+  ulonglong local_30;
+  undefined8 local_28;
+  
+  local_60 = 0xfffffffffffffffe;
+  local_48 = Proud::CFastArray<Proud::HostID,0>::vftable;
+  uVar15 = 0;
+  local_40 = (longlong *)0x0;
+  local_38 = (LPVOID)0x0;
+  local_30 = 0;
+  local_28 = 0;
+  lVar6 = DAT_140162d60;
+  if (param_3 == 0) {
+    uVar12 = param_2 & 0xffffffff;
+    pppuVar8 = &local_48;
+    FUN_14002cb80(DAT_140162d60,(longlong)pppuVar8,uVar12,param_4);
+  }
+  else {
+    param_4 = (ulonglong)(byte)param_3;
+    uVar12 = param_2 & 0xffffffff;
+    pppuVar8 = &local_48;
+    FUN_14002cce0(DAT_140162d60,(longlong)pppuVar8,uVar12,param_4);
+  }
+  FUN_140030200(lVar6,pppuVar8,uVar12,param_4);
+  local_68 = (uint *)PTR_DAT_140155010;
+  uVar1 = FUN_140030080(param_5);
+  uVar3 = 0;
+  pvVar13 = (LPVOID)0x0;
+  if ((local_68 != (uint *)0x0) && (pvVar13 = (LPVOID)0x0, local_68 != (uint *)PTR_DAT_140155010)) {
+    pvVar13 = (LPVOID)(ulonglong)local_68[-2];
+  }
+  uVar2 = uVar1;
+  if ((((int)uVar1 <= (int)pvVar13) && (uVar2 = uVar3, local_68 != (uint *)0x0)) &&
+     (local_68 != (uint *)PTR_DAT_140155010)) {
+    uVar2 = local_68[-2];
+  }
+  uVar11 = 1;
+  if (1 < (int)uVar2) {
+    uVar11 = uVar2;
+  }
+  uVar2 = uVar3;
+  if ((local_68 != (uint *)0x0) && (local_68 != (uint *)PTR_DAT_140155010)) {
+    uVar2 = local_68[-2];
+  }
+  if ((int)uVar2 < (int)uVar11) {
+    puVar5 = local_68;
+    if (local_68 == (uint *)0x0) {
+      puVar5 = (uint *)PTR_DAT_140155010;
+    }
+    local_68 = puVar5;
+    if ((int)uVar11 < 0) {
+                    /* WARNING: Subroutine does not return */
+      FUN_14002f590();
+    }
+    if (uVar11 == 0) {
+      local_68 = (uint *)PTR_DAT_140155010;
+      if (((puVar5 != (uint *)0x0) && (puVar5 != (uint *)PTR_DAT_140155010)) &&
+         (puVar5 + -2 != (uint *)0x0)) {
+        local_68 = puVar5;
+        piVar4 = (int *)FUN_140030200(puVar5,PTR_DAT_140155010,pvVar13,param_4);
+        local_58 = piVar4;
+        FUN_14002e6e0(piVar4);
+        local_50 = 1;
+        puVar9 = puVar5 + -1;
+        *puVar9 = *puVar9 - 1;
+        if (*puVar9 == 0) {
+          FUN_1400302f0(puVar5 + -2);
+        }
+        FUN_14002e770((longlong)piVar4);
+        local_68 = (uint *)PTR_DAT_140155010;
+      }
+    }
+    else {
+      uVar2 = uVar3;
+      if ((puVar5 != (uint *)0x0) && (puVar5 != (uint *)PTR_DAT_140155010)) {
+        uVar2 = puVar5[-2];
+      }
+      if (uVar11 != uVar2) {
+        puVar5 = (uint *)FUN_140030280((longlong)(int)uVar11 * 2 + 10);
+        if (puVar5 != (uint *)0x0) {
+          *puVar5 = 0;
+          puVar5[1] = 1;
+        }
+        *puVar5 = uVar11;
+        uVar2 = uVar3;
+        if ((local_68 != (uint *)0x0) && (local_68 != (uint *)PTR_DAT_140155010)) {
+          uVar2 = local_68[-2];
+        }
+        puVar9 = (uint *)PTR_DAT_140155010;
+        if ((int)uVar11 < (int)uVar2) {
+LAB_140005d9e:
+          if (local_68 != (uint *)0x0) {
+            puVar9 = local_68;
+          }
+        }
+        else {
+          uVar11 = uVar3;
+          if (local_68 != (uint *)0x0) {
+            if (local_68 != (uint *)PTR_DAT_140155010) {
+              uVar11 = local_68[-2];
+            }
+            goto LAB_140005d9e;
+          }
+        }
+        uVar12 = (ulonglong)uVar11;
+        FUN_1400300b0(puVar5 + 2,puVar9,uVar11);
+        FUN_140003240((longlong *)&local_68,puVar9,uVar12,param_4);
+        local_68 = puVar5 + 2;
+      }
+    }
+  }
+  FUN_140002ea0((longlong *)&local_68);
+  puVar5 = local_68;
+  if (local_68 == (uint *)0x0) {
+    puVar5 = (uint *)PTR_DAT_140155010;
+  }
+  FUN_1400300b0(puVar5,param_5,uVar1);
+  puVar5 = local_68;
+  if (local_68 == (uint *)0x0) {
+    puVar5 = (uint *)PTR_DAT_140155010;
+  }
+  uVar3 = FUN_140030080((short *)puVar5);
+  pvVar13 = local_38;
+  uVar1 = uVar15;
+  if (0 < (int)uVar3) {
+    uVar1 = uVar3;
+  }
+  uVar3 = uVar15;
+  if ((local_68 != (uint *)0x0) && (local_68 != (uint *)PTR_DAT_140155010)) {
+    uVar3 = local_68[-2];
+  }
+  if (((int)uVar3 <= (int)uVar1) && (uVar1 = uVar15, local_68 != (uint *)0x0)) {
+    if (local_68 == (uint *)PTR_DAT_140155010) goto LAB_140005e4f;
+    uVar1 = local_68[-2];
+  }
+  if (((local_68 != (uint *)PTR_DAT_140155010) && (local_68 != (uint *)0x0)) &&
+     (local_68 + -2 != (uint *)0x0)) {
+    local_68[-2] = uVar1;
+    *(undefined2 *)((longlong)local_68 + (longlong)(int)uVar1 * 2) = 0;
+  }
+LAB_140005e4f:
+  uVar12 = local_30 & 0xffffffff;
+  pvVar10 = local_38;
+  if ((int)local_30 == 0) {
+    pvVar10 = (LPVOID)0x0;
+  }
+  plVar7 = (longlong *)(param_1 + 0x50);
+  puVar14 = &DAT_1401555d0;
+  (**(code **)(*plVar7 + 0x48))();
+  puVar5 = local_68;
+  if (((local_68 != (uint *)0x0) && (local_68 != (uint *)PTR_DAT_140155010)) &&
+     (puVar9 = local_68 + -2, puVar9 != (uint *)0x0)) {
+    piVar4 = (int *)FUN_140030200(plVar7,pvVar10,uVar12,puVar14);
+    local_58 = piVar4;
+    FUN_14002e6e0(piVar4);
+    local_50 = 1;
+    puVar5 = puVar5 + -1;
+    *puVar5 = *puVar5 - 1;
+    if (*puVar5 == 0) {
+      FUN_1400302f0(puVar9);
+    }
+    FUN_14002e770((longlong)piVar4);
+  }
+  if (pvVar13 != (LPVOID)0x0) {
+    if (local_40 == (longlong *)0x0) {
+      FUN_1400302f0(pvVar13);
+    }
+    else {
+      (**(code **)(*local_40 + 0x18))(local_40,pvVar13);
+    }
+  }
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140005f10.c

@@ -0,0 +1,53 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140005f10 FUN_140005f10
+ * Pseudocode, not original source. */
+
+void FUN_140005f10(longlong param_1,undefined4 param_2,undefined8 param_3,longlong param_4)
+
+{
+  LPVOID pvVar1;
+  LPVOID pvVar2;
+  undefined4 local_res10 [2];
+  undefined **local_30;
+  longlong *local_28;
+  LPVOID local_20;
+  ulonglong local_18;
+  undefined8 local_10;
+  
+  local_30 = Proud::CFastArray<Proud::HostID,0>::vftable;
+  local_28 = (longlong *)0x0;
+  local_20 = (LPVOID)0x0;
+  local_18 = 0;
+  local_10 = 0;
+  local_res10[0] = param_2;
+  FUN_14002ca30(DAT_140162d60,(longlong)&local_30,param_3,param_4);
+  pvVar1 = local_20;
+  if ((int)local_18 < 1) {
+    if (local_20 == (LPVOID)0x0) {
+      return;
+    }
+    if (local_28 != (longlong *)0x0) {
+      (**(code **)(*local_28 + 0x18))(local_28,local_20);
+      return;
+    }
+  }
+  else {
+    pvVar2 = local_20;
+    if ((int)local_18 == 0) {
+      pvVar2 = (LPVOID)0x0;
+    }
+    (**(code **)(*(longlong *)(param_1 + 0x50) + 0x58))
+              ((longlong *)(param_1 + 0x50),pvVar2,local_18 & 0xffffffff,&DAT_1401555d0,local_res10)
+    ;
+    if (pvVar1 == (LPVOID)0x0) {
+      return;
+    }
+    if (local_28 != (longlong *)0x0) {
+      (**(code **)(*local_28 + 0x18))(local_28,pvVar1);
+      return;
+    }
+  }
+  FUN_1400302f0(pvVar1);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x140005ff0.c

@@ -0,0 +1,57 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140005ff0 FUN_140005ff0
+ * Pseudocode, not original source. */
+
+void FUN_140005ff0(longlong param_1,undefined4 param_2,undefined8 param_3,longlong param_4)
+
+{
+  LPVOID pvVar1;
+  LPVOID pvVar2;
+  undefined4 local_res10 [2];
+  undefined4 local_res18 [2];
+  undefined4 local_res20 [2];
+  undefined **local_40;
+  longlong *local_38;
+  LPVOID local_30;
+  ulonglong local_28;
+  undefined8 local_20;
+  
+  local_res20[0] = (undefined4)param_4;
+  local_res18[0] = (undefined4)param_3;
+  local_40 = Proud::CFastArray<Proud::HostID,0>::vftable;
+  local_38 = (longlong *)0x0;
+  local_30 = (LPVOID)0x0;
+  local_28 = 0;
+  local_20 = 0;
+  local_res10[0] = param_2;
+  FUN_14002ca30(DAT_140162d60,(longlong)&local_40,param_3,param_4);
+  pvVar1 = local_30;
+  if ((int)local_28 < 1) {
+    if (local_30 == (LPVOID)0x0) {
+      return;
+    }
+    if (local_38 != (longlong *)0x0) {
+      (**(code **)(*local_38 + 0x18))(local_38,local_30);
+      return;
+    }
+  }
+  else {
+    pvVar2 = local_30;
+    if ((int)local_28 == 0) {
+      pvVar2 = (LPVOID)0x0;
+    }
+    (**(code **)(*(longlong *)(param_1 + 0x50) + 0x68))
+              ((longlong *)(param_1 + 0x50),pvVar2,local_28 & 0xffffffff,&DAT_1401555d0,local_res10,
+               local_res18,local_res20);
+    if (pvVar1 == (LPVOID)0x0) {
+      return;
+    }
+    if (local_38 != (longlong *)0x0) {
+      (**(code **)(*local_38 + 0x18))(local_38,pvVar1);
+      return;
+    }
+  }
+  FUN_1400302f0(pvVar1);
+  return;
+}
+

decomp/Agent_Release_x64/full/functions/0x1400060f0.c

@@ -0,0 +1,201 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x1400060f0 FUN_1400060f0
+ * Pseudocode, not original source. */
+
+void FUN_1400060f0(longlong param_1,uint param_2,short *param_3,longlong param_4)
+
+{
+  uint uVar1;
+  uint uVar2;
+  uint uVar3;
+  int *piVar4;
+  uint *puVar5;
+  longlong lVar6;
+  longlong *plVar7;
+  LPVOID pvVar8;
+  undefined ***pppuVar9;
+  uint *puVar10;
+  LPVOID pvVar11;
+  uint uVar12;
+  ulonglong uVar13;
+  undefined *puVar14;
+  uint uVar15;
+  uint *local_res20;
+  undefined **local_50;
+  longlong *local_48;
+  LPVOID local_40;
+  ulonglong local_38;
+  undefined8 local_30;
+  
+  local_50 = Proud::CFastArray<Proud::HostID,0>::vftable;
+  uVar15 = 0;
+  local_48 = (longlong *)0x0;
+  local_40 = (LPVOID)0x0;
+  local_38 = 0;
+  local_30 = 0;
+  uVar13 = (ulonglong)param_2;
+  pppuVar9 = &local_50;
+  lVar6 = DAT_140162d60;
+  FUN_14002cb80(DAT_140162d60,(longlong)pppuVar9,uVar13,param_4);
+  if ((int)local_38 < 1) {
+    if (local_40 == (LPVOID)0x0) {
+      return;
+    }
+    pvVar8 = local_40;
+    if (local_48 != (longlong *)0x0) {
+      (**(code **)(*local_48 + 0x18))(local_48,local_40);
+      return;
+    }
+    goto LAB_1400063f6;
+  }
+  FUN_140030200(lVar6,pppuVar9,uVar13,param_4);
+  local_res20 = (uint *)PTR_DAT_140155010;
+  uVar1 = FUN_140030080(param_3);
+  uVar3 = 0;
+  pvVar8 = (LPVOID)0x0;
+  if ((local_res20 != (uint *)0x0) &&
+     (pvVar8 = (LPVOID)0x0, local_res20 != (uint *)PTR_DAT_140155010)) {
+    pvVar8 = (LPVOID)(ulonglong)local_res20[-2];
+  }
+  uVar2 = uVar1;
+  if ((((int)uVar1 <= (int)pvVar8) && (uVar2 = uVar3, local_res20 != (uint *)0x0)) &&
+     (local_res20 != (uint *)PTR_DAT_140155010)) {
+    uVar2 = local_res20[-2];
+  }
+  uVar12 = 1;
+  if (1 < (int)uVar2) {
+    uVar12 = uVar2;
+  }
+  uVar2 = uVar3;
+  if ((local_res20 != (uint *)0x0) && (local_res20 != (uint *)PTR_DAT_140155010)) {
+    uVar2 = local_res20[-2];
+  }
+  if ((int)uVar2 < (int)uVar12) {
+    puVar5 = local_res20;
+    if (local_res20 == (uint *)0x0) {
+      puVar5 = (uint *)PTR_DAT_140155010;
+    }
+    local_res20 = puVar5;
+    if ((int)uVar12 < 0) {
+                    /* WARNING: Subroutine does not return */
+      FUN_14002f590();
+    }
+    if (uVar12 == 0) {
+      local_res20 = (uint *)PTR_DAT_140155010;
+      if (((puVar5 != (uint *)0x0) && (puVar5 != (uint *)PTR_DAT_140155010)) &&
+         (puVar5 + -2 != (uint *)0x0)) {
+        local_res20 = puVar5;
+        piVar4 = (int *)FUN_140030200(puVar5,PTR_DAT_140155010,pvVar8,param_4);
+        FUN_14002e6e0(piVar4);
+        puVar10 = puVar5 + -1;
+        *puVar10 = *puVar10 - 1;
+        if (*puVar10 == 0) {
+          FUN_1400302f0(puVar5 + -2);
+        }
+        FUN_14002e770((longlong)piVar4);
+        local_res20 = (uint *)PTR_DAT_140155010;
+      }
+    }
+    else {
+      uVar2 = uVar3;
+      if ((puVar5 != (uint *)0x0) && (puVar5 != (uint *)PTR_DAT_140155010)) {
+        uVar2 = puVar5[-2];
+      }
+      if (uVar12 != uVar2) {
+        puVar5 = (uint *)FUN_140030280((longlong)(int)uVar12 * 2 + 10);
+        if (puVar5 != (uint *)0x0) {
+          *puVar5 = 0;
+          puVar5[1] = 1;
+        }
+        *puVar5 = uVar12;
+        uVar2 = uVar3;
+        if ((local_res20 != (uint *)0x0) && (local_res20 != (uint *)PTR_DAT_140155010)) {
+          uVar2 = local_res20[-2];
+        }
+        puVar10 = (uint *)PTR_DAT_140155010;
+        if ((int)uVar12 < (int)uVar2) {
+LAB_1400062b2:
+          if (local_res20 != (uint *)0x0) {
+            puVar10 = local_res20;
+          }
+        }
+        else {
+          uVar12 = uVar3;
+          if (local_res20 != (uint *)0x0) {
+            if (local_res20 != (uint *)PTR_DAT_140155010) {
+              uVar12 = local_res20[-2];
+            }
+            goto LAB_1400062b2;
+          }
+        }
+        uVar13 = (ulonglong)uVar12;
+        FUN_1400300b0(puVar5 + 2,puVar10,uVar12);
+        FUN_140003240((longlong *)&local_res20,puVar10,uVar13,param_4);
+        local_res20 = puVar5 + 2;
+      }
+    }
+  }
+  FUN_140002ea0((longlong *)&local_res20);
+  puVar5 = local_res20;
+  if (local_res20 == (uint *)0x0) {
+    puVar5 = (uint *)PTR_DAT_140155010;
+  }
+  FUN_1400300b0(puVar5,param_3,uVar1);
+  puVar5 = local_res20;
+  if (local_res20 == (uint *)0x0) {
+    puVar5 = (uint *)PTR_DAT_140155010;
+  }
+  uVar3 = FUN_140030080((short *)puVar5);
+  pvVar8 = local_40;
+  uVar1 = uVar15;
+  if (0 < (int)uVar3) {
+    uVar1 = uVar3;
+  }
+  uVar3 = uVar15;
+  if ((local_res20 != (uint *)0x0) && (local_res20 != (uint *)PTR_DAT_140155010)) {
+    uVar3 = local_res20[-2];
+  }
+  if (((int)uVar1 < (int)uVar3) || (uVar1 = uVar15, local_res20 == (uint *)0x0)) {
+LAB_140006344:
+    if (((local_res20 != (uint *)PTR_DAT_140155010) && (local_res20 != (uint *)0x0)) &&
+       (local_res20 + -2 != (uint *)0x0)) {
+      local_res20[-2] = uVar1;
+      *(undefined2 *)((longlong)local_res20 + (longlong)(int)uVar1 * 2) = 0;
+    }
+  }
+  else if (local_res20 != (uint *)PTR_DAT_140155010) {
+    uVar1 = local_res20[-2];
+    goto LAB_140006344;
+  }
+  pvVar11 = local_40;
+  if ((int)local_38 == 0) {
+    pvVar11 = (LPVOID)0x0;
+  }
+  plVar7 = (longlong *)(param_1 + 0x50);
+  puVar14 = &DAT_1401555d0;
+  uVar13 = local_38 & 0xffffffff;
+  (**(code **)(*plVar7 + 0x78))();
+  puVar5 = local_res20;
+  if (((local_res20 != (uint *)0x0) && (local_res20 != (uint *)PTR_DAT_140155010)) &&
+     (puVar10 = local_res20 + -2, puVar10 != (uint *)0x0)) {
+    piVar4 = (int *)FUN_140030200(plVar7,pvVar11,uVar13,puVar14);
+    FUN_14002e6e0(piVar4);
+    puVar5 = puVar5 + -1;
+    *puVar5 = *puVar5 - 1;
+    if (*puVar5 == 0) {
+      FUN_1400302f0(puVar10);
+    }
+    FUN_14002e770((longlong)piVar4);
+  }
+  if (pvVar8 == (LPVOID)0x0) {
+    return;
+  }
+  if (local_48 != (longlong *)0x0) {
+    (**(code **)(*local_48 + 0x18))(local_48,pvVar8);
+    return;
+  }
+LAB_1400063f6:
+  FUN_1400302f0(pvVar8);
+  return;
+}
+