decompiled agent_release

2026-10-14 16:45:19 -04:00 · 2026-10-14 16:45:19 -04:00 · 11a3488883
commit 11a3488883
parent baac905ef2
6439 changed files with 229565 additions and 1 deletions
--- a/decomp/Agent_Release_x64/full/functions/0x140001020.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001060.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400011d0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001260.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001300.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001340.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001390.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001550.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001600.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400016e0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400017d0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001870.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400018f0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001a50.c
+++ b/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);
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001ac0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001af0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001b20.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001b50.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001bb0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001bf0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001ce0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001dc0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001e70.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140001f00.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140002010.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400020d0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140002130.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140002180.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400023b0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400023e0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400024f0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140002640.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400026f0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140002990.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140002bc0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140002cd0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140002dc0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140002ea0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140002f90.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140003010.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140003070.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400030f0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140003170.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140003210.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140003240.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400032e0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400032f0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140003320.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140003360.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400033f0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140003420.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400034a0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400036c0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400037a0.c
+++ b/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 );
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140003f30.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004950.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004a00.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004a60.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004af0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004b30.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004c00.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004c10.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004c40.c
+++ b/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);
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004cb0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004d20.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004d60.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004e10.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004ea0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004f80.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140004fc0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140005000.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140005020.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140005100.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140005130.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140005200.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400052a0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140005340.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140005360.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400053e0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140005620.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400056f0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140005940.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140005950.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140005bf0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140005f10.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140005ff0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x1400060f0.c
+++ b/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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140006420.c
+++ b/decomp/Agent_Release_x64/full/functions/0x140006420.c
@ -0,0 +1,57 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140006420 FUN_140006420
+ * Pseudocode, not original source. */
+
+void FUN_140006420(longlong param_1,uint param_2,undefined4 param_3,longlong param_4)
+
+{
+  LPVOID pvVar1;
+  LPVOID pvVar2;
+  uint local_res10 [2];
+  undefined4 local_res18 [2];
+  undefined8 uVar3;
+  undefined **local_30;
+  longlong *local_28;
+  LPVOID local_20;
+  ulonglong local_18;
+  undefined8 local_10;
+  
+  uVar3 = 0xfffffffffffffffe;
+  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;
+  local_res18[0] = param_3;
+  FUN_14002cb80(DAT_140162d60,(longlong)&local_30,(ulonglong)param_2,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) + 0x88))
+              ((longlong *)(param_1 + 0x50),pvVar2,local_18 & 0xffffffff,&DAT_1401555d0,local_res10,
+               local_res18,uVar3);
+    if (pvVar1 == (LPVOID)0x0) {
+      return;
+    }
+    if (local_28 != (longlong *)0x0) {
+      (**(code **)(*local_28 + 0x18))(local_28,pvVar1);
+      return;
+    }
+  }
+  FUN_1400302f0(pvVar1);
+  return;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140006520.c
+++ b/decomp/Agent_Release_x64/full/functions/0x140006520.c
@ -0,0 +1,200 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140006520 FUN_140006520
+ * Pseudocode, not original source. */
+
+void FUN_140006520(longlong param_1,short *param_2,undefined8 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_res18 [2];
+  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;
+  pppuVar9 = &local_50;
+  lVar6 = DAT_140162d60;
+  FUN_14002ca30(DAT_140162d60,(longlong)pppuVar9,param_3,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_140006826;
+  }
+  FUN_140030200(lVar6,pppuVar9,param_3,param_4);
+  local_res18[0] = (uint *)PTR_DAT_140155010;
+  uVar1 = FUN_140030080(param_2);
+  uVar3 = 0;
+  pvVar8 = (LPVOID)0x0;
+  if ((local_res18[0] != (uint *)0x0) &&
+     (pvVar8 = (LPVOID)0x0, local_res18[0] != (uint *)PTR_DAT_140155010)) {
+    pvVar8 = (LPVOID)(ulonglong)local_res18[0][-2];
+  }
+  uVar2 = uVar1;
+  if ((((int)uVar1 <= (int)pvVar8) && (uVar2 = uVar3, local_res18[0] != (uint *)0x0)) &&
+     (local_res18[0] != (uint *)PTR_DAT_140155010)) {
+    uVar2 = local_res18[0][-2];
+  }
+  uVar12 = 1;
+  if (1 < (int)uVar2) {
+    uVar12 = uVar2;
+  }
+  uVar2 = uVar3;
+  if ((local_res18[0] != (uint *)0x0) && (local_res18[0] != (uint *)PTR_DAT_140155010)) {
+    uVar2 = local_res18[0][-2];
+  }
+  if ((int)uVar2 < (int)uVar12) {
+    puVar5 = local_res18[0];
+    if (local_res18[0] == (uint *)0x0) {
+      puVar5 = (uint *)PTR_DAT_140155010;
+    }
+    local_res18[0] = puVar5;
+    if ((int)uVar12 < 0) {
+                    /* WARNING: Subroutine does not return */
+      FUN_14002f590();
+    }
+    if (uVar12 == 0) {
+      local_res18[0] = (uint *)PTR_DAT_140155010;
+      if (((puVar5 != (uint *)0x0) && (puVar5 != (uint *)PTR_DAT_140155010)) &&
+         (puVar5 + -2 != (uint *)0x0)) {
+        local_res18[0] = 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_res18[0] = (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_res18[0] != (uint *)0x0) && (local_res18[0] != (uint *)PTR_DAT_140155010)) {
+          uVar2 = local_res18[0][-2];
+        }
+        puVar10 = (uint *)PTR_DAT_140155010;
+        if ((int)uVar12 < (int)uVar2) {
+LAB_1400066df:
+          if (local_res18[0] != (uint *)0x0) {
+            puVar10 = local_res18[0];
+          }
+        }
+        else {
+          uVar12 = uVar3;
+          if (local_res18[0] != (uint *)0x0) {
+            if (local_res18[0] != (uint *)PTR_DAT_140155010) {
+              uVar12 = local_res18[0][-2];
+            }
+            goto LAB_1400066df;
+          }
+        }
+        uVar13 = (ulonglong)uVar12;
+        FUN_1400300b0(puVar5 + 2,puVar10,uVar12);
+        FUN_140003240((longlong *)local_res18,puVar10,uVar13,param_4);
+        local_res18[0] = puVar5 + 2;
+      }
+    }
+  }
+  FUN_140002ea0((longlong *)local_res18);
+  puVar5 = local_res18[0];
+  if (local_res18[0] == (uint *)0x0) {
+    puVar5 = (uint *)PTR_DAT_140155010;
+  }
+  FUN_1400300b0(puVar5,param_2,uVar1);
+  puVar5 = local_res18[0];
+  if (local_res18[0] == (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_res18[0] != (uint *)0x0) && (local_res18[0] != (uint *)PTR_DAT_140155010)) {
+    uVar3 = local_res18[0][-2];
+  }
+  if (((int)uVar1 < (int)uVar3) || (uVar1 = uVar15, local_res18[0] == (uint *)0x0)) {
+LAB_140006771:
+    if (((local_res18[0] != (uint *)PTR_DAT_140155010) && (local_res18[0] != (uint *)0x0)) &&
+       (local_res18[0] + -2 != (uint *)0x0)) {
+      local_res18[0][-2] = uVar1;
+      *(undefined2 *)((longlong)local_res18[0] + (longlong)(int)uVar1 * 2) = 0;
+    }
+  }
+  else if (local_res18[0] != (uint *)PTR_DAT_140155010) {
+    uVar1 = local_res18[0][-2];
+    goto LAB_140006771;
+  }
+  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 + 0x98))();
+  puVar5 = local_res18[0];
+  if (((local_res18[0] != (uint *)0x0) && (local_res18[0] != (uint *)PTR_DAT_140155010)) &&
+     (puVar10 = local_res18[0] + -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_140006826:
+  FUN_1400302f0(pvVar8);
+  return;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140006850.c
+++ b/decomp/Agent_Release_x64/full/functions/0x140006850.c
@ -0,0 +1,58 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140006850 FUN_140006850
+ * Pseudocode, not original source. */
+
+void FUN_140006850(longlong param_1,undefined1 param_2,ulonglong param_3,undefined8 param_4)
+
+{
+  LPVOID pvVar1;
+  LPVOID pvVar2;
+  undefined1 local_68 [4];
+  undefined4 local_64;
+  undefined **local_60;
+  longlong *local_58;
+  LPVOID local_50;
+  ulonglong local_48;
+  undefined8 local_40;
+  undefined8 local_38;
+  
+  local_38 = 0xfffffffffffffffe;
+  local_64 = (undefined4)param_3;
+  local_60 = Proud::CFastArray<Proud::HostID,0>::vftable;
+  local_58 = (longlong *)0x0;
+  local_50 = (LPVOID)0x0;
+  local_48 = 0;
+  local_40 = 0;
+  local_68[0] = param_2;
+  FUN_14002cce0(DAT_140162d60,(longlong)&local_60,param_3,
+                CONCAT71((int7)((ulonglong)param_4 >> 8),9));
+  pvVar1 = local_50;
+  if ((int)local_48 < 1) {
+    if (local_50 == (LPVOID)0x0) {
+      return;
+    }
+    if (local_58 != (longlong *)0x0) {
+      (**(code **)(*local_58 + 0x18))(local_58,local_50);
+      return;
+    }
+  }
+  else {
+    pvVar2 = local_50;
+    if ((int)local_48 == 0) {
+      pvVar2 = (LPVOID)0x0;
+    }
+    (**(code **)(*(longlong *)(param_1 + 0x50) + 0xa8))
+              ((longlong *)(param_1 + 0x50),pvVar2,local_48 & 0xffffffff,&DAT_1401555d0,local_68,
+               &local_64,param_4);
+    if (pvVar1 == (LPVOID)0x0) {
+      return;
+    }
+    if (local_58 != (longlong *)0x0) {
+      (**(code **)(*local_58 + 0x18))(local_58,pvVar1);
+      return;
+    }
+  }
+  FUN_1400302f0(pvVar1);
+  return;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140006940.c
+++ b/decomp/Agent_Release_x64/full/functions/0x140006940.c
@ -0,0 +1,53 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140006940 FUN_140006940
+ * Pseudocode, not original source. */
+
+void FUN_140006940(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) + 0x38))
+              ((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;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140006a20.c
+++ b/decomp/Agent_Release_x64/full/functions/0x140006a20.c
@ -0,0 +1,17 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140006a20 FUN_140006a20
+ * Pseudocode, not original source. */
+
+void FUN_140006a20(undefined8 *param_1)
+
+{
+  if ((ulonglong *)*param_1 != (ulonglong *)0x0) {
+    FUN_140006a60((ulonglong *)*param_1,(ulonglong *)param_1[1]);
+    operator_delete((void *)*param_1);
+  }
+  *param_1 = 0;
+  param_1[1] = 0;
+  param_1[2] = 0;
+  return;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140006a60.c
+++ b/decomp/Agent_Release_x64/full/functions/0x140006a60.c
@ -0,0 +1,38 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140006a60 FUN_140006a60
+ * Pseudocode, not original source. */
+
+void FUN_140006a60(ulonglong *param_1,ulonglong *param_2)
+
+{
+  ulonglong *puVar1;
+  ulonglong *puVar2;
+  
+  if (param_1 != param_2) {
+    puVar2 = param_1 + 0x12;
+    do {
+      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 + 2;
+      puVar2 = puVar2 + 0x14;
+    } while (puVar1 != param_2);
+  }
+  return;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140006b10.c
+++ b/decomp/Agent_Release_x64/full/functions/0x140006b10.c
@ -0,0 +1,11 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140006b10 FUN_140006b10
+ * Pseudocode, not original source. */
+
+void FUN_140006b10(longlong param_1,ulonglong param_2,undefined8 param_3,undefined8 param_4)
+
+{
+  FUN_140005100((undefined8 *)(param_1 + -8),param_2,param_3,param_4);
+  return;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140006b20.c
+++ b/decomp/Agent_Release_x64/full/functions/0x140006b20.c
@ -0,0 +1,10 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140006b20 FUN_140006b20
+ * Pseudocode, not original source. */
+
+undefined1 FUN_140006b20(void)
+
+{
+  return 0;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140006b30.c
+++ b/decomp/Agent_Release_x64/full/functions/0x140006b30.c
@ -0,0 +1,15 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140006b30 FUN_140006b30
+ * Pseudocode, not original source. */
+
+void FUN_140006b30(undefined8 param_1,undefined8 param_2,longlong *param_3,longlong *param_4)
+
+{
+  longlong *plVar1;
+  
+  plVar1 = param_4;
+  FUN_140003240(param_3,param_2,param_3,param_4);
+  FUN_140003240(param_4,param_2,param_3,plVar1);
+  return;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140006b60.c
+++ b/decomp/Agent_Release_x64/full/functions/0x140006b60.c
@ -0,0 +1,10 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140006b60 FUN_140006b60
+ * Pseudocode, not original source. */
+
+undefined8 FUN_140006b60(void)
+
+{
+  return 0x8541;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140006b70.c
+++ b/decomp/Agent_Release_x64/full/functions/0x140006b70.c
@ -0,0 +1,10 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140006b70 FUN_140006b70
+ * Pseudocode, not original source. */
+
+undefined8 FUN_140006b70(void)
+
+{
+  return 0x8534;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140006b80.c
+++ b/decomp/Agent_Release_x64/full/functions/0x140006b80.c
@ -0,0 +1,10 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140006b80 FUN_140006b80
+ * Pseudocode, not original source. */
+
+void FUN_140006b80(void)
+
+{
+  return;
+}
+
--- a/decomp/Agent_Release_x64/full/functions/0x140006b90.c
+++ b/decomp/Agent_Release_x64/full/functions/0x140006b90.c
@ -0,0 +1,22 @@
+/* Agent_Release_x64.exe sha256 6f2be7b8eb799ba51b359d1958720aac5baee5b7ee0d1d36684d3cbd72d45469
+ * Ghidra 12.1.2 decompiler output for 0x140006b90 FUN_140006b90
+ * Pseudocode, not original source. */
+
+undefined8 * FUN_140006b90(undefined8 *param_1,uint param_2)
+
+{
+  *param_1 = Proud::CFastArray<Proud::HostID,0>::vftable;
+  if ((LPVOID)param_1[2] != (LPVOID)0x0) {
+    if ((longlong *)param_1[1] == (longlong *)0x0) {
+      FUN_1400302f0((LPVOID)param_1[2]);
+    }
+    else {
+      (**(code **)(*(longlong *)param_1[1] + 0x18))();
+    }
+  }
+  if ((param_2 & 1) != 0) {
+    operator_delete(param_1);
+  }
+  return param_1;
+}
+
--- a/Show more
+++ b/Show more