### EXPORT FUNC 180001000 (67 bytes) name=FUN_180001000

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_180001000(void)

{
  FUN_180002ab0((ulonglong *)&DAT_180016060,1);
  _DAT_180016068 = DAT_180016060;
  *DAT_180016060 = 0x7e;
  _DAT_180016068 = _DAT_180016068 + 1;
  atexit(FUN_18000e300);
  return;
}


==================================================================

### EXPORT FUNC 180001050 (79 bytes) name=FUN_180001050

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_180001050(void)

{
  FUN_180002ab0((ulonglong *)&DAT_180016000,8);
  _DAT_180016008 = DAT_180016000;
  *DAT_180016000 = 0x339393939393902;
  _DAT_180016008 = _DAT_180016008 + 1;
  atexit(FUN_18000e370);
  return;
}


==================================================================

### EXPORT FUNC 1800010a0 (79 bytes) name=FUN_1800010a0

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_1800010a0(void)

{
  FUN_180002ab0((ulonglong *)&DAT_180016018,8);
  _DAT_180016020 = DAT_180016018;
  *DAT_180016018 = 0x334313231323102;
  _DAT_180016020 = _DAT_180016020 + 1;
  atexit(FUN_18000e3e0);
  return;
}


==================================================================

### EXPORT FUNC 1800010f0 (67 bytes) name=FUN_1800010f0

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_1800010f0(void)

{
  FUN_180002ab0((ulonglong *)&DAT_180016090,1);
  _DAT_180016098 = DAT_180016090;
  *DAT_180016090 = 0x13;
  _DAT_180016098 = _DAT_180016098 + 1;
  atexit(FUN_18000e450);
  return;
}


==================================================================

### EXPORT FUNC 180001140 (67 bytes) name=FUN_180001140

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_180001140(void)

{
  FUN_180002ab0((ulonglong *)&DAT_180016078,1);
  _DAT_180016080 = DAT_180016078;
  *DAT_180016078 = 0x12;
  _DAT_180016080 = _DAT_180016080 + 1;
  atexit(FUN_18000e4c0);
  return;
}


==================================================================

### EXPORT FUNC 180001190 (92 bytes) name=FUN_180001190

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_180001190(void)

{
  void *pvVar1;
  undefined4 local_res8;
  undefined2 local_resc;
  
  local_res8 = 0x70757766;
  local_resc = 0xa0d;
  FUN_180002ab0((ulonglong *)&DAT_180016030,6);
  pvVar1 = DAT_180016030;
  memmove(DAT_180016030,&local_res8,6);
  _DAT_180016038 = (longlong)pvVar1 + 6;
  atexit(FUN_18000e530);
  return;
}


==================================================================

### EXPORT FUNC 1800011f0 (90 bytes) name=FUN_1800011f0

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_1800011f0(void)

{
  void *pvVar1;
  undefined4 local_res8;
  undefined1 local_resc;
  
  local_res8 = 0xd726576;
  local_resc = 10;
  FUN_180002ab0((ulonglong *)&DAT_1800160a8,5);
  pvVar1 = DAT_1800160a8;
  memmove(DAT_1800160a8,&local_res8,5);
  _DAT_1800160b0 = (longlong)pvVar1 + 5;
  atexit(FUN_18000e5a0);
  return;
}


==================================================================

### EXPORT FUNC 180001250 (67 bytes) name=FUN_180001250

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_180001250(void)

{
  FUN_180002ab0((ulonglong *)&DAT_180016048,1);
  _DAT_180016050 = DAT_180016048;
  *DAT_180016048 = 4;
  _DAT_180016050 = _DAT_180016050 + 1;
  atexit(FUN_18000e610);
  return;
}


==================================================================

### EXPORT FUNC 1800012a0 (45 bytes) name=FUN_1800012a0

void FUN_1800012a0(void)

{
  FUN_180002610(&DAT_180015060,"SCANNER_NORMAL",0xe);
  atexit(FUN_18000e6f0);
  return;
}


==================================================================

### EXPORT FUNC 1800012d0 (45 bytes) name=FUN_1800012d0

void FUN_1800012d0(void)

{
  FUN_180002610(&DAT_1800150a0,"SCANNER_OFFLINE",0xf);
  atexit(FUN_18000e760);
  return;
}


==================================================================

### EXPORT FUNC 180001300 (45 bytes) name=FUN_180001300

void FUN_180001300(void)

{
  FUN_180002610(&DAT_1800151e0,"SCANNER_DATA_EXCEED",0x13);
  atexit(FUN_18000e7d0);
  return;
}


==================================================================

### EXPORT FUNC 180001330 (45 bytes) name=FUN_180001330

void FUN_180001330(void)

{
  FUN_180002610(&DAT_180015180,"SCANNER_FILTED_QR",0x11);
  atexit(FUN_18000e840);
  return;
}


==================================================================

### EXPORT FUNC 180001360 (45 bytes) name=FUN_180001360

void FUN_180001360(void)

{
  FUN_180002610(&DAT_1800150e0,"SCANNER_FILTED_EAN8",0x13);
  atexit(FUN_18000e8b0);
  return;
}


==================================================================

### EXPORT FUNC 180001390 (45 bytes) name=FUN_180001390

void FUN_180001390(void)

{
  FUN_180002610(&DAT_180015160,"SCANNER_FILTED_EAN13",0x14);
  atexit(FUN_18000e920);
  return;
}


==================================================================

### EXPORT FUNC 1800013c0 (45 bytes) name=FUN_1800013c0

void FUN_1800013c0(void)

{
  FUN_180002610(&DAT_1800151c0,"SCANNER_FILTED_C39",0x12);
  atexit(FUN_18000e990);
  return;
}


==================================================================

### EXPORT FUNC 1800013f0 (45 bytes) name=FUN_1800013f0

void FUN_1800013f0(void)

{
  FUN_180002610(&DAT_180015120,"SCANNER_FILTED_C128",0x13);
  atexit(FUN_18000ea00);
  return;
}


==================================================================

### EXPORT FUNC 180001420 (45 bytes) name=FUN_180001420

void FUN_180001420(void)

{
  FUN_180002610(&DAT_1800150c0,"SCANNER_FILTED_GS1",0x12);
  atexit(FUN_18000ea70);
  return;
}


==================================================================

### EXPORT FUNC 180001450 (45 bytes) name=FUN_180001450

void FUN_180001450(void)

{
  FUN_180002610(&DAT_180015140,"SCANNER_FILTED_UPA",0x12);
  atexit(FUN_18000eae0);
  return;
}


==================================================================

### EXPORT FUNC 180001480 (45 bytes) name=FUN_180001480

void FUN_180001480(void)

{
  FUN_180002610(&DAT_180015100,"SCANNER_FILTED_UPB",0x12);
  atexit(FUN_18000eb50);
  return;
}


==================================================================

### EXPORT FUNC 1800014b0 (45 bytes) name=FUN_1800014b0

void FUN_1800014b0(void)

{
  FUN_180002610(&DAT_1800151a0,"SCANNER_FILTED_UPE",0x12);
  atexit(FUN_18000ebc0);
  return;
}


==================================================================

### EXPORT FUNC 1800014e0 (45 bytes) name=FUN_1800014e0

void FUN_1800014e0(void)

{
  FUN_180002610(&DAT_180015040,"SCANNER_FILTED_COUPON",0x15);
  atexit(FUN_18000ec30);
  return;
}


==================================================================

### EXPORT FUNC 180001510 (45 bytes) name=FUN_180001510

void FUN_180001510(void)

{
  FUN_180002610(&DAT_180015080,"SCANNER_FILTED_WWW",0x12);
  atexit(FUN_18000eca0);
  return;
}


==================================================================

### EXPORT FUNC 180001540 (6 bytes) name=FUN_180001540

undefined8 FUN_180001540(void)

{
  return 1;
}


==================================================================

### EXPORT FUNC 180001550 (116 bytes) name=FUN_180001550

void FUN_180001550(undefined4 *param_1)

{
  int iVar1;
  
  iVar1 = MAG_IsProcessingImage(param_1[4]);
  if (iVar1 != 0) {
    MAG_StopProcessImage(param_1[4]);
  }
  iVar1 = MAG_IsLinked(param_1[4]);
  if (iVar1 != 0) {
    MAG_DisLinkCamera(param_1[4]);
  }
  iVar1 = MAG_IsInitialized(param_1[4]);
  if (iVar1 != 0) {
    MAG_Free(param_1[4]);
    *param_1 = 0;
  }
  iVar1 = MAG_IsChannelAvailable(param_1[4]);
  if (iVar1 != 0) {
    MAG_DelChannel(param_1[4]);
    param_1[4] = 0xffffffff;
  }
  return;
}


==================================================================

### EXPORT FUNC 1800015d0 (121 bytes) name=FUN_1800015d0

int FUN_1800015d0(int *param_1)

{
  int iVar1;
  uint uVar2;
  
  if (*param_1 != 0) {
    return 1;
  }
  uVar2 = param_1[4];
  if (0x80 < uVar2) {
    uVar2 = 0;
    do {
      iVar1 = MAG_IsChannelAvailable(uVar2);
      if (iVar1 == 0) {
        MAG_NewChannel(uVar2);
        param_1[4] = uVar2;
        goto LAB_180001626;
      }
      uVar2 = uVar2 + 1;
    } while ((int)uVar2 < 0x81);
    uVar2 = param_1[4];
LAB_180001626:
    if (0x80 < uVar2) goto LAB_18000163c;
  }
  iVar1 = MAG_Initialize(uVar2,*(undefined8 *)(param_1 + 2));
  *param_1 = iVar1;
LAB_18000163c:
  return *param_1;
}


==================================================================

### EXPORT FUNC 180001650 (51 bytes) name=FUN_180001650

undefined8 * FUN_180001650(undefined8 *param_1,longlong param_2)

{
  *param_1 = std::exception::vftable;
  param_1[1] = 0;
  param_1[2] = 0;
  __std_exception_copy(param_2 + 8);
  return param_1;
}


==================================================================

### EXPORT FUNC 1800016b0 (19 bytes) name=FUN_1800016b0

char * FUN_1800016b0(longlong param_1)

{
  char *pcVar1;
  
  pcVar1 = "Unknown exception";
  if (*(char **)(param_1 + 8) != (char *)0x0) {
    pcVar1 = *(char **)(param_1 + 8);
  }
  return pcVar1;
}


==================================================================

### EXPORT FUNC 1800016d0 (67 bytes) name=FUN_1800016d0

undefined8 * FUN_1800016d0(undefined8 *param_1,ulonglong param_2)

{
  *param_1 = std::exception::vftable;
  __std_exception_destroy(param_1 + 1);
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 180001720 (33 bytes) name=FUN_180001720

undefined8 * FUN_180001720(undefined8 *param_1)

{
  param_1[2] = 0;
  param_1[1] = "bad array new length";
  *param_1 = std::bad_array_new_length::vftable;
  return param_1;
}


==================================================================

### EXPORT FUNC 180001750 (31 bytes) name=FUN_180001750

void FUN_180001750(void)

{
  undefined8 local_28 [5];
  
  FUN_180001720(local_28);
                    /* WARNING: Subroutine does not return */
  _CxxThrowException(local_28,(ThrowInfo *)&DAT_180013340);
}


==================================================================

### EXPORT FUNC 180001770 (61 bytes) name=FUN_180001770

undefined8 * FUN_180001770(undefined8 *param_1,longlong param_2)

{
  *param_1 = std::exception::vftable;
  param_1[1] = 0;
  param_1[2] = 0;
  __std_exception_copy(param_2 + 8);
  *param_1 = std::bad_array_new_length::vftable;
  return param_1;
}


==================================================================

### EXPORT FUNC 1800017b0 (61 bytes) name=FUN_1800017b0

undefined8 * FUN_1800017b0(undefined8 *param_1,longlong param_2)

{
  *param_1 = std::exception::vftable;
  param_1[1] = 0;
  param_1[2] = 0;
  __std_exception_copy(param_2 + 8);
  *param_1 = std::bad_alloc::vftable;
  return param_1;
}


==================================================================

### EXPORT FUNC 1800017f0 (3068 bytes) name=FUN_1800017f0

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
/* WARNING: Type propagation algorithm not settling */

void FUN_1800017f0(longlong param_1,longlong *param_2,longlong param_3)

{
  undefined1 uVar1;
  undefined1 *puVar2;
  int iVar3;
  ulonglong uVar4;
  undefined8 uVar5;
  void *pvVar6;
  undefined1 *puVar7;
  byte *pbVar8;
  longlong lVar9;
  longlong lVar10;
  undefined1 *puVar11;
  uint uVar12;
  ulonglong uVar13;
  ulonglong uVar14;
  ulonglong uVar15;
  ulonglong uVar16;
  ulonglong uVar17;
  bool bVar18;
  undefined1 auStack_88 [32];
  undefined1 local_68;
  uint local_64;
  undefined8 local_58 [2];
  ulonglong local_48;
  ulonglong local_40;
  ulonglong local_38;
  
  local_38 = DAT_180015010 ^ (ulonglong)auStack_88;
  iVar3 = *(int *)(param_1 + 0x4c);
  if (iVar3 == 1) {
    if (param_2[1] - *param_2 != 1) {
      return;
    }
    if (*(char *)*param_2 != '\x06') {
      return;
    }
    *(undefined1 *)(param_1 + 0x48) = 1;
    iVar3 = _Cnd_broadcast(param_1 + 0x58);
    if (iVar3 == 0) {
      return;
    }
    std::_Throw_C_error(iVar3);
    return;
  }
  if (iVar3 == 2) {
    if (param_2[1] - *param_2 != 1) {
      return;
    }
    if (*(char *)*param_2 != '\x06') {
      return;
    }
    *(undefined1 *)(param_1 + 0x48) = 1;
    iVar3 = _Cnd_broadcast(param_1 + 0x58);
    if (iVar3 == 0) {
      return;
    }
    std::_Throw_C_error(iVar3);
    return;
  }
  if (iVar3 == 3) {
    if (param_2[1] - *param_2 != 1) {
      return;
    }
    if (*(char *)*param_2 != '\x06') {
      return;
    }
    *(undefined1 *)(param_1 + 0x48) = 1;
    iVar3 = _Cnd_broadcast(param_1 + 0x58);
    if (iVar3 == 0) {
      return;
    }
    std::_Throw_C_error(iVar3);
    return;
  }
  if (iVar3 == 4) {
    uVar16 = 0;
    local_64 = 0;
    lVar9 = *param_2;
    if (param_2[1] != lVar9) {
      lVar10 = *(longlong *)(param_1 + 0x40);
      uVar15 = uVar16;
      uVar14 = uVar16;
      do {
        local_68 = *(undefined1 *)(lVar9 + uVar14);
        uVar4 = *(ulonglong *)(param_1 + 0x38);
        uVar12 = (uint)uVar15;
        if ((((int)lVar10 + (int)uVar4 & 0xfU) == 0) &&
           (*(ulonglong *)(param_1 + 0x30) <= lVar10 + 0x10U >> 4)) {
          FUN_1800028d0(param_1 + 0x20);
          uVar4 = *(ulonglong *)(param_1 + 0x38);
          lVar10 = *(longlong *)(param_1 + 0x40);
          uVar12 = local_64;
        }
        uVar4 = *(longlong *)(param_1 + 0x30) * 0x10 - 1U & uVar4;
        *(ulonglong *)(param_1 + 0x38) = uVar4;
        uVar4 = uVar4 + lVar10;
        lVar9 = (*(longlong *)(param_1 + 0x30) - 1U & uVar4 >> 4) * 8;
        lVar10 = *(longlong *)(param_1 + 0x28);
        if (*(longlong *)(lVar10 + lVar9) == 0) {
          uVar5 = FUN_18000c554(0x10);
          *(undefined8 *)(lVar9 + *(longlong *)(param_1 + 0x28)) = uVar5;
          lVar10 = *(longlong *)(param_1 + 0x28);
          uVar12 = local_64;
        }
        *(undefined1 *)((ulonglong)((uint)uVar4 & 0xf) + *(longlong *)(lVar9 + lVar10)) = local_68;
        *(longlong *)(param_1 + 0x40) = *(longlong *)(param_1 + 0x40) + 1;
        lVar10 = *(longlong *)(param_1 + 0x40);
        local_64 = uVar12 + 1;
        uVar15 = (ulonglong)local_64;
        uVar14 = uVar14 + 1;
        lVar9 = *param_2;
      } while ((ulonglong)(longlong)(int)local_64 < (ulonglong)(param_2[1] - lVar9));
    }
    local_48 = 0;
    local_40 = 0xf;
    local_58[0]._0_1_ = 0;
    uVar15 = *(ulonglong *)(param_1 + 0x38);
    uVar17 = *(longlong *)(param_1 + 0x40) + uVar15;
    uVar14 = local_48;
    uVar4 = local_40;
    for (; local_48 = uVar14, local_40 = uVar4, uVar15 != uVar17; uVar15 = uVar15 + 1) {
      uVar13 = (ulonglong)((uint)uVar15 & 0xf);
      uVar1 = *(undefined1 *)
               (uVar13 + *(longlong *)
                          (*(longlong *)(param_1 + 0x28) +
                          (*(longlong *)(param_1 + 0x30) - 1U & uVar15 >> 4) * 8));
      if (uVar14 < uVar4) {
        local_48 = uVar14 + 1;
        puVar11 = (undefined1 *)local_58;
        if (0xf < uVar4) {
          puVar11 = (undefined1 *)CONCAT71(local_58[0]._1_7_,(undefined1)local_58[0]);
        }
        puVar11[uVar14] = uVar1;
        puVar11[uVar14 + 1] = 0;
      }
      else {
        FUN_180002770(local_58,uVar13,uVar14,uVar1);
      }
      uVar14 = local_48;
      uVar4 = local_40;
    }
    puVar11 = (undefined1 *)CONCAT71(local_58[0]._1_7_,(undefined1)local_58[0]);
    puVar7 = (undefined1 *)local_58;
    if (0xf < uVar4) {
      puVar7 = puVar11;
    }
    if ((4 < uVar14) &&
       (pvVar6 = memchr(puVar7,0x4d,uVar14 - 4), uVar15 = uVar16, pvVar6 != (void *)0x0)) {
LAB_180001ac0:
      do {
        uVar17 = uVar15 + 1;
        if (*(byte *)((longlong)pvVar6 + uVar15) == (&DAT_18000f758)[uVar15]) {
          uVar15 = uVar17;
          uVar12 = 0;
          if (uVar17 != 5) goto LAB_180001ac0;
        }
        else {
          uVar12 = -(uint)(*(byte *)((longlong)pvVar6 + uVar15) < (byte)(&DAT_18000f758)[uVar15]) |
                   1;
        }
        if (uVar12 == 0) {
          if ((longlong)pvVar6 - (longlong)puVar7 != -1) {
            *(undefined1 *)(param_1 + 0x48) = 1;
            iVar3 = _Cnd_broadcast(param_1 + 0x58);
            if (iVar3 != 0) {
              std::_Throw_C_error(iVar3);
            }
          }
          break;
        }
        pvVar6 = memchr((void *)((longlong)pvVar6 + 1),0x4d,
                        (size_t)(puVar7 + ((uVar14 - 4) - ((longlong)pvVar6 + 1))));
        uVar15 = uVar16;
        if (pvVar6 == (void *)0x0) break;
      } while( true );
    }
    if (uVar4 < 0x10) {
      return;
    }
    if (uVar4 + 1 < 0x1000) goto LAB_1800020b1;
    puVar7 = puVar11 + (-8 - (longlong)*(undefined1 **)(puVar11 + 0xfffffffffffffff8));
    puVar11 = *(undefined1 **)(puVar11 + 0xfffffffffffffff8);
  }
  else if (iVar3 == 6) {
    uVar16 = 0;
    local_64 = 0;
    lVar9 = *param_2;
    if (param_2[1] != lVar9) {
      param_3 = *(longlong *)(param_1 + 0x40);
      uVar15 = uVar16;
      uVar14 = uVar16;
      do {
        local_68 = *(undefined1 *)(lVar9 + uVar14);
        uVar4 = *(ulonglong *)(param_1 + 0x38);
        uVar12 = (uint)uVar15;
        if ((((int)param_3 + (int)uVar4 & 0xfU) == 0) &&
           (*(ulonglong *)(param_1 + 0x30) <= param_3 + 0x10U >> 4)) {
          FUN_1800028d0(param_1 + 0x20);
          uVar4 = *(ulonglong *)(param_1 + 0x38);
          param_3 = *(longlong *)(param_1 + 0x40);
          uVar12 = local_64;
        }
        uVar4 = *(longlong *)(param_1 + 0x30) * 0x10 - 1U & uVar4;
        *(ulonglong *)(param_1 + 0x38) = uVar4;
        uVar4 = param_3 + uVar4;
        lVar9 = (*(longlong *)(param_1 + 0x30) - 1U & uVar4 >> 4) * 8;
        lVar10 = *(longlong *)(param_1 + 0x28);
        if (*(longlong *)(lVar10 + lVar9) == 0) {
          uVar5 = FUN_18000c554(0x10);
          *(undefined8 *)(lVar9 + *(longlong *)(param_1 + 0x28)) = uVar5;
          lVar10 = *(longlong *)(param_1 + 0x28);
          uVar12 = local_64;
        }
        *(undefined1 *)((ulonglong)((uint)uVar4 & 0xf) + *(longlong *)(lVar9 + lVar10)) = local_68;
        *(longlong *)(param_1 + 0x40) = *(longlong *)(param_1 + 0x40) + 1;
        param_3 = *(longlong *)(param_1 + 0x40);
        local_64 = uVar12 + 1;
        uVar15 = (ulonglong)local_64;
        uVar14 = uVar14 + 1;
        lVar9 = *param_2;
      } while ((ulonglong)(longlong)(int)local_64 < (ulonglong)(param_2[1] - lVar9));
    }
    local_48 = 0;
    local_40 = 0xf;
    local_58[0]._0_1_ = 0;
    uVar15 = *(ulonglong *)(param_1 + 0x38);
    uVar17 = *(longlong *)(param_1 + 0x40) + uVar15;
    uVar14 = local_48;
    uVar4 = local_40;
    for (; local_48 = uVar14, local_40 = uVar4, uVar15 != uVar17; uVar15 = uVar15 + 1) {
      uVar13 = (ulonglong)((uint)uVar15 & 0xf);
      uVar1 = *(undefined1 *)
               (uVar13 + *(longlong *)
                          (*(longlong *)(param_1 + 0x28) +
                          (uVar15 >> 4 & *(longlong *)(param_1 + 0x30) - 1U) * 8));
      if (uVar14 < uVar4) {
        local_48 = uVar14 + 1;
        puVar11 = (undefined1 *)local_58;
        if (0xf < uVar4) {
          puVar11 = (undefined1 *)CONCAT71(local_58[0]._1_7_,(undefined1)local_58[0]);
        }
        puVar11[uVar14] = uVar1;
        puVar11[uVar14 + 1] = 0;
      }
      else {
        FUN_180002770(local_58,uVar13,param_3,uVar1);
      }
      uVar14 = local_48;
      uVar4 = local_40;
    }
    puVar11 = (undefined1 *)CONCAT71(local_58[0]._1_7_,(undefined1)local_58[0]);
    puVar7 = (undefined1 *)local_58;
    if (0xf < uVar4) {
      puVar7 = puVar11;
    }
    if ((4 < uVar14) &&
       (pvVar6 = memchr(puVar7,0x4d,uVar14 - 4), uVar15 = uVar16, pvVar6 != (void *)0x0)) {
LAB_180001d40:
      do {
        uVar17 = uVar15 + 1;
        if (*(byte *)((longlong)pvVar6 + uVar15) == (&DAT_18000f758)[uVar15]) {
          uVar15 = uVar17;
          uVar12 = 0;
          if (uVar17 != 5) goto LAB_180001d40;
        }
        else {
          uVar12 = -(uint)(*(byte *)((longlong)pvVar6 + uVar15) < (byte)(&DAT_18000f758)[uVar15]) |
                   1;
        }
        if (uVar12 == 0) {
          if ((longlong)pvVar6 - (longlong)puVar7 != -1) {
            puVar7 = (undefined1 *)local_58;
            if (0xf < uVar4) {
              puVar7 = puVar11;
            }
            if (2 < uVar14) {
              pbVar8 = memchr(puVar7,0x76,uVar14 - 2);
              goto joined_r0x000180001dc2;
            }
          }
          break;
        }
        pvVar6 = memchr((void *)((longlong)pvVar6 + 1),0x4d,
                        (size_t)(puVar7 + ((uVar14 - 4) - ((longlong)pvVar6 + 1))));
        uVar15 = uVar16;
        if (pvVar6 == (void *)0x0) break;
      } while( true );
    }
LAB_180001e27:
    if (uVar4 < 0x10) {
      return;
    }
    if (uVar4 + 1 < 0x1000) goto LAB_1800020b1;
    puVar7 = puVar11 + (-8 - (longlong)*(undefined1 **)(puVar11 + 0xfffffffffffffff8));
    puVar11 = *(undefined1 **)(puVar11 + 0xfffffffffffffff8);
  }
  else {
    if (iVar3 == 5) {
      uVar16 = 0;
      local_64 = 0;
      lVar9 = *param_2;
      if (param_2[1] != lVar9) {
        param_3 = *(longlong *)(param_1 + 0x40);
        uVar15 = uVar16;
        do {
          local_68 = *(undefined1 *)(lVar9 + uVar15);
          uVar14 = *(ulonglong *)(param_1 + 0x38);
          uVar12 = (uint)uVar16;
          if ((((int)param_3 + (int)uVar14 & 0xfU) == 0) &&
             (*(ulonglong *)(param_1 + 0x30) <= param_3 + 0x10U >> 4)) {
            FUN_1800028d0(param_1 + 0x20);
            uVar14 = *(ulonglong *)(param_1 + 0x38);
            param_3 = *(longlong *)(param_1 + 0x40);
            uVar12 = local_64;
          }
          uVar14 = *(longlong *)(param_1 + 0x30) * 0x10 - 1U & uVar14;
          *(ulonglong *)(param_1 + 0x38) = uVar14;
          uVar14 = param_3 + uVar14;
          lVar9 = (*(longlong *)(param_1 + 0x30) - 1U & uVar14 >> 4) * 8;
          lVar10 = *(longlong *)(param_1 + 0x28);
          if (*(longlong *)(lVar10 + lVar9) == 0) {
            uVar5 = FUN_18000c554(0x10);
            *(undefined8 *)(lVar9 + *(longlong *)(param_1 + 0x28)) = uVar5;
            lVar10 = *(longlong *)(param_1 + 0x28);
            uVar12 = local_64;
          }
          *(undefined1 *)((ulonglong)((uint)uVar14 & 0xf) + *(longlong *)(lVar9 + lVar10)) =
               local_68;
          *(longlong *)(param_1 + 0x40) = *(longlong *)(param_1 + 0x40) + 1;
          param_3 = *(longlong *)(param_1 + 0x40);
          local_64 = uVar12 + 1;
          uVar16 = (ulonglong)local_64;
          uVar15 = uVar15 + 1;
          lVar9 = *param_2;
        } while ((ulonglong)(longlong)(int)local_64 < (ulonglong)(param_2[1] - lVar9));
      }
      local_48 = 0;
      local_40 = 0xf;
      local_58[0]._0_1_ = 0;
      uVar16 = *(ulonglong *)(param_1 + 0x38);
      uVar4 = *(longlong *)(param_1 + 0x40) + uVar16;
      uVar15 = local_48;
      uVar14 = local_40;
      for (; local_48 = uVar15, local_40 = uVar14, uVar16 != uVar4; uVar16 = uVar16 + 1) {
        uVar17 = (ulonglong)((uint)uVar16 & 0xf);
        uVar1 = *(undefined1 *)
                 (uVar17 + *(longlong *)
                            (*(longlong *)(param_1 + 0x28) +
                            (uVar16 >> 4 & *(longlong *)(param_1 + 0x30) - 1U) * 8));
        if (uVar15 < uVar14) {
          local_48 = uVar15 + 1;
          puVar11 = (undefined1 *)local_58;
          if (0xf < uVar14) {
            puVar11 = (undefined1 *)CONCAT71(local_58[0]._1_7_,(undefined1)local_58[0]);
          }
          puVar11[uVar15] = uVar1;
          puVar11[uVar15 + 1] = 0;
        }
        else {
          FUN_180002770(local_58,uVar17,param_3,uVar1);
        }
        uVar15 = local_48;
        uVar14 = local_40;
      }
      puVar11 = (undefined1 *)CONCAT71(local_58[0]._1_7_,(undefined1)local_58[0]);
      puVar7 = (undefined1 *)local_58;
      if (0xf < uVar14) {
        puVar7 = puVar11;
      }
      if (0x16 < uVar15) {
        for (pvVar6 = memchr(puVar7,0x55,uVar15 - 0x16); pvVar6 != (void *)0x0;
            pvVar6 = memchr((void *)((longlong)pvVar6 + 1),0x55,
                            (size_t)(puVar7 + ((uVar15 - 0x16) - ((longlong)pvVar6 + 1))))) {
          iVar3 = memcmp(pvVar6,"Use Ymodem to send file",0x17);
          if (iVar3 == 0) {
            if ((longlong)pvVar6 - (longlong)puVar7 != -1) {
              *(undefined1 *)(param_1 + 0x48) = 1;
              iVar3 = _Cnd_broadcast(param_1 + 0x58);
              if (iVar3 != 0) {
                std::_Throw_C_error(iVar3);
              }
            }
            break;
          }
        }
      }
      if (uVar14 < 0x10) {
        return;
      }
      if (uVar14 + 1 < 0x1000) goto LAB_1800020b1;
      puVar2 = *(undefined1 **)(puVar11 + 0xfffffffffffffff8);
      lVar9 = (longlong)puVar11 - (longlong)puVar2;
    }
    else {
      if (iVar3 == 7) {
        if (param_2[1] - *param_2 != 1) {
          return;
        }
        if (*(char *)*param_2 != '\x06') {
          return;
        }
        *(undefined1 *)(param_1 + 0x48) = 1;
        iVar3 = _Cnd_broadcast(param_1 + 0x58);
        if (iVar3 == 0) {
          return;
        }
        std::_Throw_C_error(iVar3);
        return;
      }
      if (iVar3 == 8) {
        if (param_2[1] - *param_2 != 1) {
          return;
        }
        if (*(char *)*param_2 != '\x06') {
          return;
        }
        *(undefined1 *)(param_1 + 0x48) = 1;
        iVar3 = _Cnd_broadcast(param_1 + 0x58);
        if (iVar3 == 0) {
          return;
        }
        std::_Throw_C_error(iVar3);
        return;
      }
      if (iVar3 == 9) {
        if (param_2[1] - *param_2 != 1) {
          return;
        }
        if (*(char *)*param_2 != '\x06') {
          return;
        }
        *(undefined1 *)(param_1 + 0x48) = 1;
        iVar3 = _Cnd_broadcast(param_1 + 0x58);
        if (iVar3 == 0) {
          return;
        }
        std::_Throw_C_error(iVar3);
        return;
      }
      if (iVar3 != 10) {
        return;
      }
      uVar16 = 0;
      local_64 = 0;
      lVar9 = *param_2;
      if (param_2[1] != lVar9) {
        lVar10 = *(longlong *)(param_1 + 0x40);
        uVar15 = uVar16;
        do {
          local_68 = *(undefined1 *)(lVar9 + uVar15);
          uVar14 = *(ulonglong *)(param_1 + 0x38);
          uVar12 = (uint)uVar16;
          if ((((int)uVar14 + (int)lVar10 & 0xfU) == 0) &&
             (*(ulonglong *)(param_1 + 0x30) <= lVar10 + 0x10U >> 4)) {
            FUN_1800028d0(param_1 + 0x20);
            uVar14 = *(ulonglong *)(param_1 + 0x38);
            lVar10 = *(longlong *)(param_1 + 0x40);
            uVar12 = local_64;
          }
          uVar14 = *(longlong *)(param_1 + 0x30) * 0x10 - 1U & uVar14;
          *(ulonglong *)(param_1 + 0x38) = uVar14;
          uVar14 = uVar14 + lVar10;
          lVar9 = (uVar14 >> 4 & *(longlong *)(param_1 + 0x30) - 1U) * 8;
          lVar10 = *(longlong *)(param_1 + 0x28);
          if (*(longlong *)(lVar10 + lVar9) == 0) {
            uVar5 = FUN_18000c554(0x10);
            *(undefined8 *)(lVar9 + *(longlong *)(param_1 + 0x28)) = uVar5;
            lVar10 = *(longlong *)(param_1 + 0x28);
            uVar12 = local_64;
          }
          *(undefined1 *)((ulonglong)((uint)uVar14 & 0xf) + *(longlong *)(lVar10 + lVar9)) =
               local_68;
          *(longlong *)(param_1 + 0x40) = *(longlong *)(param_1 + 0x40) + 1;
          lVar10 = *(longlong *)(param_1 + 0x40);
          local_64 = uVar12 + 1;
          uVar16 = (ulonglong)local_64;
          uVar15 = uVar15 + 1;
          lVar9 = *param_2;
        } while ((ulonglong)(longlong)(int)local_64 < (ulonglong)(param_2[1] - lVar9));
      }
      local_48 = 0;
      local_40 = 0xf;
      local_58[0]._0_1_ = 0;
      uVar16 = *(ulonglong *)(param_1 + 0x38);
      uVar4 = *(longlong *)(param_1 + 0x40) + uVar16;
      uVar15 = local_48;
      uVar14 = local_40;
      for (; local_48 = uVar15, local_40 = uVar14, uVar16 != uVar4; uVar16 = uVar16 + 1) {
        uVar17 = (ulonglong)((uint)uVar16 & 0xf);
        uVar1 = *(undefined1 *)
                 (uVar17 + *(longlong *)
                            (*(longlong *)(param_1 + 0x28) +
                            (uVar16 >> 4 & *(longlong *)(param_1 + 0x30) - 1U) * 8));
        if (uVar15 < uVar14) {
          local_48 = uVar15 + 1;
          puVar11 = (undefined1 *)local_58;
          if (0xf < uVar14) {
            puVar11 = (undefined1 *)CONCAT71(local_58[0]._1_7_,(undefined1)local_58[0]);
          }
          puVar11[uVar15] = uVar1;
          puVar11[uVar15 + 1] = 0;
        }
        else {
          FUN_180002770(local_58,uVar17,lVar9,uVar1);
        }
        uVar15 = local_48;
        uVar14 = local_40;
      }
      puVar11 = (undefined1 *)CONCAT71(local_58[0]._1_7_,(undefined1)local_58[0]);
      puVar7 = (undefined1 *)local_58;
      if (0xf < uVar14) {
        puVar7 = puVar11;
      }
      if (0x25 < uVar15) {
        for (pvVar6 = memchr(puVar7,0x46,uVar15 - 0x25); pvVar6 != (void *)0x0;
            pvVar6 = memchr((void *)((longlong)pvVar6 + 1),0x46,
                            (size_t)(puVar7 + ((uVar15 - 0x25) - ((longlong)pvVar6 + 1))))) {
          iVar3 = memcmp(pvVar6,"Firmware upgrade success, rebooting...",0x26);
          if (iVar3 == 0) {
            if ((longlong)pvVar6 - (longlong)puVar7 != -1) {
              *(undefined1 *)(param_1 + 0x48) = 1;
              iVar3 = _Cnd_broadcast(param_1 + 0x58);
              if (iVar3 != 0) {
                std::_Throw_C_error(iVar3);
              }
            }
            break;
          }
        }
      }
      if (uVar14 < 0x10) {
        return;
      }
      if (uVar14 + 1 < 0x1000) goto LAB_1800020b1;
      puVar2 = *(undefined1 **)(puVar11 + 0xfffffffffffffff8);
      lVar9 = (longlong)puVar11 - (longlong)puVar2;
    }
    puVar7 = (undefined1 *)(lVar9 - 8);
    puVar11 = puVar2;
  }
  if ((undefined1 *)0x1f < puVar7) {
                    /* WARNING: Subroutine does not return */
    _invalid_parameter_noinfo_noreturn();
  }
LAB_1800020b1:
  free(puVar11);
  return;
joined_r0x000180001dc2:
  if (pbVar8 == (byte *)0x0) goto LAB_180001e27;
  bVar18 = *pbVar8 < 0x76;
  if (((*pbVar8 == 0x76) && (bVar18 = pbVar8[1] < 0x65, pbVar8[1] == 0x65)) &&
     (bVar18 = pbVar8[2] < 0x72, pbVar8[2] == 0x72)) {
    uVar12 = 0;
  }
  else {
    uVar12 = -(uint)bVar18 | 1;
  }
  if (uVar12 == 0) {
    if ((longlong)pbVar8 - (longlong)puVar7 != -1) {
      *(undefined1 *)(param_1 + 0x48) = 1;
      iVar3 = _Cnd_broadcast(param_1 + 0x58);
      if (iVar3 != 0) {
        std::_Throw_C_error(iVar3);
      }
    }
    goto LAB_180001e27;
  }
  pbVar8 = memchr(pbVar8 + 1,0x76,(size_t)(puVar7 + ((uVar14 - 2) - (longlong)(pbVar8 + 1))));
  goto joined_r0x000180001dc2;
}


==================================================================

### EXPORT FUNC 1800023f0 (39 bytes) name=FUN_1800023f0

void FUN_1800023f0(undefined8 *param_1)

{
  void *_Memory;
  
  FUN_180002550((longlong)param_1);
  _Memory = (void *)*param_1;
  *param_1 = 0;
  free(_Memory);
  return;
}


==================================================================

### EXPORT FUNC 180002420 (87 bytes) name=FUN_180002420

void FUN_180002420(longlong *param_1)

{
  void *pvVar1;
  void *_Memory;
  
  pvVar1 = (void *)*param_1;
  if (pvVar1 != (void *)0x0) {
    _Memory = pvVar1;
    if ((0xfff < (ulonglong)(param_1[2] - (longlong)pvVar1)) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
    *param_1 = 0;
    param_1[1] = 0;
    param_1[2] = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 180002480 (38 bytes) name=FUN_180002480

void FUN_180002480(undefined8 *param_1)

{
  int iVar1;
  
  if (*(char *)(param_1 + 1) != '\0') {
    iVar1 = _Mtx_unlock(*param_1);
    if (iVar1 != 0) {
      std::_Throw_C_error(iVar1);
    }
  }
  return;
}


==================================================================

### EXPORT FUNC 1800024b0 (94 bytes) name=FUN_1800024b0

void FUN_1800024b0(longlong *param_1)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < (ulonglong)param_1[3]) {
    pvVar1 = (void *)*param_1;
    _Memory = pvVar1;
    if ((0xfff < param_1[3] + 1U) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  param_1[2] = 0;
  param_1[3] = 0xf;
  *(undefined1 *)param_1 = 0;
  return;
}


==================================================================

### EXPORT FUNC 180002510 (59 bytes) name=FUN_180002510

longlong * FUN_180002510(longlong *param_1,void *param_2)

{
  size_t sVar1;
  
  param_1[2] = 0;
  param_1[3] = 0xf;
  sVar1 = 0xffffffffffffffff;
  *(undefined1 *)param_1 = 0;
  do {
    sVar1 = sVar1 + 1;
  } while (*(char *)((longlong)param_2 + sVar1) != '\0');
  FUN_180002610(param_1,param_2,sVar1);
  return param_1;
}


==================================================================

### EXPORT FUNC 180002550 (180 bytes) name=FUN_180002550

void FUN_180002550(longlong param_1)

{
  void *pvVar1;
  void *_Memory;
  longlong lVar2;
  
  lVar2 = *(longlong *)(param_1 + 0x20);
  if (lVar2 != 0) {
    do {
      lVar2 = lVar2 + -1;
      *(longlong *)(param_1 + 0x20) = lVar2;
    } while (lVar2 != 0);
    *(undefined8 *)(param_1 + 0x18) = 0;
  }
  lVar2 = *(longlong *)(param_1 + 0x10);
  while (lVar2 != 0) {
    lVar2 = lVar2 + -1;
    pvVar1 = *(void **)(*(longlong *)(param_1 + 8) + lVar2 * 8);
    if (pvVar1 != (void *)0x0) {
      free(pvVar1);
    }
  }
  pvVar1 = *(void **)(param_1 + 8);
  if (pvVar1 != (void *)0x0) {
    _Memory = pvVar1;
    if ((0xfff < (ulonglong)(*(longlong *)(param_1 + 0x10) << 3)) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  *(undefined8 *)(param_1 + 0x10) = 0;
  *(undefined8 *)(param_1 + 8) = 0;
  return;
}


==================================================================

### EXPORT FUNC 180002610 (346 bytes) name=FUN_180002610

longlong * FUN_180002610(longlong *param_1,void *param_2,size_t param_3)

{
  ulonglong uVar1;
  ulonglong uVar2;
  void *pvVar3;
  longlong lVar4;
  ulonglong uVar5;
  size_t sVar6;
  void *_Memory;
  void *_Dst;
  longlong *_Dst_00;
  ulonglong uVar7;
  
  uVar2 = param_1[3];
  if (param_3 <= uVar2) {
    _Dst_00 = param_1;
    if (0xf < uVar2) {
      _Dst_00 = (longlong *)*param_1;
    }
    param_1[2] = param_3;
    memmove(_Dst_00,param_2,param_3);
    *(undefined1 *)(param_3 + (longlong)_Dst_00) = 0;
    return param_1;
  }
  if (0x7fffffffffffffff < param_3) {
                    /* WARNING: Subroutine does not return */
    FUN_180002b40();
  }
  uVar5 = param_3 | 0xf;
  uVar7 = 0x7fffffffffffffff;
  if (((uVar5 < 0x8000000000000000) && (uVar2 <= 0x7fffffffffffffff - (uVar2 >> 1))) &&
     (uVar1 = (uVar2 >> 1) + uVar2, uVar7 = uVar5, uVar5 < uVar1)) {
    uVar7 = uVar1;
  }
  sVar6 = uVar7 + 1;
  if (uVar7 == 0xffffffffffffffff) {
    sVar6 = 0xffffffffffffffff;
  }
  if (sVar6 < 0x1000) {
    if (sVar6 == 0) {
      _Dst = (void *)0x0;
    }
    else {
      _Dst = (void *)FUN_18000c554(sVar6);
    }
  }
  else {
    if (sVar6 + 0x27 <= sVar6) {
                    /* WARNING: Subroutine does not return */
      FUN_180001750();
    }
    lVar4 = FUN_18000c554(sVar6 + 0x27);
    if (lVar4 == 0) goto LAB_18000275a;
    _Dst = (void *)(lVar4 + 0x27U & 0xffffffffffffffe0);
    *(longlong *)((longlong)_Dst - 8) = lVar4;
  }
  param_1[2] = param_3;
  param_1[3] = uVar7;
  memcpy(_Dst,param_2,param_3);
  *(undefined1 *)(param_3 + (longlong)_Dst) = 0;
  if (0xf < uVar2) {
    pvVar3 = (void *)*param_1;
    _Memory = pvVar3;
    if ((0xfff < uVar2 + 1) &&
       (_Memory = *(void **)((longlong)pvVar3 + -8),
       0x1f < (ulonglong)((longlong)pvVar3 + (-8 - (longlong)_Memory)))) {
LAB_18000275a:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  *param_1 = (longlong)_Dst;
  return param_1;
}


==================================================================

### EXPORT FUNC 180002770 (348 bytes) name=FUN_180002770

undefined8 *
FUN_180002770(undefined8 *param_1,undefined8 param_2,undefined8 param_3,undefined1 param_4)

{
  ulonglong uVar1;
  size_t _Size;
  ulonglong uVar2;
  void *_Src;
  longlong lVar3;
  ulonglong uVar4;
  size_t sVar5;
  ulonglong uVar6;
  void *_Memory;
  void *_Dst;
  
  _Size = param_1[2];
  if (_Size == 0x7fffffffffffffff) {
                    /* WARNING: Subroutine does not return */
    FUN_180002b40();
  }
  uVar2 = param_1[3];
  uVar4 = _Size + 1 | 0xf;
  uVar6 = 0x7fffffffffffffff;
  if (((uVar4 < 0x8000000000000000) && (uVar2 <= 0x7fffffffffffffff - (uVar2 >> 1))) &&
     (uVar1 = (uVar2 >> 1) + uVar2, uVar6 = uVar4, uVar4 < uVar1)) {
    uVar6 = uVar1;
  }
  sVar5 = uVar6 + 1;
  if (uVar6 == 0xffffffffffffffff) {
    sVar5 = 0xffffffffffffffff;
  }
  if (sVar5 < 0x1000) {
    if (sVar5 == 0) {
      _Dst = (void *)0x0;
    }
    else {
      _Dst = (void *)FUN_18000c554(sVar5);
    }
  }
  else {
    if (sVar5 + 0x27 <= sVar5) {
                    /* WARNING: Subroutine does not return */
      FUN_180001750();
    }
    lVar3 = FUN_18000c554(sVar5 + 0x27);
    if (lVar3 == 0) goto LAB_18000288c;
    _Dst = (void *)(lVar3 + 0x27U & 0xffffffffffffffe0);
    *(longlong *)((longlong)_Dst - 8) = lVar3;
  }
  param_1[2] = _Size + 1;
  param_1[3] = uVar6;
  if (uVar2 < 0x10) {
    memcpy(_Dst,param_1,_Size);
    *(undefined1 *)((longlong)_Dst + _Size) = param_4;
    *(undefined1 *)((longlong)_Dst + _Size + 1) = 0;
  }
  else {
    _Src = (void *)*param_1;
    memcpy(_Dst,_Src,_Size);
    *(undefined1 *)((longlong)_Dst + _Size) = param_4;
    *(undefined1 *)((longlong)_Dst + _Size + 1) = 0;
    _Memory = _Src;
    if ((0xfff < uVar2 + 1) &&
       (_Memory = *(void **)((longlong)_Src + -8),
       0x1f < (ulonglong)((longlong)_Src + (-8 - (longlong)_Memory)))) {
LAB_18000288c:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  *param_1 = _Dst;
  return param_1;
}


==================================================================

### EXPORT FUNC 1800028d0 (469 bytes) name=FUN_1800028d0

void FUN_1800028d0(longlong param_1)

{
  code *pcVar1;
  ulonglong uVar2;
  longlong lVar3;
  void *_Memory;
  size_t sVar4;
  void *pvVar5;
  size_t sVar6;
  ulonglong uVar7;
  void *_Dst;
  ulonglong uVar8;
  
  uVar8 = *(ulonglong *)(param_1 + 0x10);
  uVar2 = 1;
  if (uVar8 != 0) {
    uVar2 = uVar8;
  }
  for (; (uVar7 = uVar2 - uVar8, uVar7 == 0 || (uVar2 < 8)); uVar2 = uVar2 * 2) {
    if (0x7ffffffffffffff - uVar2 < uVar2) {
      FUN_180002b60();
      pcVar1 = (code *)swi(3);
      (*pcVar1)();
      return;
    }
  }
  uVar8 = *(ulonglong *)(param_1 + 0x18) >> 4;
  if (0x1fffffffffffffff < uVar2) {
LAB_180002a9b:
                    /* WARNING: Subroutine does not return */
    FUN_180001750();
  }
  uVar2 = uVar2 * 8;
  if (uVar2 < 0x1000) {
    if (uVar2 == 0) {
      _Dst = (void *)0x0;
    }
    else {
      _Dst = (void *)FUN_18000c554(uVar2);
    }
  }
  else {
    if (uVar2 + 0x27 <= uVar2) goto LAB_180002a9b;
    lVar3 = FUN_18000c554(uVar2 + 0x27);
    if (lVar3 == 0) goto LAB_180002a94;
    _Dst = (void *)(lVar3 + 0x27U & 0xffffffffffffffe0);
    *(longlong *)((longlong)_Dst - 8) = lVar3;
  }
  sVar6 = uVar8 * 8;
  pvVar5 = (void *)(*(longlong *)(param_1 + 8) + sVar6);
  sVar4 = (*(longlong *)(param_1 + 0x10) * 8 - (longlong)pvVar5) + *(longlong *)(param_1 + 8);
  memmove((void *)(sVar6 + (longlong)_Dst),pvVar5,sVar4);
  pvVar5 = (void *)(sVar4 + (longlong)(sVar6 + (longlong)_Dst));
  if (uVar7 < uVar8) {
    sVar4 = uVar7 * 8;
    memmove(pvVar5,*(void **)(param_1 + 8),sVar4);
    pvVar5 = (void *)(sVar4 + *(longlong *)(param_1 + 8));
    sVar6 = (*(longlong *)(param_1 + 8) - (longlong)pvVar5) + sVar6;
    memmove(_Dst,pvVar5,sVar6);
    pvVar5 = (void *)(sVar6 + (longlong)_Dst);
  }
  else {
    memmove(pvVar5,*(void **)(param_1 + 8),sVar6);
    memset((void *)(sVar6 + (longlong)pvVar5),0,(uVar7 - uVar8) * 8);
    pvVar5 = _Dst;
    sVar4 = sVar6;
  }
  memset(pvVar5,0,sVar4);
  pvVar5 = *(void **)(param_1 + 8);
  if (pvVar5 != (void *)0x0) {
    _Memory = pvVar5;
    if ((0xfff < (ulonglong)(*(longlong *)(param_1 + 0x10) << 3)) &&
       (_Memory = *(void **)((longlong)pvVar5 + -8),
       0x1f < (ulonglong)((longlong)pvVar5 + (-8 - (longlong)_Memory)))) {
LAB_180002a94:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  *(longlong *)(param_1 + 0x10) = *(longlong *)(param_1 + 0x10) + uVar7;
  *(void **)(param_1 + 8) = _Dst;
  return;
}


==================================================================

### EXPORT FUNC 180002ab0 (134 bytes) name=FUN_180002ab0

void FUN_180002ab0(ulonglong *param_1,ulonglong param_2)

{
  longlong lVar1;
  ulonglong uVar2;
  
  if (0x7fffffffffffffff < param_2) {
                    /* WARNING: Subroutine does not return */
    FUN_180002b80();
  }
  if (param_2 < 0x1000) {
    if (param_2 == 0) {
      uVar2 = 0;
    }
    else {
      uVar2 = FUN_18000c554(param_2);
    }
  }
  else {
    if (param_2 + 0x27 <= param_2) {
                    /* WARNING: Subroutine does not return */
      FUN_180001750();
    }
    lVar1 = FUN_18000c554(param_2 + 0x27);
    if (lVar1 == 0) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    uVar2 = lVar1 + 0x27U & 0xffffffffffffffe0;
    *(longlong *)(uVar2 - 8) = lVar1;
  }
  *param_1 = uVar2;
  param_1[1] = uVar2;
  param_1[2] = uVar2 + param_2;
  return;
}


==================================================================

### EXPORT FUNC 180002b40 (18 bytes) name=FUN_180002b40

void FUN_180002b40(void)

{
  code *pcVar1;
  
  std::_Xlength_error("string too long");
  pcVar1 = (code *)swi(3);
  (*pcVar1)();
  return;
}


==================================================================

### EXPORT FUNC 180002b60 (18 bytes) name=FUN_180002b60

void FUN_180002b60(void)

{
  code *pcVar1;
  
  std::_Xlength_error("deque<T> too long");
  pcVar1 = (code *)swi(3);
  (*pcVar1)();
  return;
}


==================================================================

### EXPORT FUNC 180002b80 (18 bytes) name=FUN_180002b80

void FUN_180002b80(void)

{
  code *pcVar1;
  
  std::_Xlength_error("vector too long");
  pcVar1 = (code *)swi(3);
  (*pcVar1)();
  return;
}


==================================================================

### EXPORT FUNC 180002ba0 (239 bytes) name=FUN_180002ba0

void FUN_180002ba0(ulonglong *param_1,ulonglong param_2)

{
  void *pvVar1;
  longlong lVar2;
  void *_Memory;
  ulonglong uVar3;
  ulonglong uVar4;
  ulonglong uVar5;
  
  if (0x7fffffffffffffff < param_2) {
                    /* WARNING: Subroutine does not return */
    FUN_180002b80();
  }
  pvVar1 = (void *)*param_1;
  uVar3 = param_1[2] - (longlong)pvVar1;
  uVar5 = param_2;
  if ((uVar3 <= 0x7fffffffffffffff - (uVar3 >> 1)) &&
     (uVar5 = (uVar3 >> 1) + uVar3, uVar5 < param_2)) {
    uVar5 = param_2;
  }
  uVar4 = 0;
  if (pvVar1 != (void *)0x0) {
    _Memory = pvVar1;
    if ((0xfff < uVar3) &&
       (_Memory = *(void **)((longlong)pvVar1 - 8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) goto LAB_180002c50;
    free(_Memory);
    *param_1 = 0;
    param_1[1] = 0;
    param_1[2] = 0;
  }
  if (uVar5 < 0x1000) {
    if (uVar5 != 0) {
      uVar4 = FUN_18000c554(uVar5);
    }
  }
  else {
    if (uVar5 + 0x27 <= uVar5) {
                    /* WARNING: Subroutine does not return */
      FUN_180001750();
    }
    lVar2 = FUN_18000c554(uVar5 + 0x27);
    if (lVar2 == 0) {
LAB_180002c50:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    uVar4 = lVar2 + 0x27U & 0xffffffffffffffe0;
    *(longlong *)(uVar4 - 8) = lVar2;
  }
  *param_1 = uVar4;
  param_1[1] = uVar4;
  param_1[2] = uVar4 + uVar5;
  return;
}


==================================================================

### EXPORT FUNC 180002ca0 (248 bytes) name=FUN_180002ca0

void FUN_180002ca0(longlong *param_1)

{
  void *pvVar1;
  void *pvVar2;
  
  if (0xf < (ulonglong)param_1[0xb]) {
    pvVar1 = (void *)param_1[8];
    pvVar2 = pvVar1;
    if ((0xfff < param_1[0xb] + 1U) &&
       (pvVar2 = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)pvVar2)))) goto LAB_180002d92;
    free(pvVar2);
  }
  param_1[10] = 0;
  param_1[0xb] = 0xf;
  *(undefined1 *)(param_1 + 8) = 0;
  if (0xf < (ulonglong)param_1[7]) {
    pvVar1 = (void *)param_1[4];
    pvVar2 = pvVar1;
    if ((0xfff < param_1[7] + 1U) &&
       (pvVar2 = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)pvVar2)))) goto LAB_180002d92;
    free(pvVar2);
  }
  param_1[6] = 0;
  param_1[7] = 0xf;
  *(undefined1 *)(param_1 + 4) = 0;
  if (0xf < (ulonglong)param_1[3]) {
    pvVar1 = (void *)*param_1;
    pvVar2 = pvVar1;
    if ((0xfff < param_1[3] + 1U) &&
       (pvVar2 = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)pvVar2)))) {
LAB_180002d92:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(pvVar2);
  }
  param_1[2] = 0;
  param_1[3] = 0xf;
  *(undefined1 *)param_1 = 0;
  return;
}


==================================================================

### EXPORT FUNC 180002da0 (177 bytes) name=FUN_180002da0

void FUN_180002da0(longlong *param_1)

{
  longlong *plVar1;
  longlong *plVar2;
  
  plVar1 = (longlong *)*param_1;
  if (plVar1 != (longlong *)0x0) {
    plVar2 = (longlong *)param_1[1];
    if (plVar1 != plVar2) {
      do {
        FUN_180002ca0(plVar1);
        plVar1 = plVar1 + 0xc;
      } while (plVar1 != plVar2);
      plVar1 = (longlong *)*param_1;
    }
    plVar2 = plVar1;
    if ((0xfff < (ulonglong)(((param_1[2] - (longlong)plVar1) / 0x60) * 0x60)) &&
       (plVar2 = (longlong *)plVar1[-1],
       0x1f < (ulonglong)((longlong)plVar1 + (-8 - (longlong)plVar2)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(plVar2);
    *param_1 = 0;
    param_1[1] = 0;
    param_1[2] = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 180002e60 (201 bytes) name=FUN_180002e60

undefined8 * FUN_180002e60(undefined8 *param_1,undefined8 *param_2)

{
  ulonglong uVar1;
  ulonglong uVar2;
  undefined8 uVar3;
  longlong lVar4;
  void *_Dst;
  ulonglong uVar5;
  
  _Dst = (void *)0x0;
  param_1[2] = 0;
  param_1[3] = 0;
  uVar2 = param_2[2];
  if (0xf < (ulonglong)param_2[3]) {
    param_2 = (undefined8 *)*param_2;
  }
  if (uVar2 < 0x10) {
    uVar3 = param_2[1];
    uVar5 = 0xf;
    *param_1 = *param_2;
    param_1[1] = uVar3;
  }
  else {
    uVar5 = uVar2 | 0xf;
    if (0x7fffffffffffffff < uVar5) {
      uVar5 = 0x7fffffffffffffff;
    }
    uVar1 = uVar5 + 1;
    if (uVar1 < 0x1000) {
      if (uVar1 != 0) {
        _Dst = (void *)FUN_18000c554(uVar1);
      }
    }
    else {
      if (uVar5 + 0x28 <= uVar1) {
                    /* WARNING: Subroutine does not return */
        FUN_180001750();
      }
      lVar4 = FUN_18000c554(uVar5 + 0x28);
      if (lVar4 == 0) {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      _Dst = (void *)(lVar4 + 0x27U & 0xffffffffffffffe0);
      *(longlong *)((longlong)_Dst - 8) = lVar4;
    }
    *param_1 = _Dst;
    memcpy(_Dst,param_2,uVar2 + 1);
  }
  param_1[2] = uVar2;
  param_1[3] = uVar5;
  return param_1;
}


==================================================================

### EXPORT FUNC 180002f30 (49 bytes) name=FUN_180002f30

void FUN_180002f30(undefined8 param_1,longlong *param_2,longlong *param_3)

{
  for (; param_2 != param_3; param_2 = param_2 + 0xc) {
    FUN_180002ca0(param_2);
  }
  return;
}


==================================================================

### EXPORT FUNC 180002f70 (66 bytes) name=deallocate

/* Library Function - Multiple Matches With Same Base Name
    public: void __cdecl std::allocator<struct `protected: int __cdecl GSI1::readHash(unsigned
   short,long,long) __ptr64'::`2'::FileSymbolInfo>::deallocate(struct `protected: int __cdecl
   GSI1::readHash(unsigned short,long,long) __ptr64'::`2'::FileSymbolInfo * __ptr64 const,unsigned
   __int64) __ptr64
    public: void __cdecl std::allocator<struct GSISymbolEntry>::deallocate(struct GSISymbolEntry *
   __ptr64 const,unsigned __int64) __ptr64
   
   Library: Visual Studio 2019 Release */

void deallocate(undefined8 param_1,void *param_2,longlong param_3)

{
  void *_Memory;
  
  _Memory = param_2;
  if ((0xfff < (ulonglong)(param_3 * 0x60)) &&
     (_Memory = *(void **)((longlong)param_2 + -8),
     0x1f < (ulonglong)((longlong)param_2 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
    _invalid_parameter_noinfo_noreturn();
  }
  free(_Memory);
  return;
}


==================================================================

### EXPORT FUNC 180002fc0 (8 bytes) name=FUN_180002fc0

undefined * FUN_180002fc0(void)

{
  return &DAT_180015fe0;
}


==================================================================

### EXPORT FUNC 180002fd0 (2014 bytes) name=FUN_180002fd0

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

longlong * FUN_180002fd0(longlong *param_1)

{
  undefined8 *puVar1;
  code *pcVar2;
  void *pvVar3;
  BOOL BVar4;
  LSTATUS LVar5;
  uint uVar6;
  int iVar7;
  HDEVINFO DeviceInfoSet;
  HKEY hKey;
  wchar_t *pwVar8;
  longlong *plVar9;
  void *pvVar10;
  ulonglong uVar11;
  WCHAR *pWVar12;
  DWORD MemberIndex;
  undefined1 auStackY_7c8 [32];
  WCHAR local_780;
  undefined6 uStack_77e;
  undefined8 local_770;
  ulonglong local_768;
  WCHAR local_760;
  undefined6 uStack_75e;
  undefined8 local_750;
  ulonglong local_748;
  longlong *local_740;
  undefined8 *local_738;
  DWORD local_730;
  DWORD local_72c;
  DWORD local_728 [2];
  longlong local_720 [2];
  size_t local_710;
  ulonglong local_708;
  longlong local_700 [2];
  size_t local_6f0;
  ulonglong local_6e8;
  longlong local_6e0 [2];
  size_t local_6d0;
  ulonglong local_6c8;
  _SP_DEVINFO_DATA local_6c0;
  undefined1 local_698 [16];
  undefined8 local_688;
  undefined8 local_680;
  undefined1 local_678 [16];
  undefined8 local_668;
  undefined8 local_660;
  undefined1 local_658 [16];
  undefined8 local_648;
  undefined8 local_640;
  wchar_t local_638 [256];
  short local_438 [256];
  short local_238 [256];
  ulonglong local_38;
  
  local_38 = DAT_180015010 ^ (ulonglong)auStackY_7c8;
  MemberIndex = 0;
  *param_1 = 0;
  param_1[1] = 0;
  *param_1 = 0;
  param_1[1] = 0;
  param_1[2] = 0;
  local_740 = param_1;
  DeviceInfoSet = SetupDiGetClassDevsW((GUID *)&DAT_18000f7e8,(PCWSTR)0x0,(HWND)0x0,2);
  local_6c0.cbSize = 0x20;
  do {
    do {
      do {
        BVar4 = SetupDiEnumDeviceInfo(DeviceInfoSet,MemberIndex,&local_6c0);
        if (BVar4 == 0) {
          SetupDiDestroyDeviceInfoList(DeviceInfoSet);
          return param_1;
        }
        MemberIndex = MemberIndex + 1;
        hKey = SetupDiOpenDevRegKey(DeviceInfoSet,&local_6c0,1,0,1,0x20019);
        local_730 = 0x100;
        LVar5 = RegQueryValueExW(hKey,L"PortName",(LPDWORD)0x0,(LPDWORD)0x0,(LPBYTE)local_638,
                                 &local_730);
        RegCloseKey(hKey);
      } while (LVar5 != 0);
      uVar6 = local_730 - 1;
      if (uVar6 < 0x100) {
        if (0x1ff < (ulonglong)uVar6 * 2) goto LAB_1800037ae;
        local_638[uVar6] = L'\0';
      }
      else {
        local_638[0] = L'\0';
      }
      pwVar8 = wcsstr(local_638,L"LPT");
    } while (pwVar8 != (wchar_t *)0x0);
    local_72c = 0;
    BVar4 = SetupDiGetDeviceRegistryPropertyW
                      (DeviceInfoSet,&local_6c0,0xc,(PDWORD)0x0,(PBYTE)local_438,0x100,&local_72c);
    if ((BVar4 == 1) && (local_72c != 0)) {
      if (0x1ff < (ulonglong)(local_72c - 1) * 2) goto LAB_1800037ae;
      local_438[local_72c - 1] = 0;
    }
    else {
      local_438[0] = 0;
    }
    local_728[0] = 0;
    BVar4 = SetupDiGetDeviceRegistryPropertyW
                      (DeviceInfoSet,&local_6c0,1,(PDWORD)0x0,(PBYTE)local_238,0x100,local_728);
    if ((BVar4 == 1) && (local_728[0] != 0)) {
      if (0x1ff < (ulonglong)(local_728[0] - 1) * 2) {
LAB_1800037ae:
        __report_rangecheckfailure();
        pcVar2 = (code *)swi(3);
        plVar9 = (longlong *)(*pcVar2)();
        return plVar9;
      }
      local_238[local_728[0] - 1] = 0;
    }
    else {
      local_238[0] = 0;
    }
    local_770 = 0;
    local_768 = 7;
    local_780 = L'\0';
    uVar11 = 0xffffffffffffffff;
    do {
      uVar11 = uVar11 + 1;
    } while (local_638[uVar11] != L'\0');
    FUN_180003830((longlong *)&local_780,local_638,uVar11);
    pWVar12 = &local_780;
    if (7 < local_768) {
      pWVar12 = (LPCWSTR)CONCAT62(uStack_77e,local_780);
    }
    iVar7 = WideCharToMultiByte(0xfde9,0,pWVar12,(int)local_770,(LPSTR)0x0,0,(LPCSTR)0x0,(LPBOOL)0x0
                               );
    local_6d0 = 0;
    local_6c8 = 0xf;
    local_6e0[0]._0_1_ = 0;
    FUN_1800039a0(local_6e0,(longlong)iVar7);
    plVar9 = local_6e0;
    if (0xf < local_6c8) {
      plVar9 = (longlong *)CONCAT71(local_6e0[0]._1_7_,(undefined1)local_6e0[0]);
    }
    pWVar12 = &local_780;
    if (7 < local_768) {
      pWVar12 = (LPCWSTR)CONCAT62(uStack_77e,local_780);
    }
    WideCharToMultiByte(0xfde9,0,pWVar12,(int)local_770,(LPSTR)plVar9,iVar7,(LPCSTR)0x0,(LPBOOL)0x0)
    ;
    if (7 < local_768) {
      pvVar3 = (void *)CONCAT62(uStack_77e,local_780);
      pvVar10 = pvVar3;
      if ((0xfff < local_768 * 2 + 2) &&
         (pvVar10 = *(void **)((longlong)pvVar3 + -8),
         0x1f < (ulonglong)((longlong)pvVar3 + (-8 - (longlong)pvVar10)))) {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(pvVar10);
    }
    local_770 = 0;
    local_768 = 7;
    local_780 = L'\0';
    local_750 = 0;
    local_748 = 7;
    local_760 = L'\0';
    uVar11 = 0xffffffffffffffff;
    do {
      uVar11 = uVar11 + 1;
    } while (local_438[uVar11] != 0);
    FUN_180003830((longlong *)&local_760,local_438,uVar11);
    pWVar12 = &local_760;
    if (7 < local_748) {
      pWVar12 = (LPCWSTR)CONCAT62(uStack_75e,local_760);
    }
    iVar7 = WideCharToMultiByte(0xfde9,0,pWVar12,(int)local_750,(LPSTR)0x0,0,(LPCSTR)0x0,(LPBOOL)0x0
                               );
    local_6f0 = 0;
    local_6e8 = 0xf;
    local_700[0]._0_1_ = 0;
    FUN_1800039a0(local_700,(longlong)iVar7);
    plVar9 = local_700;
    if (0xf < local_6e8) {
      plVar9 = (longlong *)CONCAT71(local_700[0]._1_7_,(undefined1)local_700[0]);
    }
    pWVar12 = &local_760;
    if (7 < local_748) {
      pWVar12 = (LPCWSTR)CONCAT62(uStack_75e,local_760);
    }
    WideCharToMultiByte(0xfde9,0,pWVar12,(int)local_750,(LPSTR)plVar9,iVar7,(LPCSTR)0x0,(LPBOOL)0x0)
    ;
    if (7 < local_748) {
      pvVar3 = (void *)CONCAT62(uStack_75e,local_760);
      pvVar10 = pvVar3;
      if ((0xfff < local_748 * 2 + 2) &&
         (pvVar10 = *(void **)((longlong)pvVar3 + -8),
         0x1f < (ulonglong)((longlong)pvVar3 + (-8 - (longlong)pvVar10)))) {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(pvVar10);
    }
    local_750 = 0;
    local_748 = 7;
    local_760 = L'\0';
    local_770 = 0;
    local_768 = 7;
    local_780 = L'\0';
    uVar11 = 0xffffffffffffffff;
    do {
      uVar11 = uVar11 + 1;
    } while (local_238[uVar11] != 0);
    FUN_180003830((longlong *)&local_780,local_238,uVar11);
    pWVar12 = &local_780;
    if (7 < local_768) {
      pWVar12 = (LPCWSTR)CONCAT62(uStack_77e,local_780);
    }
    iVar7 = WideCharToMultiByte(0xfde9,0,pWVar12,(int)local_770,(LPSTR)0x0,0,(LPCSTR)0x0,(LPBOOL)0x0
                               );
    local_710 = 0;
    local_708 = 0xf;
    local_720[0]._0_1_ = 0;
    FUN_1800039a0(local_720,(longlong)iVar7);
    plVar9 = local_720;
    if (0xf < local_708) {
      plVar9 = (longlong *)CONCAT71(local_720[0]._1_7_,(undefined1)local_720[0]);
    }
    pWVar12 = &local_780;
    if (7 < local_768) {
      pWVar12 = (LPCWSTR)CONCAT62(uStack_77e,local_780);
    }
    WideCharToMultiByte(0xfde9,0,pWVar12,(int)local_770,(LPSTR)plVar9,iVar7,(LPCSTR)0x0,(LPBOOL)0x0)
    ;
    if (7 < local_768) {
      pvVar3 = (void *)CONCAT62(uStack_77e,local_780);
      pvVar10 = pvVar3;
      if ((0xfff < local_768 * 2 + 2) &&
         (pvVar10 = *(void **)((longlong)pvVar3 + -8),
         0x1f < (ulonglong)((longlong)pvVar3 + (-8 - (longlong)pvVar10)))) {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(pvVar10);
    }
    local_688 = 0;
    local_680 = 0xf;
    local_698[0] = 0;
    local_668 = 0;
    local_660 = 0xf;
    local_678[0] = 0;
    local_648 = 0;
    local_640 = 0xf;
    local_658[0] = 0;
    plVar9 = local_6e0;
    if (0xf < local_6c8) {
      plVar9 = (longlong *)CONCAT71(local_6e0[0]._1_7_,(undefined1)local_6e0[0]);
    }
    FUN_180002610((longlong *)local_698,plVar9,local_6d0);
    plVar9 = local_700;
    if (0xf < local_6e8) {
      plVar9 = (longlong *)CONCAT71(local_700[0]._1_7_,(undefined1)local_700[0]);
    }
    FUN_180002610((longlong *)local_678,plVar9,local_6f0);
    plVar9 = local_720;
    if (0xf < local_708) {
      plVar9 = (longlong *)CONCAT71(local_720[0]._1_7_,(undefined1)local_720[0]);
    }
    FUN_180002610((longlong *)local_658,plVar9,local_710);
    puVar1 = (undefined8 *)param_1[1];
    if (puVar1 == (undefined8 *)param_1[2]) {
      FUN_180003b00(param_1,puVar1,(undefined8 *)local_698);
    }
    else {
      local_738 = puVar1;
      FUN_180002e60(puVar1,(undefined8 *)local_698);
      FUN_180002e60(puVar1 + 4,(undefined8 *)local_678);
      FUN_180002e60(puVar1 + 8,(undefined8 *)local_658);
      param_1[1] = param_1[1] + 0x60;
    }
    FUN_180002ca0((longlong *)local_698);
    if (0xf < local_708) {
      pvVar3 = (void *)CONCAT71(local_720[0]._1_7_,(undefined1)local_720[0]);
      pvVar10 = pvVar3;
      if ((0xfff < local_708 + 1) &&
         (pvVar10 = *(void **)((longlong)pvVar3 + -8),
         0x1f < (ulonglong)((longlong)pvVar3 + (-8 - (longlong)pvVar10)))) {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(pvVar10);
    }
    local_710 = 0;
    local_708 = 0xf;
    local_720[0]._0_1_ = 0;
    if (0xf < local_6e8) {
      pvVar3 = (void *)CONCAT71(local_700[0]._1_7_,(undefined1)local_700[0]);
      pvVar10 = pvVar3;
      if ((0xfff < local_6e8 + 1) &&
         (pvVar10 = *(void **)((longlong)pvVar3 + -8),
         0x1f < (ulonglong)((longlong)pvVar3 + (-8 - (longlong)pvVar10)))) {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(pvVar10);
    }
    local_6f0 = 0;
    local_6e8 = 0xf;
    local_700[0]._0_1_ = 0;
    if (0xf < local_6c8) {
      pvVar3 = (void *)CONCAT71(local_6e0[0]._1_7_,(undefined1)local_6e0[0]);
      pvVar10 = pvVar3;
      if ((0xfff < local_6c8 + 1) &&
         (pvVar10 = *(void **)((longlong)pvVar3 + -8),
         0x1f < (ulonglong)((longlong)pvVar3 + (-8 - (longlong)pvVar10)))) {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(pvVar10);
    }
  } while( true );
}


==================================================================

### EXPORT FUNC 1800037c0 (97 bytes) name=FUN_1800037c0

void FUN_1800037c0(longlong *param_1)

{
  void *pvVar1;
  void *_Memory;
  
  if (7 < (ulonglong)param_1[3]) {
    pvVar1 = (void *)*param_1;
    _Memory = pvVar1;
    if ((0xfff < param_1[3] * 2 + 2U) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  param_1[3] = 7;
  param_1[2] = 0;
  *(undefined2 *)param_1 = 0;
  return;
}


==================================================================

### EXPORT FUNC 180003830 (358 bytes) name=FUN_180003830

longlong * FUN_180003830(longlong *param_1,void *param_2,ulonglong param_3)

{
  ulonglong uVar1;
  ulonglong uVar2;
  void *pvVar3;
  longlong lVar4;
  ulonglong uVar5;
  void *_Memory;
  ulonglong uVar6;
  longlong *_Dst;
  void *_Dst_00;
  
  uVar2 = param_1[3];
  if (uVar2 < param_3) {
    if (0x7ffffffffffffffe < param_3) {
                    /* WARNING: Subroutine does not return */
      FUN_180002b40();
    }
    uVar5 = param_3 | 7;
    uVar6 = 0x7ffffffffffffffe;
    if (((uVar5 < 0x7fffffffffffffff) && (uVar2 <= 0x7ffffffffffffffe - (uVar2 >> 1))) &&
       (uVar1 = (uVar2 >> 1) + uVar2, uVar6 = uVar5, uVar5 < uVar1)) {
      uVar6 = uVar1;
    }
    if (0x7fffffffffffffff < uVar6 + 1) {
LAB_180003993:
                    /* WARNING: Subroutine does not return */
      FUN_180001750();
    }
    uVar5 = (uVar6 + 1) * 2;
    _Dst_00 = (void *)0x0;
    if (uVar5 < 0x1000) {
      if (uVar5 != 0) {
        _Dst_00 = (void *)FUN_18000c554(uVar5);
      }
    }
    else {
      if (uVar5 + 0x27 <= uVar5) goto LAB_180003993;
      lVar4 = FUN_18000c554(uVar5 + 0x27);
      if (lVar4 == 0) goto LAB_180003986;
      _Dst_00 = (void *)(lVar4 + 0x27U & 0xffffffffffffffe0);
      *(longlong *)((longlong)_Dst_00 - 8) = lVar4;
    }
    param_1[3] = uVar6;
    param_1[2] = param_3;
    memcpy(_Dst_00,param_2,param_3 * 2);
    *(undefined2 *)(param_3 * 2 + (longlong)_Dst_00) = 0;
    if (7 < uVar2) {
      pvVar3 = (void *)*param_1;
      _Memory = pvVar3;
      if ((0xfff < uVar2 * 2 + 2) &&
         (_Memory = *(void **)((longlong)pvVar3 + -8),
         0x1f < (ulonglong)((longlong)pvVar3 + (-8 - (longlong)_Memory)))) {
LAB_180003986:
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(_Memory);
    }
    *param_1 = (longlong)_Dst_00;
  }
  else {
    _Dst = param_1;
    if (7 < uVar2) {
      _Dst = (longlong *)*param_1;
    }
    param_1[2] = param_3;
    memmove(_Dst,param_2,param_3 * 2);
    *(undefined2 *)(param_3 * 2 + (longlong)_Dst) = 0;
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 1800039a0 (349 bytes) name=FUN_1800039a0

longlong * FUN_1800039a0(longlong *param_1,ulonglong param_2)

{
  ulonglong uVar1;
  ulonglong uVar2;
  void *pvVar3;
  longlong lVar4;
  ulonglong uVar5;
  size_t sVar6;
  void *_Memory;
  longlong *_Dst;
  ulonglong uVar7;
  void *_Dst_00;
  
  uVar2 = param_1[3];
  if (param_2 <= uVar2) {
    _Dst = param_1;
    if (0xf < uVar2) {
      _Dst = (longlong *)*param_1;
    }
    param_1[2] = param_2;
    memset(_Dst,0,param_2);
    *(undefined1 *)(param_2 + (longlong)_Dst) = 0;
    return param_1;
  }
  if (0x7fffffffffffffff < param_2) {
                    /* WARNING: Subroutine does not return */
    FUN_180002b40();
  }
  uVar5 = param_2 | 0xf;
  uVar7 = 0x7fffffffffffffff;
  if (((uVar5 < 0x8000000000000000) && (uVar2 <= 0x7fffffffffffffff - (uVar2 >> 1))) &&
     (uVar1 = (uVar2 >> 1) + uVar2, uVar7 = uVar5, uVar5 < uVar1)) {
    uVar7 = uVar1;
  }
  sVar6 = uVar7 + 1;
  if (uVar7 == 0xffffffffffffffff) {
    sVar6 = 0xffffffffffffffff;
  }
  if (sVar6 < 0x1000) {
    if (sVar6 == 0) {
      _Dst_00 = (void *)0x0;
    }
    else {
      _Dst_00 = (void *)FUN_18000c554(sVar6);
    }
  }
  else {
    if (sVar6 + 0x27 <= sVar6) {
                    /* WARNING: Subroutine does not return */
      FUN_180001750();
    }
    lVar4 = FUN_18000c554(sVar6 + 0x27);
    if (lVar4 == 0) goto LAB_180003aed;
    _Dst_00 = (void *)(lVar4 + 0x27U & 0xffffffffffffffe0);
    *(longlong *)((longlong)_Dst_00 - 8) = lVar4;
  }
  param_1[2] = param_2;
  param_1[3] = uVar7;
  memset(_Dst_00,0,param_2);
  *(undefined1 *)((longlong)_Dst_00 + param_2) = 0;
  if (0xf < uVar2) {
    pvVar3 = (void *)*param_1;
    _Memory = pvVar3;
    if ((0xfff < uVar2 + 1) &&
       (_Memory = *(void **)((longlong)pvVar3 + -8),
       0x1f < (ulonglong)((longlong)pvVar3 + (-8 - (longlong)_Memory)))) {
LAB_180003aed:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  *param_1 = (longlong)_Dst_00;
  return param_1;
}


==================================================================

### EXPORT FUNC 180003b00 (580 bytes) name=FUN_180003b00

undefined8 * FUN_180003b00(longlong *param_1,undefined8 *param_2,undefined8 *param_3)

{
  ulonglong uVar1;
  longlong lVar2;
  ulonglong uVar3;
  longlong lVar4;
  undefined8 *puVar5;
  longlong lVar6;
  undefined8 *puVar7;
  longlong *plVar8;
  longlong *plVar9;
  undefined8 *puVar10;
  undefined8 *puVar11;
  undefined8 *puVar12;
  ulonglong uVar13;
  
  lVar4 = *param_1;
  lVar6 = ((longlong)param_2 - lVar4) / 6 + ((longlong)param_2 - lVar4 >> 0x3f);
  lVar2 = (param_1[1] - lVar4) / 0x60;
  if (lVar2 == 0x2aaaaaaaaaaaaaa) {
                    /* WARNING: Subroutine does not return */
    FUN_180002b80();
  }
  uVar1 = lVar2 + 1;
  uVar13 = (param_1[2] - lVar4) / 0x60;
  uVar3 = uVar1;
  if ((uVar13 <= 0x2aaaaaaaaaaaaaa - (uVar13 >> 1)) &&
     (uVar3 = (uVar13 >> 1) + uVar13, uVar3 < uVar1)) {
    uVar3 = uVar1;
  }
  if (0x2aaaaaaaaaaaaaa < uVar3) {
LAB_180003d3b:
                    /* WARNING: Subroutine does not return */
    FUN_180001750();
  }
  uVar13 = uVar3 * 0x60;
  if (uVar13 < 0x1000) {
    if (uVar13 == 0) {
      puVar10 = (undefined8 *)0x0;
    }
    else {
      puVar10 = (undefined8 *)FUN_18000c554(uVar13);
    }
  }
  else {
    if (uVar13 + 0x27 <= uVar13) goto LAB_180003d3b;
    lVar4 = FUN_18000c554(uVar13 + 0x27);
    if (lVar4 == 0) goto LAB_180003d34;
    puVar10 = (undefined8 *)(lVar4 + 0x27U & 0xffffffffffffffe0);
    puVar10[-1] = lVar4;
  }
  puVar12 = puVar10 + ((lVar6 >> 4) - (lVar6 >> 0x3f)) * 0xc;
  FUN_180002e60(puVar12,param_3);
  FUN_180002e60(puVar12 + 4,param_3 + 4);
  FUN_180002e60(puVar12 + 8,param_3 + 8);
  puVar7 = (undefined8 *)param_1[1];
  puVar5 = (undefined8 *)*param_1;
  puVar11 = puVar10;
  if (param_2 != puVar7) {
    FUN_180003d50(puVar5,param_2,puVar10);
    puVar5 = param_2;
    puVar7 = (undefined8 *)param_1[1];
    puVar11 = puVar12 + 0xc;
  }
  FUN_180003d50(puVar5,puVar7,puVar11);
  plVar8 = (longlong *)*param_1;
  if (plVar8 != (longlong *)0x0) {
    plVar9 = (longlong *)param_1[1];
    if (plVar8 != plVar9) {
      do {
        FUN_180002ca0(plVar8);
        plVar8 = plVar8 + 0xc;
      } while (plVar8 != plVar9);
      plVar8 = (longlong *)*param_1;
    }
    plVar9 = plVar8;
    if ((0xfff < (ulonglong)(((param_1[2] - (longlong)plVar8) / 0x60) * 0x60)) &&
       (plVar9 = (longlong *)plVar8[-1],
       0x1f < (ulonglong)((longlong)plVar8 + (-8 - (longlong)plVar9)))) {
LAB_180003d34:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(plVar9);
  }
  *param_1 = (longlong)puVar10;
  param_1[1] = (longlong)(puVar10 + uVar1 * 0xc);
  param_1[2] = (longlong)(puVar10 + uVar3 * 0xc);
  return puVar12;
}


==================================================================

### EXPORT FUNC 180003d50 (202 bytes) name=FUN_180003d50

void FUN_180003d50(undefined8 *param_1,undefined8 *param_2,undefined8 *param_3)

{
  undefined8 *puVar1;
  undefined8 *puVar2;
  undefined8 *puVar3;
  undefined8 uVar4;
  undefined8 *puVar5;
  undefined8 *puVar6;
  
  if (param_1 != param_2) {
    puVar5 = param_3;
    puVar6 = param_1 + 7;
    do {
      *(undefined8 *)((longlong)param_3 + (-0x28 - (longlong)param_1) + (longlong)puVar6) = 0;
      *(undefined8 *)((longlong)param_3 + (-0x20 - (longlong)param_1) + (longlong)puVar6) = 0;
      uVar4 = puVar6[-6];
      puVar1 = puVar6 + 0xc;
      puVar2 = puVar6 + 5;
      *puVar5 = puVar6[-7];
      puVar5[1] = uVar4;
      uVar4 = puVar6[-4];
      puVar5[2] = puVar6[-5];
      puVar5[3] = uVar4;
      puVar6[-5] = 0;
      puVar5 = puVar5 + 0xc;
      puVar6[-4] = 0xf;
      *(undefined1 *)(puVar6 + -7) = 0;
      *(undefined8 *)((longlong)param_3 + (-0x68 - (longlong)param_1) + (longlong)puVar1) = 0;
      *(undefined8 *)((longlong)param_3 + (-0x60 - (longlong)param_1) + (longlong)puVar1) = 0;
      uVar4 = puVar6[-2];
      puVar3 = (undefined8 *)((longlong)param_3 + (-0x78 - (longlong)param_1) + (longlong)puVar1);
      *puVar3 = puVar6[-3];
      puVar3[1] = uVar4;
      uVar4 = *puVar6;
      puVar3 = (undefined8 *)((longlong)param_3 + (-0x68 - (longlong)param_1) + (longlong)puVar1);
      *puVar3 = puVar6[-1];
      puVar3[1] = uVar4;
      puVar6[-1] = 0;
      *puVar6 = 0xf;
      *(undefined1 *)(puVar6 + -3) = 0;
      *(undefined8 *)((longlong)param_3 + (-0x48 - (longlong)param_1) + (longlong)puVar1) = 0;
      *(undefined8 *)((longlong)param_3 + (-0x40 - (longlong)param_1) + (longlong)puVar1) = 0;
      uVar4 = puVar6[2];
      puVar3 = (undefined8 *)((longlong)param_3 + (-0x58 - (longlong)param_1) + (longlong)puVar1);
      *puVar3 = puVar6[1];
      puVar3[1] = uVar4;
      uVar4 = puVar6[4];
      puVar3 = (undefined8 *)((longlong)param_3 + (-0x48 - (longlong)param_1) + (longlong)puVar1);
      *puVar3 = puVar6[3];
      puVar3[1] = uVar4;
      puVar6[3] = 0;
      puVar6[4] = 0xf;
      *(undefined1 *)(puVar6 + 1) = 0;
      puVar6 = puVar1;
    } while (puVar2 != param_2);
  }
  return;
}


==================================================================

### EXPORT FUNC 180003e20 (100 bytes) name=FUN_180003e20

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

undefined8 * FUN_180003e20(undefined8 *param_1,undefined8 param_2)

{
  undefined1 auStack_48 [32];
  undefined8 local_28;
  undefined1 local_20;
  ulonglong local_18;
  
  local_18 = DAT_180015010 ^ (ulonglong)auStack_48;
  local_20 = 1;
  *param_1 = std::exception::vftable;
  param_1[1] = 0;
  param_1[2] = 0;
  local_28 = param_2;
  __std_exception_copy(&local_28);
  *param_1 = std::invalid_argument::vftable;
  return param_1;
}


==================================================================

### EXPORT FUNC 180003e90 (668 bytes) name=FUN_180003e90

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

undefined8 * FUN_180003e90(undefined8 *param_1)

{
  longlong *plVar1;
  basic_ostream<char,std::char_traits<char>_> *pbVar2;
  void *pvVar3;
  void *pvVar4;
  size_t sVar5;
  undefined1 auStack_188 [32];
  undefined4 local_168;
  undefined1 local_160;
  undefined7 uStack_15f;
  undefined8 uStack_158;
  undefined8 local_150;
  ulonglong uStack_148;
  undefined8 *local_140;
  int iStack_12c;
  undefined *local_128 [2];
  undefined *local_118;
  undefined **local_110;
  basic_iostream<char,std::char_traits<char>_> local_108 [16];
  longlong *local_f8;
  longlong *local_f0;
  longlong *local_d8;
  ulonglong *local_d0;
  int *local_c0;
  ulonglong local_a8;
  uint local_a0;
  basic_ios<char,std::char_traits<char>_> local_90 [104];
  ulonglong local_28;
  ulonglong uVar6;
  
  local_28 = DAT_180015010 ^ (ulonglong)auStack_188;
  local_168 = 0;
  param_1[1] = 0;
  param_1[2] = 0;
  *param_1 = serial::SerialException::vftable;
  plVar1 = param_1 + 3;
  param_1[5] = 0;
  param_1[6] = 0xf;
  *(undefined1 *)plVar1 = 0;
  local_140 = param_1;
  memset(local_128,0,0xf8);
  local_128[0] = &DAT_18000fcb8;
  local_118 = &DAT_18000fba8;
  std::basic_ios<char,std::char_traits<char>_>::basic_ios<char,std::char_traits<char>_>(local_90);
  local_168 = 1;
  std::basic_iostream<char,std::char_traits<char>_>::basic_iostream<char,std::char_traits<char>_>
            ((basic_iostream<char,std::char_traits<char>_> *)local_128,
             (basic_streambuf<char,std::char_traits<char>_> *)&local_110);
  *(undefined ***)((longlong)local_128 + (longlong)*(int *)(local_128[0] + 4)) =
       std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  *(int *)((longlong)&iStack_12c + (longlong)*(int *)(local_128[0] + 4)) =
       *(int *)(local_128[0] + 4) + -0x98;
  std::basic_streambuf<char,std::char_traits<char>_>::basic_streambuf<char,std::char_traits<char>_>
            ((basic_streambuf<char,std::char_traits<char>_> *)&local_110);
  local_110 = std::basic_stringbuf<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  local_a8 = 0;
  local_a0 = 0;
  pbVar2 = FUN_180006310((basic_ostream<char,std::char_traits<char>_> *)&local_118,
                         "SerialException ");
  pbVar2 = FUN_180006310(pbVar2,"Serial port already open.");
  FUN_180006310(pbVar2," failed.");
  local_150 = 0;
  uStack_148 = 0xf;
  local_160 = 0;
  local_168 = 5;
  if (((local_a0 & 2) == 0) && (uVar6 = *local_d0, uVar6 != 0)) {
    pvVar4 = (void *)*local_f0;
    if (uVar6 < local_a8) {
      uVar6 = local_a8;
    }
    sVar5 = uVar6 - (longlong)pvVar4;
LAB_18000401b:
    FUN_180002610((longlong *)&local_160,pvVar4,sVar5);
  }
  else if (((local_a0 & 4) == 0) && (*local_d8 != 0)) {
    pvVar4 = (void *)*local_f8;
    sVar5 = ((longlong)*local_c0 - (longlong)pvVar4) + *local_d8;
    goto LAB_18000401b;
  }
  if (plVar1 == (longlong *)&local_160) {
    if (0xf < uStack_148) {
      pvVar3 = (void *)CONCAT71(uStack_15f,local_160);
      pvVar4 = pvVar3;
      if ((0xfff < uStack_148 + 1) &&
         (pvVar4 = *(void **)((longlong)pvVar3 + -8),
         0x1f < (ulonglong)((longlong)pvVar3 + (-8 - (longlong)pvVar4)))) goto LAB_1800040b7;
      free(pvVar4);
    }
  }
  else {
    if (0xf < (ulonglong)param_1[6]) {
      pvVar4 = (void *)*plVar1;
      pvVar3 = pvVar4;
      if ((0xfff < param_1[6] + 1) &&
         (pvVar3 = *(void **)((longlong)pvVar4 + -8),
         0x1f < (ulonglong)((longlong)pvVar4 + (-8 - (longlong)pvVar3)))) {
LAB_1800040b7:
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(pvVar3);
    }
    param_1[6] = 0xf;
    *(undefined1 *)plVar1 = 0;
    *plVar1 = CONCAT71(uStack_15f,local_160);
    param_1[4] = uStack_158;
    param_1[5] = local_150;
    param_1[6] = uStack_148;
  }
  *(undefined ***)((longlong)local_128 + (longlong)*(int *)(local_128[0] + 4)) =
       std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  *(int *)((longlong)&iStack_12c + (longlong)*(int *)(local_128[0] + 4)) =
       *(int *)(local_128[0] + 4) + -0x98;
  FUN_180005f90((basic_streambuf<char,std::char_traits<char>_> *)&local_110);
  std::basic_iostream<char,std::char_traits<char>_>::~basic_iostream<char,std::char_traits<char>_>
            (local_108);
  std::basic_ios<char,std::char_traits<char>_>::~basic_ios<char,std::char_traits<char>_>(local_90);
  return param_1;
}


==================================================================

### EXPORT FUNC 180004130 (53 bytes) name=FUN_180004130

undefined8 * FUN_180004130(undefined8 *param_1,longlong param_2)

{
  param_1[1] = 0;
  param_1[2] = 0;
  *param_1 = serial::SerialException::vftable;
  FUN_180002e60(param_1 + 3,(undefined8 *)(param_2 + 0x18));
  return param_1;
}


==================================================================

### EXPORT FUNC 180004170 (126 bytes) name=FUN_180004170

void FUN_180004170(undefined8 *param_1)

{
  void *pvVar1;
  void *_Memory;
  
  *param_1 = serial::SerialException::vftable;
  if (0xf < (ulonglong)param_1[6]) {
    pvVar1 = (void *)param_1[3];
    _Memory = pvVar1;
    if ((0xfff < param_1[6] + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  param_1[5] = 0;
  param_1[6] = 0xf;
  *(undefined1 *)(param_1 + 3) = 0;
  *param_1 = std::exception::vftable;
                    /* WARNING: Could not recover jumptable at 0x0001800041e1. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  __std_exception_destroy(param_1 + 1);
  return;
}


==================================================================

### EXPORT FUNC 1800041f0 (15 bytes) name=FUN_1800041f0

longlong * FUN_1800041f0(longlong param_1)

{
  longlong *plVar1;
  
  plVar1 = (longlong *)(param_1 + 0x18);
  if (0xf < *(ulonglong *)(param_1 + 0x30)) {
    plVar1 = (longlong *)*plVar1;
  }
  return plVar1;
}


==================================================================

### EXPORT FUNC 180004200 (159 bytes) name=FUN_180004200

undefined8 * FUN_180004200(undefined8 *param_1,uint param_2)

{
  void *pvVar1;
  void *_Memory;
  
  *param_1 = serial::SerialException::vftable;
  if (0xf < (ulonglong)param_1[6]) {
    pvVar1 = (void *)param_1[3];
    _Memory = pvVar1;
    if ((0xfff < param_1[6] + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  param_1[5] = 0;
  param_1[6] = 0xf;
  *(undefined1 *)(param_1 + 3) = 0;
  *param_1 = std::exception::vftable;
  __std_exception_destroy(param_1 + 1);
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 1800042a0 (95 bytes) name=FUN_1800042a0

void FUN_1800042a0(longlong *param_1)

{
  basic_ios<char,std::char_traits<char>_> *this;
  
  this = (basic_ios<char,std::char_traits<char>_> *)(param_1 + 0x13);
  *(undefined ***)(this + (longlong)*(int *)(*param_1 + 4) + -0x98) =
       std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  *(int *)(this + (longlong)*(int *)(*param_1 + 4) + -0x9c) = *(int *)(*param_1 + 4) + -0x98;
  FUN_180005f90((basic_streambuf<char,std::char_traits<char>_> *)(param_1 + 3));
  std::basic_iostream<char,std::char_traits<char>_>::~basic_iostream<char,std::char_traits<char>_>
            ((basic_iostream<char,std::char_traits<char>_> *)(param_1 + 4));
                    /* WARNING: Could not recover jumptable at 0x0001800042f8. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  std::basic_ios<char,std::char_traits<char>_>::~basic_ios<char,std::char_traits<char>_>(this);
  return;
}


==================================================================

### EXPORT FUNC 180004300 (13 bytes) name=FUN_180004300

void FUN_180004300(void *param_1)

{
  memset(param_1,0,0xf8);
  return;
}


==================================================================

### EXPORT FUNC 180004310 (843 bytes) name=FUN_180004310

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

undefined8 * FUN_180004310(undefined8 *param_1,longlong *param_2,undefined4 param_3,char *param_4)

{
  longlong *plVar1;
  basic_ostream<char,std::char_traits<char>_> *pbVar2;
  basic_ostream<char,struct_std::char_traits<char>_> *pbVar3;
  void *pvVar4;
  void *pvVar5;
  char *pcVar6;
  size_t sVar7;
  undefined1 auStack_1b8 [32];
  undefined4 local_198;
  undefined1 local_190;
  undefined7 uStack_18f;
  undefined8 uStack_188;
  undefined8 local_180;
  ulonglong uStack_178;
  undefined8 *local_168;
  undefined8 local_150;
  undefined *local_148 [2];
  undefined *local_138;
  undefined **local_130;
  basic_iostream<char,std::char_traits<char>_> local_128 [16];
  longlong *local_118;
  longlong *local_110;
  longlong *local_f8;
  ulonglong *local_f0;
  int *local_e0;
  ulonglong local_c8;
  uint local_c0;
  basic_ios<char,std::char_traits<char>_> local_b0 [104];
  ulonglong local_48;
  ulonglong uVar8;
  
  local_48 = DAT_180015010 ^ (ulonglong)auStack_1b8;
  local_198 = 0;
  param_1[1] = 0;
  param_1[2] = 0;
  *param_1 = serial::IOException::vftable;
  local_168 = param_1;
  local_150 = param_2;
  FUN_180002e60(param_1 + 3,param_2);
  *(undefined4 *)(param_1 + 7) = param_3;
  plVar1 = param_1 + 8;
  param_1[10] = 0;
  param_1[0xb] = 0xf;
  *(undefined1 *)plVar1 = 0;
  *(undefined4 *)(param_1 + 0xc) = 0;
  memset(local_148,0,0xf8);
  local_148[0] = &DAT_18000fcb8;
  local_138 = &DAT_18000fba8;
  std::basic_ios<char,std::char_traits<char>_>::basic_ios<char,std::char_traits<char>_>(local_b0);
  local_198 = 1;
  std::basic_iostream<char,std::char_traits<char>_>::basic_iostream<char,std::char_traits<char>_>
            ((basic_iostream<char,std::char_traits<char>_> *)local_148,
             (basic_streambuf<char,std::char_traits<char>_> *)&local_130);
  *(undefined ***)((longlong)local_148 + (longlong)*(int *)(local_148[0] + 4)) =
       std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  *(int *)((longlong)local_148 + (longlong)*(int *)(local_148[0] + 4) + -4) =
       *(int *)(local_148[0] + 4) + -0x98;
  std::basic_streambuf<char,std::char_traits<char>_>::basic_streambuf<char,std::char_traits<char>_>
            ((basic_streambuf<char,std::char_traits<char>_> *)&local_130);
  local_130 = std::basic_stringbuf<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  local_c8 = 0;
  local_c0 = 0;
  pbVar2 = FUN_180006310((basic_ostream<char,std::char_traits<char>_> *)&local_138,"IO Exception: ")
  ;
  FUN_180006310(pbVar2,param_4);
  pbVar2 = FUN_180006310((basic_ostream<char,std::char_traits<char>_> *)&local_138,", file ");
  pcVar6 = (char *)(param_1 + 3);
  if (0xf < (ulonglong)param_1[6]) {
    pcVar6 = (char *)param_1[3];
  }
  pbVar2 = FUN_180006920(pbVar2,pcVar6,param_1[5]);
  pbVar2 = FUN_180006310(pbVar2,", line ");
  pbVar3 = std::basic_ostream<char,std::char_traits<char>_>::operator<<
                     (pbVar2,*(int *)(param_1 + 7));
  FUN_180006310((basic_ostream<char,std::char_traits<char>_> *)pbVar3,".");
  local_180 = 0;
  uStack_178 = 0xf;
  local_190 = 0;
  local_198 = 5;
  if (((local_c0 & 2) == 0) && (uVar8 = *local_f0, uVar8 != 0)) {
    pvVar4 = (void *)*local_110;
    if (uVar8 < local_c8) {
      uVar8 = local_c8;
    }
    sVar7 = uVar8 - (longlong)pvVar4;
LAB_1800044fe:
    FUN_180002610((longlong *)&local_190,pvVar4,sVar7);
  }
  else if (((local_c0 & 4) == 0) && (*local_f8 != 0)) {
    pvVar4 = (void *)*local_118;
    sVar7 = ((longlong)*local_e0 - (longlong)pvVar4) + *local_f8;
    goto LAB_1800044fe;
  }
  if (plVar1 == (longlong *)&local_190) {
    if (0xf < uStack_178) {
      pvVar5 = (void *)CONCAT71(uStack_18f,local_190);
      pvVar4 = pvVar5;
      if ((0xfff < uStack_178 + 1) &&
         (pvVar4 = *(void **)((longlong)pvVar5 + -8),
         0x1f < (ulonglong)((longlong)pvVar5 + (-8 - (longlong)pvVar4)))) goto LAB_18000459b;
      free(pvVar4);
    }
  }
  else {
    if (0xf < (ulonglong)param_1[0xb]) {
      pvVar4 = (void *)*plVar1;
      pvVar5 = pvVar4;
      if ((0xfff < param_1[0xb] + 1) &&
         (pvVar5 = *(void **)((longlong)pvVar4 + -8),
         0x1f < (ulonglong)((longlong)pvVar4 + (-8 - (longlong)pvVar5)))) {
LAB_18000459b:
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(pvVar5);
    }
    param_1[0xb] = 0xf;
    *(undefined1 *)plVar1 = 0;
    *plVar1 = CONCAT71(uStack_18f,local_190);
    param_1[9] = uStack_188;
    param_1[10] = local_180;
    param_1[0xb] = uStack_178;
  }
  *(undefined ***)((longlong)local_148 + (longlong)*(int *)(local_148[0] + 4)) =
       std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  *(int *)((longlong)local_148 + (longlong)*(int *)(local_148[0] + 4) + -4) =
       *(int *)(local_148[0] + 4) + -0x98;
  FUN_180005f90((basic_streambuf<char,std::char_traits<char>_> *)&local_130);
  std::basic_iostream<char,std::char_traits<char>_>::~basic_iostream<char,std::char_traits<char>_>
            (local_128);
  std::basic_ios<char,std::char_traits<char>_>::~basic_ios<char,std::char_traits<char>_>(local_b0);
  if (0xf < (ulonglong)param_2[3]) {
    pvVar4 = (void *)*param_2;
    pvVar5 = pvVar4;
    if ((0xfff < param_2[3] + 1U) &&
       (pvVar5 = *(void **)((longlong)pvVar4 + -8),
       0x1f < (ulonglong)((longlong)pvVar4 + (-8 - (longlong)pvVar5)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(pvVar5);
  }
  param_2[2] = 0;
  param_2[3] = 0xf;
  *(undefined1 *)param_2 = 0;
  return param_1;
}


==================================================================

### EXPORT FUNC 180004660 (205 bytes) name=FUN_180004660

void FUN_180004660(undefined8 *param_1)

{
  void *pvVar1;
  void *pvVar2;
  
  *param_1 = serial::IOException::vftable;
  if (0xf < (ulonglong)param_1[0xb]) {
    pvVar1 = (void *)param_1[8];
    pvVar2 = pvVar1;
    if ((0xfff < param_1[0xb] + 1) &&
       (pvVar2 = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)pvVar2)))) goto LAB_180004727;
    free(pvVar2);
  }
  param_1[10] = 0;
  param_1[0xb] = 0xf;
  *(undefined1 *)(param_1 + 8) = 0;
  if (0xf < (ulonglong)param_1[6]) {
    pvVar1 = (void *)param_1[3];
    pvVar2 = pvVar1;
    if ((0xfff < param_1[6] + 1) &&
       (pvVar2 = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)pvVar2)))) {
LAB_180004727:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(pvVar2);
  }
  param_1[5] = 0;
  param_1[6] = 0xf;
  *(undefined1 *)(param_1 + 3) = 0;
  *param_1 = std::exception::vftable;
                    /* WARNING: Could not recover jumptable at 0x000180004720. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  __std_exception_destroy(param_1 + 1);
  return;
}


==================================================================

### EXPORT FUNC 180004730 (97 bytes) name=FUN_180004730

undefined8 * FUN_180004730(undefined8 *param_1,longlong param_2)

{
  param_1[1] = 0;
  param_1[2] = 0;
  *param_1 = serial::IOException::vftable;
  param_1[5] = 0;
  param_1[6] = 0xf;
  *(undefined1 *)(param_1 + 3) = 0;
  *(undefined4 *)(param_1 + 7) = *(undefined4 *)(param_2 + 0x38);
  FUN_180002e60(param_1 + 8,(undefined8 *)(param_2 + 0x40));
  *(undefined4 *)(param_1 + 0xc) = *(undefined4 *)(param_2 + 0x60);
  return param_1;
}


==================================================================

### EXPORT FUNC 1800047a0 (15 bytes) name=FUN_1800047a0

longlong * FUN_1800047a0(longlong param_1)

{
  longlong *plVar1;
  
  plVar1 = (longlong *)(param_1 + 0x40);
  if (0xf < *(ulonglong *)(param_1 + 0x58)) {
    plVar1 = (longlong *)*plVar1;
  }
  return plVar1;
}


==================================================================

### EXPORT FUNC 1800047b0 (238 bytes) name=FUN_1800047b0

undefined8 * FUN_1800047b0(undefined8 *param_1,uint param_2)

{
  void *pvVar1;
  void *pvVar2;
  
  *param_1 = serial::IOException::vftable;
  if (0xf < (ulonglong)param_1[0xb]) {
    pvVar1 = (void *)param_1[8];
    pvVar2 = pvVar1;
    if ((0xfff < param_1[0xb] + 1) &&
       (pvVar2 = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)pvVar2)))) goto LAB_180004898;
    free(pvVar2);
  }
  param_1[10] = 0;
  param_1[0xb] = 0xf;
  *(undefined1 *)(param_1 + 8) = 0;
  if (0xf < (ulonglong)param_1[6]) {
    pvVar1 = (void *)param_1[3];
    pvVar2 = pvVar1;
    if ((0xfff < param_1[6] + 1) &&
       (pvVar2 = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)pvVar2)))) {
LAB_180004898:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(pvVar2);
  }
  param_1[5] = 0;
  param_1[6] = 0xf;
  *(undefined1 *)(param_1 + 3) = 0;
  *param_1 = std::exception::vftable;
  __std_exception_destroy(param_1 + 1);
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 1800048a0 (667 bytes) name=FUN_1800048a0

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

undefined8 * FUN_1800048a0(undefined8 *param_1,char *param_2)

{
  longlong *plVar1;
  basic_ostream<char,std::char_traits<char>_> *pbVar2;
  void *pvVar3;
  void *pvVar4;
  size_t sVar5;
  undefined1 auStack_198 [32];
  undefined4 local_178;
  undefined1 local_170;
  undefined7 uStack_16f;
  undefined8 uStack_168;
  undefined8 local_160;
  ulonglong uStack_158;
  undefined8 *local_150;
  int iStack_13c;
  undefined *local_138 [2];
  undefined *local_128;
  undefined **local_120;
  basic_iostream<char,std::char_traits<char>_> local_118 [16];
  longlong *local_108;
  longlong *local_100;
  longlong *local_e8;
  ulonglong *local_e0;
  int *local_d0;
  ulonglong local_b8;
  uint local_b0;
  basic_ios<char,std::char_traits<char>_> local_a0 [104];
  ulonglong local_38;
  ulonglong uVar6;
  
  local_38 = DAT_180015010 ^ (ulonglong)auStack_198;
  local_178 = 0;
  param_1[1] = 0;
  param_1[2] = 0;
  *param_1 = serial::PortNotOpenedException::vftable;
  plVar1 = param_1 + 3;
  param_1[5] = 0;
  param_1[6] = 0xf;
  *(undefined1 *)plVar1 = 0;
  local_150 = param_1;
  memset(local_138,0,0xf8);
  local_138[0] = &DAT_18000fcb8;
  local_128 = &DAT_18000fba8;
  std::basic_ios<char,std::char_traits<char>_>::basic_ios<char,std::char_traits<char>_>(local_a0);
  local_178 = 1;
  std::basic_iostream<char,std::char_traits<char>_>::basic_iostream<char,std::char_traits<char>_>
            ((basic_iostream<char,std::char_traits<char>_> *)local_138,
             (basic_streambuf<char,std::char_traits<char>_> *)&local_120);
  *(undefined ***)((longlong)local_138 + (longlong)*(int *)(local_138[0] + 4)) =
       std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  *(int *)((longlong)&iStack_13c + (longlong)*(int *)(local_138[0] + 4)) =
       *(int *)(local_138[0] + 4) + -0x98;
  std::basic_streambuf<char,std::char_traits<char>_>::basic_streambuf<char,std::char_traits<char>_>
            ((basic_streambuf<char,std::char_traits<char>_> *)&local_120);
  local_120 = std::basic_stringbuf<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  local_b8 = 0;
  local_b0 = 0;
  pbVar2 = FUN_180006310((basic_ostream<char,std::char_traits<char>_> *)&local_128,
                         "PortNotOpenedException ");
  pbVar2 = FUN_180006310(pbVar2,param_2);
  FUN_180006310(pbVar2," failed.");
  local_160 = 0;
  uStack_158 = 0xf;
  local_170 = 0;
  local_178 = 5;
  if (((local_b0 & 2) == 0) && (uVar6 = *local_e0, uVar6 != 0)) {
    pvVar4 = (void *)*local_100;
    if (uVar6 < local_b8) {
      uVar6 = local_b8;
    }
    sVar5 = uVar6 - (longlong)pvVar4;
LAB_180004a2b:
    FUN_180002610((longlong *)&local_170,pvVar4,sVar5);
  }
  else if (((local_b0 & 4) == 0) && (*local_e8 != 0)) {
    pvVar4 = (void *)*local_108;
    sVar5 = ((longlong)*local_d0 - (longlong)pvVar4) + *local_e8;
    goto LAB_180004a2b;
  }
  if (plVar1 == (longlong *)&local_170) {
    if (0xf < uStack_158) {
      pvVar3 = (void *)CONCAT71(uStack_16f,local_170);
      pvVar4 = pvVar3;
      if ((0xfff < uStack_158 + 1) &&
         (pvVar4 = *(void **)((longlong)pvVar3 + -8),
         0x1f < (ulonglong)((longlong)pvVar3 + (-8 - (longlong)pvVar4)))) goto LAB_180004ac7;
      free(pvVar4);
    }
  }
  else {
    if (0xf < (ulonglong)param_1[6]) {
      pvVar4 = (void *)*plVar1;
      pvVar3 = pvVar4;
      if ((0xfff < param_1[6] + 1) &&
         (pvVar3 = *(void **)((longlong)pvVar4 + -8),
         0x1f < (ulonglong)((longlong)pvVar4 + (-8 - (longlong)pvVar3)))) {
LAB_180004ac7:
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(pvVar3);
    }
    param_1[6] = 0xf;
    *(undefined1 *)plVar1 = 0;
    *plVar1 = CONCAT71(uStack_16f,local_170);
    param_1[4] = uStack_168;
    param_1[5] = local_160;
    param_1[6] = uStack_158;
  }
  *(undefined ***)((longlong)local_138 + (longlong)*(int *)(local_138[0] + 4)) =
       std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  *(int *)((longlong)&iStack_13c + (longlong)*(int *)(local_138[0] + 4)) =
       *(int *)(local_138[0] + 4) + -0x98;
  FUN_180005f90((basic_streambuf<char,std::char_traits<char>_> *)&local_120);
  std::basic_iostream<char,std::char_traits<char>_>::~basic_iostream<char,std::char_traits<char>_>
            (local_118);
  std::basic_ios<char,std::char_traits<char>_>::~basic_ios<char,std::char_traits<char>_>(local_a0);
  return param_1;
}


==================================================================

### EXPORT FUNC 180004b40 (53 bytes) name=FUN_180004b40

undefined8 * FUN_180004b40(undefined8 *param_1,longlong param_2)

{
  param_1[1] = 0;
  param_1[2] = 0;
  *param_1 = serial::PortNotOpenedException::vftable;
  FUN_180002e60(param_1 + 3,(undefined8 *)(param_2 + 0x18));
  return param_1;
}


==================================================================

### EXPORT FUNC 180004b80 (126 bytes) name=FUN_180004b80

void FUN_180004b80(undefined8 *param_1)

{
  void *pvVar1;
  void *_Memory;
  
  *param_1 = serial::PortNotOpenedException::vftable;
  if (0xf < (ulonglong)param_1[6]) {
    pvVar1 = (void *)param_1[3];
    _Memory = pvVar1;
    if ((0xfff < param_1[6] + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  param_1[5] = 0;
  param_1[6] = 0xf;
  *(undefined1 *)(param_1 + 3) = 0;
  *param_1 = std::exception::vftable;
                    /* WARNING: Could not recover jumptable at 0x000180004bf1. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  __std_exception_destroy(param_1 + 1);
  return;
}


==================================================================

### EXPORT FUNC 180004c00 (159 bytes) name=FUN_180004c00

undefined8 * FUN_180004c00(undefined8 *param_1,uint param_2)

{
  void *pvVar1;
  void *_Memory;
  
  *param_1 = serial::PortNotOpenedException::vftable;
  if (0xf < (ulonglong)param_1[6]) {
    pvVar1 = (void *)param_1[3];
    _Memory = pvVar1;
    if ((0xfff < param_1[6] + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  param_1[5] = 0;
  param_1[6] = 0xf;
  *(undefined1 *)(param_1 + 3) = 0;
  *param_1 = std::exception::vftable;
  __std_exception_destroy(param_1 + 1);
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 180004ca0 (744 bytes) name=FUN_180004ca0

undefined8 * FUN_180004ca0(undefined8 *param_1,undefined8 *param_2)

{
  ulonglong *puVar1;
  longlong lVar2;
  ulonglong uVar3;
  ulonglong uVar4;
  undefined8 uVar5;
  short *psVar6;
  ulonglong uVar7;
  void *_Dst;
  undefined8 *puVar8;
  longlong lVar9;
  undefined8 *puVar10;
  
  _Dst = (void *)0x0;
  if (*(int *)(*(longlong *)((longlong)ThreadLocalStoragePointer + (ulonglong)_tls_index * 8) + 4) <
      DAT_1800160e0) {
    _Init_thread_header(&DAT_1800160e0);
    if (DAT_1800160e0 == -1) {
      DAT_1800160d0 = 0;
      DAT_1800160d8 = 7;
      DAT_1800160c0._0_2_ = 0;
      FUN_180003830(&DAT_1800160c0,L"\\\\.\\",4);
      atexit(FUN_18000e680);
      _Init_thread_footer(&DAT_1800160e0);
    }
  }
  psVar6 = (short *)&DAT_1800160c0;
  if (7 < DAT_1800160d8) {
    psVar6 = (short *)CONCAT62(DAT_1800160c0._2_6_,(undefined2)DAT_1800160c0);
  }
  puVar8 = param_2;
  if (7 < (ulonglong)param_2[3]) {
    puVar8 = (undefined8 *)*param_2;
  }
  puVar1 = param_2 + 2;
  uVar3 = *puVar1;
  uVar7 = uVar3;
  if (DAT_1800160d0 < uVar3) {
    uVar7 = DAT_1800160d0;
  }
  if (uVar7 != 0) {
    lVar9 = (longlong)puVar8 - (longlong)psVar6;
    do {
      if (*(short *)(lVar9 + (longlong)psVar6) != *psVar6) goto LAB_180004e80;
      psVar6 = psVar6 + 1;
      uVar7 = uVar7 - 1;
    } while (uVar7 != 0);
  }
  if ((uVar3 < DAT_1800160d0) || (uVar3 != DAT_1800160d0)) {
LAB_180004e80:
    param_1[2] = 0;
    param_1[3] = 7;
    *(undefined2 *)param_1 = 0;
    FUN_180006860(param_1,DAT_1800160d0 + *puVar1);
    uVar3 = DAT_1800160d0;
    puVar8 = &DAT_1800160c0;
    if (7 < DAT_1800160d8) {
      puVar8 = (undefined8 *)CONCAT62(DAT_1800160c0._2_6_,(undefined2)DAT_1800160c0);
    }
    lVar9 = param_1[2];
    uVar7 = param_1[3];
    if (uVar7 - lVar9 < DAT_1800160d0) {
      FUN_1800066a0(param_1,DAT_1800160d0,uVar7,puVar8,DAT_1800160d0);
    }
    else {
      lVar2 = lVar9 + DAT_1800160d0;
      param_1[2] = lVar2;
      puVar10 = param_1;
      if (7 < uVar7) {
        puVar10 = (undefined8 *)*param_1;
      }
      memmove((void *)((longlong)puVar10 + lVar9 * 2),puVar8,uVar3 * 2);
      *(undefined2 *)((longlong)puVar10 + lVar2 * 2) = 0;
    }
    if (7 < (ulonglong)param_2[3]) {
      param_2 = (undefined8 *)*param_2;
    }
    uVar3 = *puVar1;
    lVar9 = param_1[2];
    uVar7 = param_1[3];
    if (uVar7 - lVar9 < uVar3) {
      FUN_1800066a0(param_1,uVar3,uVar7,param_2,uVar3);
    }
    else {
      param_1[2] = lVar9 + uVar3;
      puVar8 = param_1;
      if (7 < uVar7) {
        puVar8 = (undefined8 *)*param_1;
      }
      memmove((void *)((longlong)puVar8 + lVar9 * 2),param_2,uVar3 * 2);
      *(undefined2 *)((longlong)puVar8 + (lVar9 + uVar3) * 2) = 0;
    }
  }
  else {
    param_1[2] = 0;
    param_1[3] = 0;
    uVar3 = *puVar1;
    if (7 < (ulonglong)param_2[3]) {
      param_2 = (undefined8 *)*param_2;
    }
    if (uVar3 < 8) {
      uVar5 = param_2[1];
      *param_1 = *param_2;
      param_1[1] = uVar5;
      param_1[2] = uVar3;
      param_1[3] = 7;
    }
    else {
      uVar7 = uVar3 | 7;
      if (0x7ffffffffffffffe < uVar7) {
        uVar7 = 0x7ffffffffffffffe;
      }
      if (0x7fffffffffffffff < uVar7 + 1) {
LAB_180004f84:
                    /* WARNING: Subroutine does not return */
        FUN_180001750();
      }
      uVar4 = (uVar7 + 1) * 2;
      if (uVar4 < 0x1000) {
        if (uVar4 != 0) {
          _Dst = (void *)FUN_18000c554(uVar4);
        }
      }
      else {
        if (uVar4 + 0x27 <= uVar4) goto LAB_180004f84;
        lVar9 = FUN_18000c554(uVar4 + 0x27);
        if (lVar9 == 0) {
                    /* WARNING: Subroutine does not return */
          _invalid_parameter_noinfo_noreturn();
        }
        _Dst = (void *)(lVar9 + 0x27U & 0xffffffffffffffe0);
        *(longlong *)((longlong)_Dst - 8) = lVar9;
      }
      *param_1 = _Dst;
      memcpy(_Dst,param_2,uVar3 * 2 + 2);
      param_1[2] = uVar3;
      param_1[3] = uVar7;
    }
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 180004f90 (170 bytes) name=FUN_180004f90

undefined8 * FUN_180004f90(undefined8 *param_1,uint param_2)

{
  void *pvVar1;
  void *_Memory;
  
  *param_1 = serial::Serial::SerialImpl::vftable;
  FUN_180005790((longlong)param_1);
  CloseHandle((HANDLE)param_1[0xc]);
  CloseHandle((HANDLE)param_1[0xd]);
  if (7 < (ulonglong)param_1[4]) {
    pvVar1 = (void *)param_1[1];
    _Memory = pvVar1;
    if ((0xfff < param_1[4] * 2 + 2U) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  param_1[3] = 0;
  param_1[4] = 7;
  *(undefined2 *)(param_1 + 1) = 0;
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 180005040 (760 bytes) name=FUN_180005040

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

void FUN_180005040(longlong param_1)

{
  DWORD DVar1;
  HANDLE pvVar2;
  longlong *plVar3;
  basic_ostream<char,std::char_traits<char>_> *pbVar4;
  longlong *plVar5;
  char *pcVar6;
  LPCWSTR ***ppppWVar7;
  undefined8 uVar8;
  undefined1 auStackY_258 [32];
  longlong local_208 [4];
  longlong local_1e8 [8];
  undefined8 local_1a8 [14];
  LPCWSTR **local_138 [3];
  undefined8 local_120;
  undefined *local_118 [2];
  undefined *local_108;
  undefined **local_100 [13];
  undefined8 local_98;
  undefined4 local_90;
  basic_ios<char,std::char_traits<char>_> local_80 [104];
  ulonglong local_18;
  
  local_18 = DAT_180015010 ^ (ulonglong)auStackY_258;
  if (*(longlong *)(param_1 + 0x18) == 0) {
    FUN_180003e20(local_208,"Empty port is invalid.");
                    /* WARNING: Subroutine does not return */
    _CxxThrowException(local_208,(ThrowInfo *)&DAT_180013448);
  }
  if (*(char *)(param_1 + 0x30) != '\x01') {
    FUN_180004ca0(local_138,(undefined8 *)(param_1 + 8));
    ppppWVar7 = local_138;
    if (7 < local_120) {
      ppppWVar7 = (LPCWSTR ***)local_138[0];
    }
    pvVar2 = CreateFileW((LPCWSTR)ppppWVar7,0xc0000000,0,(LPSECURITY_ATTRIBUTES)0x0,3,0x80,
                         (HANDLE)0x0);
    *(HANDLE *)(param_1 + 0x28) = pvVar2;
    if (pvVar2 == (HANDLE)0xffffffffffffffff) {
      DVar1 = GetLastError();
      memset(local_118,0,0xf8);
      local_118[0] = &DAT_18000fcb8;
      local_108 = &DAT_18000fba8;
      std::basic_ios<char,std::char_traits<char>_>::basic_ios<char,std::char_traits<char>_>
                (local_80);
      uVar8 = 0;
      std::basic_iostream<char,std::char_traits<char>_>::
      basic_iostream<char,std::char_traits<char>_>
                ((basic_iostream<char,std::char_traits<char>_> *)local_118,
                 (basic_streambuf<char,std::char_traits<char>_> *)local_100);
      *(undefined ***)((longlong)local_118 + (longlong)*(int *)(local_118[0] + 4)) =
           std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>_>::vftable;
      *(int *)((longlong)local_118 + (longlong)*(int *)(local_118[0] + 4) + -4) =
           *(int *)(local_118[0] + 4) + -0x98;
      std::basic_streambuf<char,std::char_traits<char>_>::
      basic_streambuf<char,std::char_traits<char>_>
                ((basic_streambuf<char,std::char_traits<char>_> *)local_100);
      local_100[0] = std::basic_stringbuf<char,std::char_traits<char>,std::allocator<char>_>::
                     vftable;
      local_98 = 0;
      local_90 = 0;
      if (DVar1 == 2) {
        plVar3 = FUN_1800059c0(param_1,local_208,uVar8);
        pbVar4 = FUN_180006310((basic_ostream<char,std::char_traits<char>_> *)&local_108,
                               "Specified port, ");
        pbVar4 = (basic_ostream<char,std::char_traits<char>_> *)FUN_1800064e0(pbVar4,(char *)plVar3)
        ;
        FUN_180006310(pbVar4,", does not exist.");
        FUN_1800024b0(local_208);
        plVar3 = FUN_180006050((longlong)local_118,local_1e8);
        plVar5 = FUN_180002510(local_208,
                               "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                              );
        pcVar6 = (char *)FUN_1800061b0(plVar3);
        FUN_180004310(local_1a8,plVar5,0x53,pcVar6);
                    /* WARNING: Subroutine does not return */
        _CxxThrowException(local_1a8,(ThrowInfo *)&DAT_1800134b8);
      }
      pbVar4 = FUN_180006310((basic_ostream<char,std::char_traits<char>_> *)&local_108,
                             "Unknown error opening the serial port: ");
      std::basic_ostream<char,std::char_traits<char>_>::operator<<(pbVar4,DVar1);
      plVar3 = FUN_180006050((longlong)local_118,local_1e8);
      plVar5 = FUN_180002510(local_208,
                             "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                            );
      pcVar6 = (char *)FUN_1800061b0(plVar3);
      FUN_180004310(local_1a8,plVar5,0x56,pcVar6);
                    /* WARNING: Subroutine does not return */
      _CxxThrowException(local_1a8,(ThrowInfo *)&DAT_1800134b8);
    }
    FUN_1800053c0(param_1);
    *(undefined1 *)(param_1 + 0x30) = 1;
    if (7 < local_120) {
      ppppWVar7 = (LPCWSTR ***)local_138[0];
      if ((0xfff < local_120 * 2 + 2) &&
         (ppppWVar7 = (LPCWSTR ***)local_138[0][-1],
         0x1f < (ulonglong)((longlong)local_138[0] + (-8 - (longlong)ppppWVar7)))) {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(ppppWVar7);
    }
    return;
  }
  FUN_180003e90(local_1e8);
                    /* WARNING: Subroutine does not return */
  _CxxThrowException(local_1e8,(ThrowInfo *)&DAT_1800133a0);
}


==================================================================

### EXPORT FUNC 180005340 (61 bytes) name=FUN_180005340

undefined8 * FUN_180005340(undefined8 *param_1,longlong param_2)

{
  *param_1 = std::exception::vftable;
  param_1[1] = 0;
  param_1[2] = 0;
  __std_exception_copy(param_2 + 8);
  *param_1 = std::invalid_argument::vftable;
  return param_1;
}


==================================================================

### EXPORT FUNC 180005380 (61 bytes) name=FUN_180005380

undefined8 * FUN_180005380(undefined8 *param_1,longlong param_2)

{
  *param_1 = std::exception::vftable;
  param_1[1] = 0;
  param_1[2] = 0;
  __std_exception_copy(param_2 + 8);
  *param_1 = std::logic_error::vftable;
  return param_1;
}


==================================================================

### EXPORT FUNC 1800053c0 (968 bytes) name=FUN_1800053c0

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

void FUN_1800053c0(longlong param_1)

{
  uint uVar1;
  int iVar2;
  BOOL BVar3;
  longlong *plVar4;
  undefined1 auStack_108 [40];
  longlong local_e0 [5];
  undefined8 local_b8 [14];
  _DCB local_48;
  _COMMTIMEOUTS local_28;
  ulonglong local_10;
  
  local_10 = DAT_180015010 ^ (ulonglong)auStack_108;
  if (*(HANDLE *)(param_1 + 0x28) == (HANDLE)0xffffffffffffffff) {
    plVar4 = FUN_180002510(local_e0,
                           "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                          );
    FUN_180004310(local_b8,plVar4,99,"Invalid file descriptor, is the serial port open?");
                    /* WARNING: Subroutine does not return */
    _CxxThrowException(local_b8,(ThrowInfo *)&DAT_1800134b8);
  }
  local_48.StopBits = '\0';
  local_48.XonChar = '\0';
  local_48.XoffChar = '\0';
  local_48.ErrorChar = '\0';
  local_48.EofChar = '\0';
  local_48.EvtChar = '\0';
  local_48.wReserved1 = 0;
  local_48.DCBlength = 0x1c;
  local_48.BaudRate = 0;
  local_48._8_4_ = 0;
  local_48.wReserved = 0;
  local_48.XonLim = 0;
  local_48.XoffLim = 0;
  local_48.ByteSize = '\0';
  local_48.Parity = '\0';
  BVar3 = GetCommState(*(HANDLE *)(param_1 + 0x28),&local_48);
  if (BVar3 == 0) {
    plVar4 = FUN_180002510(local_e0,
                           "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                          );
    FUN_180004310(local_b8,plVar4,0x6c,"Error getting the serial port state.");
                    /* WARNING: Subroutine does not return */
    _CxxThrowException(local_b8,(ThrowInfo *)&DAT_1800134b8);
  }
  uVar1 = *(uint *)(param_1 + 0x48);
  local_48.BaudRate = uVar1;
  if (uVar1 < 0x3841) {
    if (uVar1 == 0x3840) {
      local_48.BaudRate = 0x3840;
    }
    else if (uVar1 < 0x4b1) {
      if (uVar1 == 0x4b0) {
        local_48.BaudRate = 0x4b0;
      }
      else if (uVar1 == 0x6e) {
        local_48.BaudRate = 0x6e;
      }
      else if (uVar1 == 300) {
        local_48.BaudRate = 300;
      }
    }
    else if (uVar1 == 0x960) {
      local_48.BaudRate = 0x960;
    }
    else if (uVar1 == 0x12c0) {
      local_48.BaudRate = 0x12c0;
    }
  }
  else if (uVar1 < 0x1c201) {
    if (uVar1 == 0x1c200) {
      local_48.BaudRate = 0x1c200;
    }
    else if (uVar1 == 0x4b00) {
      local_48.BaudRate = 0x4b00;
    }
    else if (uVar1 == 0x9600) {
      local_48.BaudRate = 0x9600;
    }
  }
  else if (uVar1 == 0x1f400) {
    local_48.BaudRate = 0x1f400;
  }
  else if (uVar1 == 0x3e800) {
    local_48.BaudRate = 0x3e800;
  }
  iVar2 = *(int *)(param_1 + 0x50);
  if (iVar2 == 8) {
    local_48.ByteSize = '\b';
  }
  else if (iVar2 == 7) {
    local_48.ByteSize = '\a';
  }
  else if (iVar2 == 6) {
    local_48.ByteSize = '\x06';
  }
  else {
    if (iVar2 != 5) {
      FUN_180003e20(local_e0,"invalid char len");
                    /* WARNING: Subroutine does not return */
      _CxxThrowException(local_e0,(ThrowInfo *)&DAT_180013448);
    }
    local_48.ByteSize = '\x05';
  }
  iVar2 = *(int *)(param_1 + 0x54);
  if (iVar2 == 1) {
    local_48._20_8_ = local_48._20_8_ & 0xffffffffffffff00;
  }
  else if (iVar2 == 3) {
    local_48.StopBits = 1;
  }
  else {
    if (iVar2 != 2) {
      FUN_180003e20(local_e0,"invalid stop bit");
                    /* WARNING: Subroutine does not return */
      _CxxThrowException(local_e0,(ThrowInfo *)&DAT_180013448);
    }
    local_48.StopBits = 2;
  }
  iVar2 = *(int *)(param_1 + 0x4c);
  if ((((iVar2 != 0) && (iVar2 != 2)) && (iVar2 != 1)) && ((iVar2 != 3 && (iVar2 != 4)))) {
    FUN_180003e20(local_e0,"invalid parity");
                    /* WARNING: Subroutine does not return */
    _CxxThrowException(local_e0,(ThrowInfo *)&DAT_180013448);
  }
  local_48.Parity = (BYTE)iVar2;
  iVar2 = *(int *)(param_1 + 0x58);
  if (iVar2 == 0) {
    local_48._8_4_ = local_48._8_4_ & 0xffffccfb;
  }
  else if (iVar2 == 1) {
    local_48._8_4_ = local_48._8_4_ & 0xffffcffb | 0x300;
  }
  else if (iVar2 == 2) {
    local_48._8_4_ = local_48._8_4_ & 0xffffecff | 0x2004;
  }
  BVar3 = SetCommState(*(HANDLE *)(param_1 + 0x28),&local_48);
  if (BVar3 == 0) {
    CloseHandle(*(HANDLE *)(param_1 + 0x28));
    plVar4 = FUN_180002510(local_e0,
                           "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                          );
    FUN_180004310(local_b8,plVar4,0x106,"Error setting serial port settings.");
                    /* WARNING: Subroutine does not return */
    _CxxThrowException(local_b8,(ThrowInfo *)&DAT_1800134b8);
  }
  local_28.ReadIntervalTimeout = *(DWORD *)(param_1 + 0x34);
  local_28.ReadTotalTimeoutConstant = *(DWORD *)(param_1 + 0x38);
  local_28.ReadTotalTimeoutMultiplier = *(DWORD *)(param_1 + 0x3c);
  local_28.WriteTotalTimeoutConstant = *(DWORD *)(param_1 + 0x40);
  local_28.WriteTotalTimeoutMultiplier = *(DWORD *)(param_1 + 0x44);
  BVar3 = SetCommTimeouts(*(HANDLE *)(param_1 + 0x28),&local_28);
  if (BVar3 != 0) {
    return;
  }
  plVar4 = FUN_180002510(local_e0,
                         "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                        );
  FUN_180004310(local_b8,plVar4,0x111,"Error setting timeouts.");
                    /* WARNING: Subroutine does not return */
  _CxxThrowException(local_b8,(ThrowInfo *)&DAT_1800134b8);
}


==================================================================

### EXPORT FUNC 180005790 (244 bytes) name=FUN_180005790

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

void FUN_180005790(longlong param_1)

{
  BOOL BVar1;
  DWORD DVar2;
  basic_ostream<char,std::char_traits<char>_> *this;
  longlong *plVar3;
  longlong *plVar4;
  char *pcVar5;
  undefined1 auStack_1f8 [40];
  longlong local_1d0 [4];
  longlong local_1b0 [5];
  undefined8 local_188 [14];
  basic_iostream<char,std::char_traits<char>_> local_118 [16];
  basic_ostream<char,std::char_traits<char>_> local_108 [240];
  ulonglong local_18;
  
  local_18 = DAT_180015010 ^ (ulonglong)auStack_1f8;
  if (*(char *)(param_1 + 0x30) == '\x01') {
    if (*(HANDLE *)(param_1 + 0x28) != (HANDLE)0xffffffffffffffff) {
      BVar1 = CloseHandle(*(HANDLE *)(param_1 + 0x28));
      if (BVar1 == 0) {
        FUN_180004300(local_118);
        FUN_1800060f0(local_118);
        DVar2 = GetLastError();
        this = FUN_180006310(local_108,"Error while closing serial port: ");
        std::basic_ostream<char,std::char_traits<char>_>::operator<<(this,DVar2);
        plVar3 = FUN_180006050((longlong)local_118,local_1b0);
        plVar4 = FUN_180002510(local_1d0,
                               "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                              );
        pcVar5 = (char *)FUN_1800061b0(plVar3);
        FUN_180004310(local_188,plVar4,0x11f,pcVar5);
                    /* WARNING: Subroutine does not return */
        _CxxThrowException(local_188,(ThrowInfo *)&DAT_1800134b8);
      }
      *(undefined8 *)(param_1 + 0x28) = 0xffffffffffffffff;
    }
    *(undefined1 *)(param_1 + 0x30) = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 180005890 (291 bytes) name=FUN_180005890

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

DWORD FUN_180005890(longlong param_1,LPVOID param_2,DWORD param_3)

{
  BOOL BVar1;
  DWORD DVar2;
  basic_ostream<char,std::char_traits<char>_> *this;
  longlong *plVar3;
  longlong *plVar4;
  char *pcVar5;
  undefined1 auStackY_228 [32];
  longlong local_1f0 [4];
  longlong local_1d0 [7];
  undefined8 local_198 [14];
  DWORD local_128 [4];
  basic_iostream<char,std::char_traits<char>_> local_118 [16];
  basic_ostream<char,std::char_traits<char>_> local_108 [240];
  ulonglong local_18;
  
  local_18 = DAT_180015010 ^ (ulonglong)auStackY_228;
  if (*(char *)(param_1 + 0x30) == '\0') {
    FUN_1800048a0(local_1d0,"Serial::read");
                    /* WARNING: Subroutine does not return */
    _CxxThrowException(local_1d0,(ThrowInfo *)&DAT_1800134d8);
  }
  BVar1 = ReadFile(*(HANDLE *)(param_1 + 0x28),param_2,param_3,local_128,(LPOVERLAPPED)0x0);
  if (BVar1 != 0) {
    return local_128[0];
  }
  FUN_180004300(local_118);
  FUN_1800060f0(local_118);
  DVar2 = GetLastError();
  this = FUN_180006310(local_108,"Error while reading from the serial port: ");
  std::basic_ostream<char,std::char_traits<char>_>::operator<<(this,DVar2);
  plVar3 = FUN_180006050((longlong)local_118,local_1d0);
  plVar4 = FUN_180002510(local_1f0,
                         "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                        );
  pcVar5 = (char *)FUN_1800061b0(plVar3);
  FUN_180004310(local_198,plVar4,0x154,pcVar5);
                    /* WARNING: Subroutine does not return */
  _CxxThrowException(local_198,(ThrowInfo *)&DAT_1800134b8);
}


==================================================================

### EXPORT FUNC 1800059c0 (197 bytes) name=FUN_1800059c0

longlong * FUN_1800059c0(longlong param_1,longlong *param_2,undefined8 param_3)

{
  undefined1 uVar1;
  longlong lVar2;
  ulonglong uVar3;
  longlong *plVar4;
  undefined8 *puVar5;
  ulonglong uVar6;
  undefined8 *puVar7;
  bool bVar8;
  
  puVar7 = (undefined8 *)(param_1 + 8);
  bVar8 = 7 < *(ulonglong *)(param_1 + 0x20);
  puVar5 = puVar7;
  if (bVar8) {
    puVar5 = (undefined8 *)*puVar7;
  }
  lVar2 = *(longlong *)(param_1 + 0x18);
  if (bVar8) {
    puVar7 = (undefined8 *)*puVar7;
  }
  param_2[2] = 0;
  param_2[3] = 0xf;
  *(undefined1 *)param_2 = 0;
  uVar6 = ((longlong)puVar5 + lVar2 * 2) - (longlong)puVar7 >> 1;
  if (0xf < uVar6) {
    FUN_180006c50(param_2,uVar6);
    param_2[2] = 0;
  }
  for (; puVar7 != (undefined8 *)((longlong)puVar5 + lVar2 * 2);
      puVar7 = (undefined8 *)((longlong)puVar7 + 2)) {
    uVar1 = *(undefined1 *)puVar7;
    uVar6 = param_2[2];
    uVar3 = param_2[3];
    if (uVar6 < uVar3) {
      param_2[2] = uVar6 + 1;
      plVar4 = param_2;
      if (0xf < uVar3) {
        plVar4 = (longlong *)*param_2;
      }
      *(undefined1 *)((longlong)plVar4 + uVar6) = uVar1;
      *(undefined1 *)((longlong)plVar4 + uVar6 + 1) = 0;
    }
    else {
      FUN_180002770(param_2,uVar3,param_3,uVar1);
    }
  }
  return param_2;
}


==================================================================

### EXPORT FUNC 180005a90 (233 bytes) name=FUN_180005a90

ulonglong * FUN_180005a90(longlong param_1,ulonglong *param_2,longlong *param_3,byte param_4)

{
  longlong lVar1;
  int iVar2;
  longlong lVar3;
  ulonglong uVar4;
  longlong lVar5;
  longlong lVar6;
  undefined8 uVar7;
  ulonglong uVar8;
  
  uVar8 = param_3[1] + *param_3;
  lVar3 = **(longlong **)(param_1 + 0x38);
  uVar4 = **(ulonglong **)(param_1 + 0x40);
  if ((uVar4 != 0) && (*(ulonglong *)(param_1 + 0x68) < uVar4)) {
    *(ulonglong *)(param_1 + 0x68) = uVar4;
  }
  lVar5 = *(longlong *)(param_1 + 0x68);
  lVar6 = **(longlong **)(param_1 + 0x18);
  if (((ulonglong)(lVar5 - lVar6) < uVar8) ||
     ((uVar8 != 0 &&
      ((((param_4 & 1) != 0 && (lVar3 == 0)) || (((param_4 & 2) != 0 && (uVar4 == 0)))))))) {
    *param_2 = 0xffffffffffffffff;
  }
  else {
    lVar1 = lVar6 + uVar8;
    if (((param_4 & 1) != 0) && (lVar3 != 0)) {
      **(longlong **)(param_1 + 0x38) = lVar1;
      **(int **)(param_1 + 0x50) = (int)lVar5 - (int)lVar1;
    }
    if (((param_4 & 2) != 0) && (uVar4 != 0)) {
      iVar2 = **(int **)(param_1 + 0x58);
      uVar7 = **(undefined8 **)(param_1 + 0x40);
      **(longlong **)(param_1 + 0x20) = lVar6;
      **(longlong **)(param_1 + 0x40) = lVar1;
      **(int **)(param_1 + 0x58) = (iVar2 + (int)uVar7) - (int)lVar1;
    }
    *param_2 = uVar8;
  }
  param_2[1] = 0;
  param_2[2] = 0;
  return param_2;
}


==================================================================

### EXPORT FUNC 180005b80 (340 bytes) name=FUN_180005b80

ulonglong *
FUN_180005b80(longlong param_1,ulonglong *param_2,longlong param_3,int param_4,byte param_5)

{
  longlong lVar1;
  int iVar2;
  longlong lVar3;
  ulonglong uVar4;
  longlong lVar5;
  longlong lVar6;
  undefined8 uVar7;
  ulonglong uVar8;
  ulonglong uVar9;
  
  lVar3 = **(longlong **)(param_1 + 0x38);
  uVar4 = **(ulonglong **)(param_1 + 0x40);
  if ((uVar4 != 0) && (*(ulonglong *)(param_1 + 0x68) < uVar4)) {
    *(ulonglong *)(param_1 + 0x68) = uVar4;
  }
  lVar5 = *(longlong *)(param_1 + 0x68);
  lVar6 = **(longlong **)(param_1 + 0x18);
  uVar9 = lVar5 - lVar6;
  if (param_4 == 0) {
    uVar8 = 0;
LAB_180005c31:
    uVar8 = uVar8 + param_3;
    if ((uVar8 <= uVar9) &&
       ((uVar8 == 0 ||
        ((((param_5 & 1) == 0 || (lVar3 != 0)) && (((param_5 & 2) == 0 || (uVar4 != 0)))))))) {
      lVar1 = lVar6 + uVar8;
      if (((param_5 & 1) != 0) && (lVar3 != 0)) {
        **(longlong **)(param_1 + 0x38) = lVar1;
        **(int **)(param_1 + 0x50) = (int)lVar5 - (int)lVar1;
      }
      if (((param_5 & 2) != 0) && (uVar4 != 0)) {
        iVar2 = **(int **)(param_1 + 0x58);
        uVar7 = **(undefined8 **)(param_1 + 0x40);
        **(longlong **)(param_1 + 0x20) = lVar6;
        **(longlong **)(param_1 + 0x40) = lVar1;
        **(int **)(param_1 + 0x58) = (iVar2 + (int)uVar7) - (int)lVar1;
      }
      *param_2 = uVar8;
      goto LAB_180005cac;
    }
  }
  else if (param_4 == 1) {
    if ((param_5 & 3) != 3) {
      if ((param_5 & 1) == 0) {
        if (((param_5 & 2) != 0) && ((uVar4 != 0 || (lVar6 == 0)))) {
          uVar8 = uVar4 - lVar6;
          goto LAB_180005c31;
        }
      }
      else if ((lVar3 != 0) || (lVar6 == 0)) {
        uVar8 = lVar3 - lVar6;
        goto LAB_180005c31;
      }
    }
  }
  else {
    uVar8 = uVar9;
    if (param_4 == 2) goto LAB_180005c31;
  }
  *param_2 = 0xffffffffffffffff;
LAB_180005cac:
  param_2[1] = 0;
  param_2[2] = 0;
  return param_2;
}


==================================================================

### EXPORT FUNC 180005ce0 (104 bytes) name=FUN_180005ce0

ulonglong FUN_180005ce0(longlong param_1)

{
  undefined8 *puVar1;
  byte *pbVar2;
  byte *pbVar3;
  undefined8 uVar4;
  byte *pbVar5;
  
  puVar1 = *(undefined8 **)(param_1 + 0x38);
  pbVar2 = (byte *)*puVar1;
  if (pbVar2 != (byte *)0x0) {
    if (pbVar2 < pbVar2 + **(int **)(param_1 + 0x50)) {
      return (ulonglong)*pbVar2;
    }
    pbVar3 = (byte *)**(undefined8 **)(param_1 + 0x40);
    if ((pbVar3 != (byte *)0x0) && ((*(byte *)(param_1 + 0x70) & 4) == 0)) {
      pbVar5 = *(byte **)(param_1 + 0x68);
      if (*(byte **)(param_1 + 0x68) < pbVar3) {
        pbVar5 = pbVar3;
      }
      if (pbVar2 < pbVar5) {
        *(byte **)(param_1 + 0x68) = pbVar5;
        uVar4 = *puVar1;
        *puVar1 = uVar4;
        **(int **)(param_1 + 0x50) = (int)pbVar5 - (int)uVar4;
        return (ulonglong)*(byte *)**(undefined8 **)(param_1 + 0x38);
      }
    }
  }
  return 0xffffffff;
}


==================================================================

### EXPORT FUNC 180005d50 (82 bytes) name=FUN_180005d50

int FUN_180005d50(longlong param_1,int param_2)

{
  ulonglong uVar1;
  
  uVar1 = **(ulonglong **)(param_1 + 0x38);
  if (((uVar1 != 0) && (**(ulonglong **)(param_1 + 0x18) < uVar1)) &&
     ((param_2 == -1 ||
      (((char)param_2 == *(char *)(uVar1 - 1) || ((*(byte *)(param_1 + 0x70) & 2) == 0)))))) {
    **(int **)(param_1 + 0x50) = **(int **)(param_1 + 0x50) + 1;
    **(longlong **)(param_1 + 0x38) = **(longlong **)(param_1 + 0x38) + -1;
    if (param_2 == -1) {
      param_2 = 0;
    }
    else {
      *(char *)**(undefined8 **)(param_1 + 0x38) = (char)param_2;
    }
    return param_2;
  }
  return -1;
}


==================================================================

### EXPORT FUNC 180005db0 (478 bytes) name=FUN_180005db0

int FUN_180005db0(basic_streambuf<char,std::char_traits<char>_> *param_1,int param_2)

{
  void *_Src;
  undefined8 uVar1;
  uint uVar2;
  char *pcVar3;
  void *pvVar4;
  longlong lVar5;
  ulonglong uVar6;
  ulonglong _Size;
  
  if (((byte)param_1[0x70] & 2) != 0) {
    return -1;
  }
  if (param_2 == -1) {
    return 0;
  }
  uVar6 = **(ulonglong **)(param_1 + 0x40);
  if ((uVar6 != 0) && (uVar6 < (longlong)**(int **)(param_1 + 0x58) + uVar6)) {
    pcVar3 = std::basic_streambuf<char,std::char_traits<char>_>::_Pninc(param_1);
    *pcVar3 = (char)param_2;
    *(ulonglong *)(param_1 + 0x68) = uVar6 + 1;
    return param_2;
  }
  _Src = (void *)**(undefined8 **)(param_1 + 0x18);
  _Size = ((longlong)**(int **)(param_1 + 0x58) + uVar6) - (longlong)_Src;
  if (uVar6 == 0) {
    _Size = 0;
  }
  if (_Size < 0x20) {
    uVar6 = 0x20;
    pvVar4 = (void *)FUN_18000c554(0x20);
  }
  else {
    if (_Size < 0x3fffffff) {
      uVar6 = _Size * 2;
      if (uVar6 < 0x1000) {
        if (uVar6 == 0) {
          pvVar4 = (void *)0x0;
        }
        else {
          pvVar4 = (void *)FUN_18000c554(uVar6);
        }
        goto LAB_180005ea3;
      }
    }
    else {
      uVar6 = 0x7fffffff;
      if (0x7ffffffe < _Size) {
        return -1;
      }
    }
    if (uVar6 + 0x27 <= uVar6) {
                    /* WARNING: Subroutine does not return */
      FUN_180001750();
    }
    lVar5 = FUN_18000c554(uVar6 + 0x27);
    if (lVar5 == 0) goto LAB_180005f67;
    pvVar4 = (void *)(lVar5 + 0x27U & 0xffffffffffffffe0);
    *(longlong *)((longlong)pvVar4 - 8) = lVar5;
  }
LAB_180005ea3:
  memcpy(pvVar4,_Src,_Size);
  lVar5 = _Size + (longlong)pvVar4;
  *(longlong *)(param_1 + 0x68) = lVar5 + 1;
  **(undefined8 **)(param_1 + 0x20) = pvVar4;
  **(longlong **)(param_1 + 0x40) = lVar5;
  **(int **)(param_1 + 0x58) = ((int)pvVar4 - (int)lVar5) + (int)uVar6;
  if (((byte)param_1[0x70] & 4) == 0) {
    uVar1 = *(undefined8 *)(param_1 + 0x68);
    lVar5 = (**(longlong **)(param_1 + 0x38) - (longlong)_Src) + (longlong)pvVar4;
    **(undefined8 **)(param_1 + 0x18) = pvVar4;
    **(longlong **)(param_1 + 0x38) = lVar5;
    **(int **)(param_1 + 0x50) = (int)uVar1 - (int)lVar5;
  }
  else {
    **(undefined8 **)(param_1 + 0x18) = pvVar4;
    **(undefined8 **)(param_1 + 0x38) = 0;
    **(int **)(param_1 + 0x50) = (int)pvVar4;
  }
  uVar2 = *(uint *)(param_1 + 0x70);
  if ((uVar2 & 1) != 0) {
    pvVar4 = _Src;
    if ((0xfff < _Size) &&
       (pvVar4 = *(void **)((longlong)_Src + -8),
       0x1f < (ulonglong)((longlong)_Src + (-8 - (longlong)pvVar4)))) {
LAB_180005f67:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(pvVar4);
    uVar2 = *(uint *)(param_1 + 0x70);
  }
  *(uint *)(param_1 + 0x70) = uVar2 | 1;
  pcVar3 = std::basic_streambuf<char,std::char_traits<char>_>::_Pninc(param_1);
  *pcVar3 = (char)param_2;
  return param_2;
}


==================================================================

### EXPORT FUNC 180005f90 (182 bytes) name=FUN_180005f90

void FUN_180005f90(basic_streambuf<char,std::char_traits<char>_> *param_1)

{
  void *pvVar1;
  void *_Memory;
  longlong lVar2;
  
  *(undefined ***)param_1 =
       std::basic_stringbuf<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  if (((byte)param_1[0x70] & 1) != 0) {
    if (**(longlong **)(param_1 + 0x40) == 0) {
      lVar2 = (longlong)**(int **)(param_1 + 0x50) + **(longlong **)(param_1 + 0x38);
    }
    else {
      lVar2 = (longlong)**(int **)(param_1 + 0x58) + **(longlong **)(param_1 + 0x40);
    }
    pvVar1 = (void *)**(longlong **)(param_1 + 0x18);
    _Memory = pvVar1;
    if ((0xfff < (ulonglong)(lVar2 - (longlong)pvVar1)) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  **(undefined8 **)(param_1 + 0x18) = 0;
  **(undefined8 **)(param_1 + 0x38) = 0;
  **(undefined4 **)(param_1 + 0x50) = 0;
  **(undefined8 **)(param_1 + 0x20) = 0;
  **(undefined8 **)(param_1 + 0x40) = 0;
  **(undefined4 **)(param_1 + 0x58) = 0;
  *(uint *)(param_1 + 0x70) = *(uint *)(param_1 + 0x70) & 0xfffffffe;
  *(undefined8 *)(param_1 + 0x68) = 0;
                    /* WARNING: Could not recover jumptable at 0x000180006039. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  std::basic_streambuf<char,std::char_traits<char>_>::~basic_streambuf<char,std::char_traits<char>_>
            (param_1);
  return;
}


==================================================================

### EXPORT FUNC 180006050 (156 bytes) name=FUN_180006050

longlong * FUN_180006050(longlong param_1,longlong *param_2)

{
  ulonglong uVar1;
  void *pvVar2;
  ulonglong *puVar3;
  size_t sVar4;
  ulonglong local_20;
  longlong *local_18;
  
  local_18 = param_2;
  param_2[2] = 0;
  param_2[3] = 0xf;
  *(undefined1 *)param_2 = 0;
  if (((*(uint *)(param_1 + 0x88) & 2) == 0) &&
     (uVar1 = **(ulonglong **)(param_1 + 0x58), uVar1 != 0)) {
    pvVar2 = (void *)**(longlong **)(param_1 + 0x38);
    local_20 = uVar1;
    puVar3 = &local_20;
    if (uVar1 < *(ulonglong *)(param_1 + 0x80)) {
      puVar3 = (ulonglong *)(param_1 + 0x80);
    }
    sVar4 = *puVar3 - (longlong)pvVar2;
  }
  else {
    if ((*(uint *)(param_1 + 0x88) & 4) != 0) {
      return param_2;
    }
    if (**(longlong **)(param_1 + 0x50) == 0) {
      return param_2;
    }
    pvVar2 = (void *)**(longlong **)(param_1 + 0x30);
    sVar4 = ((longlong)**(int **)(param_1 + 0x68) - (longlong)pvVar2) +
            **(longlong **)(param_1 + 0x50);
  }
  FUN_180002610(param_2,pvVar2,sVar4);
  return param_2;
}


==================================================================

### EXPORT FUNC 1800060f0 (182 bytes) name=FUN_1800060f0

basic_iostream<char,std::char_traits<char>_> *
FUN_1800060f0(basic_iostream<char,std::char_traits<char>_> *param_1)

{
  basic_streambuf<char,std::char_traits<char>_> *this;
  
  *(undefined **)param_1 = &DAT_18000fcb8;
  *(undefined **)(param_1 + 0x10) = &DAT_18000fba8;
  std::basic_ios<char,std::char_traits<char>_>::basic_ios<char,std::char_traits<char>_>
            ((basic_ios<char,std::char_traits<char>_> *)(param_1 + 0x98));
  this = (basic_streambuf<char,std::char_traits<char>_> *)(param_1 + 0x18);
  std::basic_iostream<char,std::char_traits<char>_>::basic_iostream<char,std::char_traits<char>_>
            (param_1,this);
  *(undefined ***)(param_1 + *(int *)(*(longlong *)param_1 + 4)) =
       std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  *(int *)(param_1 + (longlong)*(int *)(*(longlong *)param_1 + 4) + -4) =
       *(int *)(*(longlong *)param_1 + 4) + -0x98;
  std::basic_streambuf<char,std::char_traits<char>_>::basic_streambuf<char,std::char_traits<char>_>
            (this);
  *(undefined ***)this =
       std::basic_stringbuf<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  *(undefined8 *)(param_1 + 0x80) = 0;
  *(undefined4 *)(param_1 + 0x88) = 0;
  return param_1;
}


==================================================================

### EXPORT FUNC 1800061b0 (15 bytes) name=FUN_1800061b0

undefined8 * FUN_1800061b0(undefined8 *param_1)

{
  if (0xf < (ulonglong)param_1[3]) {
    return (undefined8 *)*param_1;
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 1800061c0 (52 bytes) name=FUN_1800061c0

basic_streambuf<char,std::char_traits<char>_> *
FUN_1800061c0(basic_streambuf<char,std::char_traits<char>_> *param_1,uint param_2)

{
  FUN_180005f90(param_1);
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 180006200 (146 bytes) name=FUN_180006200

basic_ios<char,std::char_traits<char>_> *
FUN_180006200(basic_ios<char,std::char_traits<char>_> *param_1,uint param_2)

{
  *(undefined ***)(param_1 + (longlong)*(int *)(*(longlong *)(param_1 + -0x98) + 4) + -0x98) =
       std::basic_stringstream<char,std::char_traits<char>,std::allocator<char>_>::vftable;
  *(int *)(param_1 + (longlong)*(int *)(*(longlong *)(param_1 + -0x98) + 4) + -0x9c) =
       *(int *)(*(longlong *)(param_1 + -0x98) + 4) + -0x98;
  FUN_180005f90((basic_streambuf<char,std::char_traits<char>_> *)(param_1 + -0x80));
  std::basic_iostream<char,std::char_traits<char>_>::~basic_iostream<char,std::char_traits<char>_>
            ((basic_iostream<char,std::char_traits<char>_> *)(param_1 + -0x78));
  std::basic_ios<char,std::char_traits<char>_>::~basic_ios<char,std::char_traits<char>_>(param_1);
  if ((param_2 & 1) != 0) {
    free(param_1 + -0x98);
  }
  return param_1 + -0x98;
}


==================================================================

### EXPORT FUNC 1800062a0 (63 bytes) name=FUN_1800062a0

void FUN_1800062a0(longlong *param_1)

{
  longlong *plVar1;
  bool bVar2;
  
  bVar2 = std::uncaught_exception();
  if (!bVar2) {
    std::basic_ostream<char,std::char_traits<char>_>::_Osfx
              ((basic_ostream<char,std::char_traits<char>_> *)*param_1);
  }
  plVar1 = *(longlong **)((longlong)*(int *)(*(longlong *)*param_1 + 4) + 0x48 + *param_1);
  if (plVar1 != (longlong *)0x0) {
    (**(code **)(*plVar1 + 0x10))();
  }
  return;
}


==================================================================

### EXPORT FUNC 1800062e0 (36 bytes) name=FUN_1800062e0

void FUN_1800062e0(longlong *param_1)

{
  longlong *plVar1;
  
  plVar1 = *(longlong **)((longlong)*(int *)(*(longlong *)*param_1 + 4) + 0x48 + *param_1);
  if (plVar1 != (longlong *)0x0) {
    (**(code **)(*plVar1 + 0x10))();
  }
  return;
}


==================================================================

### EXPORT FUNC 180006310 (444 bytes) name=FUN_180006310

basic_ostream<char,std::char_traits<char>_> *
FUN_180006310(basic_ostream<char,std::char_traits<char>_> *param_1,char *param_2)

{
  longlong *plVar1;
  basic_ostream<char,std::char_traits<char>_> *this;
  bool bVar2;
  int iVar3;
  __int64 _Var4;
  longlong lVar5;
  int iVar6;
  longlong lVar7;
  longlong lVar8;
  
  iVar6 = 0;
  lVar8 = -1;
  do {
    lVar8 = lVar8 + 1;
  } while (param_2[lVar8] != '\0');
  lVar5 = *(longlong *)param_1;
  lVar7 = *(longlong *)(param_1 + (longlong)*(int *)(lVar5 + 4) + 0x28);
  if ((lVar7 < 1) || (lVar7 <= lVar8)) {
    lVar7 = 0;
  }
  else {
    lVar7 = lVar7 - lVar8;
  }
  plVar1 = *(longlong **)(param_1 + (longlong)*(int *)(lVar5 + 4) + 0x48);
  if (plVar1 != (longlong *)0x0) {
    (**(code **)(*plVar1 + 8))(plVar1);
    lVar5 = *(longlong *)param_1;
  }
  if (*(int *)(param_1 + (longlong)*(int *)(lVar5 + 4) + 0x10) == 0) {
    this = *(basic_ostream<char,std::char_traits<char>_> **)
            (param_1 + (longlong)*(int *)(lVar5 + 4) + 0x50);
    if ((this == (basic_ostream<char,std::char_traits<char>_> *)0x0) || (this == param_1)) {
      bVar2 = true;
    }
    else {
      std::basic_ostream<char,std::char_traits<char>_>::flush(this);
      lVar5 = *(longlong *)param_1;
      bVar2 = *(int *)(param_1 + (longlong)*(int *)(lVar5 + 4) + 0x10) == 0;
    }
  }
  else {
    bVar2 = false;
  }
  if (bVar2) {
    if ((*(uint *)(param_1 + (longlong)*(int *)(lVar5 + 4) + 0x18) & 0x1c0) != 0x40) {
      for (; 0 < lVar7; lVar7 = lVar7 + -1) {
        iVar3 = std::basic_streambuf<char,std::char_traits<char>_>::sputc
                          (*(basic_streambuf<char,std::char_traits<char>_> **)
                            (param_1 + (longlong)*(int *)(*(longlong *)param_1 + 4) + 0x48),
                           (char)param_1[(longlong)*(int *)(*(longlong *)param_1 + 4) + 0x58]);
        if (iVar3 == -1) goto LAB_180006459;
      }
      lVar5 = *(longlong *)param_1;
    }
    _Var4 = std::basic_streambuf<char,std::char_traits<char>_>::sputn
                      (*(basic_streambuf<char,std::char_traits<char>_> **)
                        (param_1 + (longlong)*(int *)(lVar5 + 4) + 0x48),param_2,lVar8);
    if (_Var4 == lVar8) {
      for (; 0 < lVar7; lVar7 = lVar7 + -1) {
        iVar3 = std::basic_streambuf<char,std::char_traits<char>_>::sputc
                          (*(basic_streambuf<char,std::char_traits<char>_> **)
                            (param_1 + (longlong)*(int *)(*(longlong *)param_1 + 4) + 0x48),
                           (char)param_1[(longlong)*(int *)(*(longlong *)param_1 + 4) + 0x58]);
        if (iVar3 == -1) goto LAB_180006459;
      }
    }
    else {
LAB_180006459:
      iVar6 = 4;
    }
    *(undefined8 *)(param_1 + (longlong)*(int *)(*(longlong *)param_1 + 4) + 0x28) = 0;
  }
  else {
    iVar6 = 4;
  }
  std::basic_ios<char,std::char_traits<char>_>::setstate
            ((basic_ios<char,std::char_traits<char>_> *)
             (param_1 + *(int *)(*(longlong *)param_1 + 4)),iVar6,false);
  bVar2 = std::uncaught_exception();
  if (!bVar2) {
    std::basic_ostream<char,std::char_traits<char>_>::_Osfx(param_1);
  }
  if (*(longlong **)(param_1 + (longlong)*(int *)(*(longlong *)param_1 + 4) + 0x48) !=
      (longlong *)0x0) {
    (**(code **)(**(longlong **)(param_1 + (longlong)*(int *)(*(longlong *)param_1 + 4) + 0x48) +
                0x10))();
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 1800064e0 (25 bytes) name=FUN_1800064e0

void FUN_1800064e0(basic_ostream<char,std::char_traits<char>_> *param_1,char *param_2)

{
  char *pcVar1;
  
  pcVar1 = param_2;
  if (0xf < *(ulonglong *)(param_2 + 0x18)) {
    pcVar1 = *(char **)param_2;
  }
  FUN_180006920(param_1,pcVar1,*(ulonglong *)(param_2 + 0x10));
  return;
}


==================================================================

### EXPORT FUNC 180006500 (402 bytes) name=FUN_180006500

undefined8 *
FUN_180006500(undefined8 *param_1,undefined8 param_2,undefined8 param_3,undefined2 param_4)

{
  ulonglong uVar1;
  longlong lVar2;
  ulonglong uVar3;
  void *_Src;
  size_t _Size;
  longlong lVar4;
  ulonglong uVar5;
  ulonglong uVar6;
  void *_Memory;
  void *_Dst;
  
  lVar2 = param_1[2];
  if (lVar2 == 0x7ffffffffffffffe) {
                    /* WARNING: Subroutine does not return */
    FUN_180002b40();
  }
  uVar3 = param_1[3];
  uVar5 = lVar2 + 1U | 7;
  uVar6 = 0x7ffffffffffffffe;
  if (((uVar5 < 0x7fffffffffffffff) && (uVar3 <= 0x7ffffffffffffffe - (uVar3 >> 1))) &&
     (uVar1 = (uVar3 >> 1) + uVar3, uVar6 = uVar5, uVar5 < uVar1)) {
    uVar6 = uVar1;
  }
  uVar5 = uVar6 + 1;
  if (uVar6 == 0xffffffffffffffff) {
    uVar5 = 0xffffffffffffffff;
  }
  if (0x7fffffffffffffff < uVar5) {
LAB_18000668f:
                    /* WARNING: Subroutine does not return */
    FUN_180001750();
  }
  uVar5 = uVar5 * 2;
  _Dst = (void *)0x0;
  if (uVar5 < 0x1000) {
    if (uVar5 != 0) {
      _Dst = (void *)FUN_18000c554(uVar5);
    }
  }
  else {
    if (uVar5 + 0x27 <= uVar5) goto LAB_18000668f;
    lVar4 = FUN_18000c554(uVar5 + 0x27);
    if (lVar4 == 0) goto LAB_18000664a;
    _Dst = (void *)(lVar4 + 0x27U & 0xffffffffffffffe0);
    *(longlong *)((longlong)_Dst - 8) = lVar4;
  }
  _Size = lVar2 * 2;
  param_1[2] = lVar2 + 1U;
  param_1[3] = uVar6;
  if (uVar3 < 8) {
    memcpy(_Dst,param_1,_Size);
    *(undefined2 *)(_Size + (longlong)_Dst) = param_4;
    *(undefined2 *)(_Size + 2 + (longlong)_Dst) = 0;
  }
  else {
    _Src = (void *)*param_1;
    memcpy(_Dst,_Src,_Size);
    *(undefined2 *)(_Size + (longlong)_Dst) = param_4;
    *(undefined2 *)(_Size + 2 + (longlong)_Dst) = 0;
    _Memory = _Src;
    if ((0xfff < uVar3 * 2 + 2) &&
       (_Memory = *(void **)((longlong)_Src + -8),
       0x1f < (ulonglong)((longlong)_Src + (-8 - (longlong)_Memory)))) {
LAB_18000664a:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  *param_1 = _Dst;
  return param_1;
}


==================================================================

### EXPORT FUNC 1800066a0 (433 bytes) name=FUN_1800066a0

undefined8 *
FUN_1800066a0(undefined8 *param_1,ulonglong param_2,undefined8 param_3,void *param_4,
             longlong param_5)

{
  ulonglong uVar1;
  undefined2 *puVar2;
  longlong lVar3;
  ulonglong uVar4;
  void *_Src;
  size_t _Size;
  longlong lVar5;
  ulonglong uVar6;
  void *_Dst;
  ulonglong uVar7;
  void *_Memory;
  
  lVar3 = param_1[2];
  if (0x7ffffffffffffffeU - lVar3 < param_2) {
                    /* WARNING: Subroutine does not return */
    FUN_180002b40();
  }
  uVar4 = param_1[3];
  uVar6 = param_2 + lVar3 | 7;
  uVar7 = 0x7ffffffffffffffe;
  if (((uVar6 < 0x7fffffffffffffff) && (uVar4 <= 0x7ffffffffffffffe - (uVar4 >> 1))) &&
     (uVar1 = (uVar4 >> 1) + uVar4, uVar7 = uVar6, uVar6 < uVar1)) {
    uVar7 = uVar1;
  }
  uVar6 = uVar7 + 1;
  if (uVar7 == 0xffffffffffffffff) {
    uVar6 = 0xffffffffffffffff;
  }
  if (0x7fffffffffffffff < uVar6) {
LAB_18000684e:
                    /* WARNING: Subroutine does not return */
    FUN_180001750();
  }
  uVar6 = uVar6 * 2;
  _Dst = (void *)0x0;
  if (uVar6 < 0x1000) {
    if (uVar6 != 0) {
      _Dst = (void *)FUN_18000c554(uVar6);
    }
  }
  else {
    if (uVar6 + 0x27 <= uVar6) goto LAB_18000684e;
    lVar5 = FUN_18000c554(uVar6 + 0x27);
    if (lVar5 == 0) goto LAB_180006800;
    _Dst = (void *)(lVar5 + 0x27U & 0xffffffffffffffe0);
    *(longlong *)((longlong)_Dst - 8) = lVar5;
  }
  _Size = lVar3 * 2;
  param_1[2] = param_2 + lVar3;
  param_1[3] = uVar7;
  puVar2 = (undefined2 *)((longlong)_Dst + (param_5 + lVar3) * 2);
  if (uVar4 < 8) {
    memcpy(_Dst,param_1,_Size);
    memcpy((void *)(_Size + (longlong)_Dst),param_4,param_5 * 2);
    *puVar2 = 0;
  }
  else {
    _Src = (void *)*param_1;
    memcpy(_Dst,_Src,_Size);
    memcpy((void *)(_Size + (longlong)_Dst),param_4,param_5 * 2);
    *puVar2 = 0;
    _Memory = _Src;
    if ((0xfff < uVar4 * 2 + 2) &&
       (_Memory = *(void **)((longlong)_Src + -8),
       0x1f < (ulonglong)((longlong)_Src + (-8 - (longlong)_Memory)))) {
LAB_180006800:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  *param_1 = _Dst;
  return param_1;
}


==================================================================

### EXPORT FUNC 180006860 (179 bytes) name=FUN_180006860

void FUN_180006860(undefined8 *param_1,ulonglong param_2)

{
  ulonglong uVar1;
  ulonglong uVar2;
  void *_Src;
  void *_Memory;
  
  uVar1 = param_1[2];
  if (uVar1 <= param_2) {
    uVar2 = param_1[3];
    if (uVar2 != param_2) {
      if (uVar2 < param_2) {
        FUN_180006ae0(param_1,param_2 - uVar1);
        param_1[2] = uVar1;
        return;
      }
      if ((param_2 < 8) && (7 < uVar2)) {
        _Src = (void *)*param_1;
        memcpy(param_1,_Src,uVar1 * 2 + 2);
        _Memory = _Src;
        if ((0xfff < param_1[3] * 2 + 2U) &&
           (_Memory = *(void **)((longlong)_Src + -8),
           0x1f < (ulonglong)((longlong)_Src + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
          _invalid_parameter_noinfo_noreturn();
        }
        free(_Memory);
        param_1[3] = 7;
      }
    }
  }
  return;
}


==================================================================

### EXPORT FUNC 180006920 (433 bytes) name=FUN_180006920

basic_ostream<char,std::char_traits<char>_> *
FUN_180006920(basic_ostream<char,std::char_traits<char>_> *param_1,char *param_2,ulonglong param_3)

{
  longlong *plVar1;
  basic_ostream<char,std::char_traits<char>_> *this;
  bool bVar2;
  int iVar3;
  ulonglong uVar4;
  longlong lVar5;
  int iVar6;
  longlong lVar7;
  
  iVar6 = 0;
  lVar5 = *(longlong *)param_1;
  uVar4 = *(ulonglong *)(param_1 + (longlong)*(int *)(lVar5 + 4) + 0x28);
  if (((longlong)uVar4 < 1) || (uVar4 <= param_3)) {
    lVar7 = 0;
  }
  else {
    lVar7 = uVar4 - param_3;
  }
  plVar1 = *(longlong **)(param_1 + (longlong)*(int *)(lVar5 + 4) + 0x48);
  if (plVar1 != (longlong *)0x0) {
    (**(code **)(*plVar1 + 8))(plVar1);
    lVar5 = *(longlong *)param_1;
  }
  if (*(int *)(param_1 + (longlong)*(int *)(lVar5 + 4) + 0x10) == 0) {
    this = *(basic_ostream<char,std::char_traits<char>_> **)
            (param_1 + (longlong)*(int *)(lVar5 + 4) + 0x50);
    if ((this == (basic_ostream<char,std::char_traits<char>_> *)0x0) || (this == param_1)) {
      bVar2 = true;
    }
    else {
      std::basic_ostream<char,std::char_traits<char>_>::flush(this);
      lVar5 = *(longlong *)param_1;
      bVar2 = *(int *)(param_1 + (longlong)*(int *)(lVar5 + 4) + 0x10) == 0;
    }
  }
  else {
    bVar2 = false;
  }
  if (bVar2) {
    if ((*(uint *)(param_1 + (longlong)*(int *)(lVar5 + 4) + 0x18) & 0x1c0) != 0x40) {
      for (; lVar7 != 0; lVar7 = lVar7 + -1) {
        iVar3 = std::basic_streambuf<char,std::char_traits<char>_>::sputc
                          (*(basic_streambuf<char,std::char_traits<char>_> **)
                            (param_1 + (longlong)*(int *)(*(longlong *)param_1 + 4) + 0x48),
                           (char)param_1[(longlong)*(int *)(*(longlong *)param_1 + 4) + 0x58]);
        if (iVar3 == -1) {
          iVar6 = 4;
          goto LAB_180006a12;
        }
      }
      lVar5 = *(longlong *)param_1;
    }
    uVar4 = std::basic_streambuf<char,std::char_traits<char>_>::sputn
                      (*(basic_streambuf<char,std::char_traits<char>_> **)
                        (param_1 + (longlong)*(int *)(lVar5 + 4) + 0x48),param_2,param_3);
    if (uVar4 == param_3) {
LAB_180006a12:
      do {
        if (lVar7 == 0) goto LAB_180006a3a;
        iVar3 = std::basic_streambuf<char,std::char_traits<char>_>::sputc
                          (*(basic_streambuf<char,std::char_traits<char>_> **)
                            (param_1 + (longlong)*(int *)(*(longlong *)param_1 + 4) + 0x48),
                           (char)param_1[(longlong)*(int *)(*(longlong *)param_1 + 4) + 0x58]);
        if (iVar3 == -1) break;
        lVar7 = lVar7 + -1;
      } while( true );
    }
    iVar6 = 4;
LAB_180006a3a:
    *(undefined8 *)(param_1 + (longlong)*(int *)(*(longlong *)param_1 + 4) + 0x28) = 0;
  }
  else {
    iVar6 = 4;
  }
  std::basic_ios<char,std::char_traits<char>_>::setstate
            ((basic_ios<char,std::char_traits<char>_> *)
             (param_1 + *(int *)(*(longlong *)param_1 + 4)),iVar6,false);
  bVar2 = std::uncaught_exception();
  if (!bVar2) {
    std::basic_ostream<char,std::char_traits<char>_>::_Osfx(param_1);
  }
  if (*(longlong **)(param_1 + (longlong)*(int *)(*(longlong *)param_1 + 4) + 0x48) !=
      (longlong *)0x0) {
    (**(code **)(**(longlong **)(param_1 + (longlong)*(int *)(*(longlong *)param_1 + 4) + 0x48) +
                0x10))();
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 180006ae0 (354 bytes) name=FUN_180006ae0

undefined8 * FUN_180006ae0(undefined8 *param_1,ulonglong param_2)

{
  ulonglong uVar1;
  size_t _Size;
  longlong lVar2;
  ulonglong uVar3;
  void *_Src;
  longlong lVar4;
  ulonglong uVar5;
  ulonglong uVar6;
  void *_Memory;
  void *_Dst;
  
  lVar2 = param_1[2];
  if (0x7ffffffffffffffeU - lVar2 < param_2) {
                    /* WARNING: Subroutine does not return */
    FUN_180002b40();
  }
  uVar3 = param_1[3];
  uVar5 = param_2 + lVar2 | 7;
  uVar6 = 0x7ffffffffffffffe;
  if (((uVar5 < 0x7fffffffffffffff) && (uVar3 <= 0x7ffffffffffffffe - (uVar3 >> 1))) &&
     (uVar1 = (uVar3 >> 1) + uVar3, uVar6 = uVar5, uVar5 < uVar1)) {
    uVar6 = uVar1;
  }
  uVar5 = uVar6 + 1;
  if (uVar6 == 0xffffffffffffffff) {
    uVar5 = 0xffffffffffffffff;
  }
  if (0x7fffffffffffffff < uVar5) {
LAB_180006c3f:
                    /* WARNING: Subroutine does not return */
    FUN_180001750();
  }
  uVar5 = uVar5 * 2;
  if (uVar5 < 0x1000) {
    if (uVar5 == 0) {
      _Dst = (void *)0x0;
    }
    else {
      _Dst = (void *)FUN_18000c554(uVar5);
    }
  }
  else {
    if (uVar5 + 0x27 <= uVar5) goto LAB_180006c3f;
    lVar4 = FUN_18000c554(uVar5 + 0x27);
    if (lVar4 == 0) goto LAB_180006c0c;
    _Dst = (void *)(lVar4 + 0x27U & 0xffffffffffffffe0);
    *(longlong *)((longlong)_Dst - 8) = lVar4;
  }
  param_1[2] = param_2 + lVar2;
  _Size = lVar2 * 2 + 2;
  param_1[3] = uVar6;
  if (uVar3 < 8) {
    memcpy(_Dst,param_1,_Size);
  }
  else {
    _Src = (void *)*param_1;
    memcpy(_Dst,_Src,_Size);
    _Memory = _Src;
    if ((0xfff < uVar3 * 2 + 2) &&
       (_Memory = *(void **)((longlong)_Src + -8),
       0x1f < (ulonglong)((longlong)_Src + (-8 - (longlong)_Memory)))) {
LAB_180006c0c:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  *param_1 = _Dst;
  return param_1;
}


==================================================================

### EXPORT FUNC 180006c50 (324 bytes) name=FUN_180006c50

undefined8 * FUN_180006c50(undefined8 *param_1,ulonglong param_2)

{
  ulonglong uVar1;
  longlong lVar2;
  ulonglong uVar3;
  void *_Src;
  longlong lVar4;
  size_t sVar5;
  ulonglong uVar6;
  ulonglong uVar7;
  void *_Memory;
  void *_Dst;
  
  lVar2 = param_1[2];
  if (0x7fffffffffffffffU - lVar2 < param_2) {
                    /* WARNING: Subroutine does not return */
    FUN_180002b40();
  }
  uVar3 = param_1[3];
  uVar6 = param_2 + lVar2 | 0xf;
  uVar7 = 0x7fffffffffffffff;
  if (((uVar6 < 0x8000000000000000) && (uVar3 <= 0x7fffffffffffffff - (uVar3 >> 1))) &&
     (uVar1 = (uVar3 >> 1) + uVar3, uVar7 = uVar6, uVar6 < uVar1)) {
    uVar7 = uVar1;
  }
  sVar5 = uVar7 + 1;
  if (uVar7 == 0xffffffffffffffff) {
    sVar5 = 0xffffffffffffffff;
  }
  if (sVar5 < 0x1000) {
    if (sVar5 == 0) {
      _Dst = (void *)0x0;
    }
    else {
      _Dst = (void *)FUN_18000c554(sVar5);
    }
  }
  else {
    if (sVar5 + 0x27 <= sVar5) {
                    /* WARNING: Subroutine does not return */
      FUN_180001750();
    }
    lVar4 = FUN_18000c554(sVar5 + 0x27);
    if (lVar4 == 0) goto LAB_180006d5e;
    _Dst = (void *)(lVar4 + 0x27U & 0xffffffffffffffe0);
    *(longlong *)((longlong)_Dst - 8) = lVar4;
  }
  param_1[2] = param_2 + lVar2;
  param_1[3] = uVar7;
  if (uVar3 < 0x10) {
    memcpy(_Dst,param_1,lVar2 + 1U);
  }
  else {
    _Src = (void *)*param_1;
    memcpy(_Dst,_Src,lVar2 + 1U);
    _Memory = _Src;
    if ((0xfff < uVar3 + 1) &&
       (_Memory = *(void **)((longlong)_Src + -8),
       0x1f < (ulonglong)((longlong)_Src + (-8 - (longlong)_Memory)))) {
LAB_180006d5e:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  *param_1 = _Dst;
  return param_1;
}


==================================================================

### EXPORT FUNC 180006da0 (99 bytes) name=FUN_180006da0

void FUN_180006da0(undefined8 *param_1)

{
  longlong *plVar1;
  void *pvVar2;
  void *_Memory;
  
  plVar1 = (longlong *)*param_1;
  if (plVar1 != (longlong *)0x0) {
    if (0xf < (ulonglong)plVar1[3]) {
      pvVar2 = (void *)*plVar1;
      _Memory = pvVar2;
      if ((0xfff < plVar1[3] + 1U) &&
         (_Memory = *(void **)((longlong)pvVar2 + -8),
         0x1f < (ulonglong)((longlong)pvVar2 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(_Memory);
    }
    plVar1[2] = 0;
    plVar1[3] = 0xf;
    *(undefined1 *)plVar1 = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 180006e10 (102 bytes) name=FUN_180006e10

void FUN_180006e10(undefined8 *param_1)

{
  longlong *plVar1;
  void *pvVar2;
  void *_Memory;
  
  plVar1 = (longlong *)*param_1;
  if (plVar1 != (longlong *)0x0) {
    if (7 < (ulonglong)plVar1[3]) {
      pvVar2 = (void *)*plVar1;
      _Memory = pvVar2;
      if ((0xfff < plVar1[3] * 2 + 2U) &&
         (_Memory = *(void **)((longlong)pvVar2 + -8),
         0x1f < (ulonglong)((longlong)pvVar2 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(_Memory);
    }
    plVar1[3] = 7;
    plVar1[2] = 0;
    *(undefined2 *)plVar1 = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 180006e78 (12 bytes) name=FUN_180006e78

void FUN_180006e78(longlong param_1,uint param_2)

{
  FUN_180006200((basic_ios<char,std::char_traits<char>_> *)(param_1 - *(int *)(param_1 + -4)),
                param_2);
  return;
}


==================================================================

### EXPORT FUNC 180006e90 (95 bytes) name=FUN_180006e90

void FUN_180006e90(longlong *param_1)

{
  BOOL BVar1;
  longlong *plVar2;
  longlong local_98 [4];
  undefined8 local_78 [15];
  
  BVar1 = ReleaseMutex(*(HANDLE *)(*param_1 + 0x60));
  if (BVar1 != 0) {
    return;
  }
  plVar2 = FUN_180002510(local_98,
                         "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                        );
  FUN_180004310(local_78,plVar2,0x271,"Error releasing read mutex.");
                    /* WARNING: Subroutine does not return */
  _CxxThrowException(local_78,(ThrowInfo *)&DAT_1800134b8);
}


==================================================================

### EXPORT FUNC 180006f50 (419 bytes) name=FUN_180006f50

undefined8 * FUN_180006f50(undefined8 *param_1,char *param_2,undefined8 param_3,undefined8 *param_4)

{
  undefined8 *puVar1;
  char cVar2;
  longlong lVar3;
  ulonglong uVar4;
  ulonglong uVar5;
  undefined8 *puVar6;
  undefined8 *puVar7;
  HANDLE pvVar8;
  char *pcVar9;
  undefined8 uVar10;
  
  *param_1 = serial::Serial::vftable;
  uVar10 = param_3;
  puVar6 = (undefined8 *)FUN_18000c554(0x70);
  *puVar6 = 0;
  puVar6[1] = 0;
  puVar6[2] = 0;
  puVar6[3] = 0;
  puVar6[4] = 0;
  puVar6[5] = 0;
  puVar6[6] = 0;
  puVar6[7] = 0;
  puVar6[8] = 0;
  puVar6[9] = 0;
  puVar6[10] = 0;
  puVar6[0xb] = 0;
  puVar6[0xc] = 0;
  puVar6[0xd] = 0;
  *puVar6 = serial::Serial::SerialImpl::vftable;
  pcVar9 = param_2;
  if (0xf < *(ulonglong *)(param_2 + 0x18)) {
    pcVar9 = *(char **)param_2;
  }
  lVar3 = *(longlong *)(param_2 + 0x10);
  if (0xf < *(ulonglong *)(param_2 + 0x18)) {
    param_2 = *(char **)param_2;
  }
  puVar1 = puVar6 + 1;
  puVar6[3] = 0;
  puVar6[4] = 7;
  *(undefined2 *)puVar1 = 0;
  FUN_180006860(puVar1,(longlong)(pcVar9 + lVar3) - (longlong)param_2);
  for (; param_2 != pcVar9 + lVar3; param_2 = param_2 + 1) {
    cVar2 = *param_2;
    uVar4 = puVar6[3];
    uVar5 = puVar6[4];
    if (uVar4 < uVar5) {
      puVar6[3] = uVar4 + 1;
      puVar7 = puVar1;
      if (7 < uVar5) {
        puVar7 = (undefined8 *)*puVar1;
      }
      *(short *)((longlong)puVar7 + uVar4 * 2) = (short)cVar2;
      *(undefined2 *)((longlong)puVar7 + uVar4 * 2 + 2) = 0;
    }
    else {
      FUN_180006500(puVar1,uVar5,uVar10,(short)cVar2);
    }
  }
  puVar6[5] = 0xffffffffffffffff;
  *(undefined1 *)(puVar6 + 6) = 0;
  *(undefined8 *)((longlong)puVar6 + 0x34) = 0;
  *(undefined8 *)((longlong)puVar6 + 0x3c) = 0;
  *(undefined4 *)((longlong)puVar6 + 0x44) = 0;
  *(int *)(puVar6 + 9) = (int)param_3;
  *(undefined4 *)((longlong)puVar6 + 0x4c) = 0;
  *(undefined4 *)(puVar6 + 10) = 8;
  *(undefined8 *)((longlong)puVar6 + 0x54) = 1;
  if (puVar6[3] != 0) {
    FUN_180005040((longlong)puVar6);
  }
  pvVar8 = CreateMutexW((LPSECURITY_ATTRIBUTES)0x0,0,(LPCWSTR)0x0);
  puVar6[0xc] = pvVar8;
  pvVar8 = CreateMutexW((LPSECURITY_ATTRIBUTES)0x0,0,(LPCWSTR)0x0);
  puVar6[0xd] = pvVar8;
  param_1[1] = puVar6;
  uVar10 = param_4[1];
  *(undefined8 *)((longlong)puVar6 + 0x34) = *param_4;
  *(undefined8 *)((longlong)puVar6 + 0x3c) = uVar10;
  *(undefined4 *)((longlong)puVar6 + 0x44) = *(undefined4 *)(param_4 + 2);
  if (*(char *)(puVar6 + 6) != '\0') {
    FUN_1800053c0((longlong)puVar6);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 180007100 (77 bytes) name=FUN_180007100

undefined8 * FUN_180007100(undefined8 *param_1,uint param_2)

{
  undefined8 *puVar1;
  
  *param_1 = serial::Serial::vftable;
  puVar1 = (undefined8 *)param_1[1];
  if (puVar1 != (undefined8 *)0x0) {
    (**(code **)*puVar1)(puVar1,1);
  }
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 180007150 (298 bytes) name=FUN_180007150

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

DWORD FUN_180007150(longlong param_1,LPCVOID param_2,DWORD param_3)

{
  BOOL BVar1;
  DWORD DVar2;
  basic_ostream<char,std::char_traits<char>_> *this;
  longlong *plVar3;
  longlong *plVar4;
  char *pcVar5;
  undefined1 auStackY_248 [32];
  longlong local_210 [4];
  undefined8 local_1f0 [7];
  longlong local_1b8 [4];
  undefined8 local_198 [14];
  DWORD local_128 [4];
  basic_iostream<char,std::char_traits<char>_> local_118 [16];
  basic_ostream<char,std::char_traits<char>_> local_108 [240];
  ulonglong local_18;
  
  local_18 = DAT_180015010 ^ (ulonglong)auStackY_248;
  if (*(char *)(*(longlong *)(param_1 + 8) + 0x30) == '\0') {
    FUN_1800048a0(local_1f0,"Serial::write");
                    /* WARNING: Subroutine does not return */
    _CxxThrowException(local_1f0,(ThrowInfo *)&DAT_1800134d8);
  }
  BVar1 = WriteFile(*(HANDLE *)(*(longlong *)(param_1 + 8) + 0x28),param_2,param_3,local_128,
                    (LPOVERLAPPED)0x0);
  if (BVar1 != 0) {
    return local_128[0];
  }
  FUN_180004300(local_118);
  FUN_1800060f0(local_118);
  DVar2 = GetLastError();
  this = FUN_180006310(local_108,"Error while writing to the serial port: ");
  std::basic_ostream<char,std::char_traits<char>_>::operator<<(this,DVar2);
  plVar3 = FUN_180006050((longlong)local_118,local_1b8);
  plVar4 = FUN_180002510(local_210,
                         "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                        );
  pcVar5 = (char *)FUN_1800061b0(plVar3);
  FUN_180004310(local_198,plVar4,0x163,pcVar5);
                    /* WARNING: Subroutine does not return */
  _CxxThrowException(local_198,(ThrowInfo *)&DAT_1800134b8);
}


==================================================================

### EXPORT FUNC 180007280 (131 bytes) name=FUN_180007280

void FUN_180007280(longlong *param_1,longlong param_2,longlong param_3,longlong param_4)

{
  void *pvVar1;
  void *_Memory;
  
  pvVar1 = (void *)*param_1;
  if (pvVar1 != (void *)0x0) {
    _Memory = pvVar1;
    if ((0xfff < (ulonglong)(param_1[2] - (longlong)pvVar1)) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  *param_1 = param_2;
  param_1[1] = param_2 + param_3;
  param_1[2] = param_2 + param_4;
  return;
}


==================================================================

### EXPORT FUNC 180007310 (15 bytes) name=FUN_180007310

void FUN_180007310(undefined8 *param_1)

{
  (**(code **)*param_1)();
  return;
}


==================================================================

### EXPORT FUNC 180007320 (52 bytes) name=FUN_180007320

longlong * FUN_180007320(longlong *param_1,uint param_2)

{
  FUN_180007360(param_1);
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 180007360 (138 bytes) name=FUN_180007360

void FUN_180007360(longlong *param_1)

{
  undefined8 *puVar1;
  char cVar2;
  
  *param_1 = (longlong)SerialPort::vftable;
  if ((param_1[4] != 0) && ((char)param_1[3] == '\x01')) {
    cVar2 = (**(code **)(*param_1 + 0x28))();
    if (cVar2 != '\0') {
      *(undefined1 *)(param_1 + 3) = 0;
      FUN_180005790(*(longlong *)(param_1[4] + 8));
      puVar1 = (undefined8 *)param_1[4];
      if (puVar1 != (undefined8 *)0x0) {
        (**(code **)*puVar1)(puVar1,1);
      }
      param_1[4] = 0;
    }
  }
  puVar1 = (undefined8 *)param_1[4];
  if (puVar1 != (undefined8 *)0x0) {
    (**(code **)*puVar1)(puVar1,1);
  }
  param_1[4] = 0;
  if ((int)param_1[2] != 0) {
                    /* WARNING: Subroutine does not return */
    terminate();
  }
  return;
}


==================================================================

### EXPORT FUNC 1800073f0 (289 bytes) name=FUN_1800073f0

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

ulonglong FUN_1800073f0(longlong *param_1,char *param_2,ulonglong param_3)

{
  char cVar1;
  undefined8 *puVar2;
  ulonglong uVar3;
  ulonglong extraout_RAX;
  undefined1 auStackY_98 [32];
  uintptr_t local_58;
  ulonglong uStack_50;
  undefined4 local_48;
  longlong *local_38;
  undefined8 *local_30;
  ulonglong local_28;
  
  local_28 = DAT_180015010 ^ (ulonglong)auStackY_98;
  local_38 = param_1;
  cVar1 = (**(code **)(*param_1 + 0x28))();
  if (cVar1 != '\0') {
    (**(code **)(*param_1 + 0x20))(param_1);
  }
  local_30 = (undefined8 *)FUN_18000c554(0x10);
  *local_30 = 0;
  local_30[1] = 0;
  local_58 = 0;
  uStack_50 = 0;
  local_48 = 0;
  puVar2 = FUN_180006f50(local_30,param_2,param_3 & 0xffffffff,&local_58);
  param_1[4] = (longlong)puVar2;
  local_30 = (undefined8 *)FUN_18000c554(0x10);
  *local_30 = param_1;
  local_30[1] = FUN_180007310;
  local_58 = _beginthreadex((void *)0x0,0,FUN_180007930,local_30,0,(uint *)&uStack_50);
  if (local_58 == 0) {
    uStack_50 = uStack_50 & 0xffffffff00000000;
    std::_Throw_Cpp_error(6);
    uVar3 = extraout_RAX & 0xffffffffffffff00;
  }
  else {
    if ((int)param_1[2] != 0) {
                    /* WARNING: Subroutine does not return */
      terminate();
    }
    param_1[1] = local_58;
    param_1[2] = uStack_50;
    uVar3 = CONCAT71((int7)(local_58 >> 8),1);
  }
  return uVar3;
}


==================================================================

### EXPORT FUNC 180007520 (69 bytes) name=FUN_180007520

void FUN_180007520(longlong *param_1)

{
  undefined8 *puVar1;
  char cVar2;
  
  cVar2 = (**(code **)(*param_1 + 0x28))();
  if (cVar2 != '\0') {
    *(undefined1 *)(param_1 + 3) = 0;
    FUN_180005790(*(longlong *)(param_1[4] + 8));
    puVar1 = (undefined8 *)param_1[4];
    if (puVar1 != (undefined8 *)0x0) {
      (**(code **)*puVar1)(puVar1,1);
    }
    param_1[4] = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 180007570 (19 bytes) name=FUN_180007570

ulonglong FUN_180007570(longlong param_1)

{
  ulonglong in_RAX;
  
  if (*(longlong *)(param_1 + 0x20) != 0) {
    in_RAX = 0;
    if (*(char *)(param_1 + 0x18) == '\x01') {
      return 1;
    }
  }
  return in_RAX & 0xffffffffffffff00;
}


==================================================================

### EXPORT FUNC 180007590 (292 bytes) name=FUN_180007590

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

DWORD FUN_180007590(longlong *param_1,LPCVOID param_2,DWORD param_3)

{
  longlong lVar1;
  longlong lVar2;
  char cVar3;
  DWORD DVar4;
  BOOL BVar5;
  longlong *plVar6;
  undefined1 auStack_168 [32];
  longlong local_148 [4];
  longlong local_128 [4];
  undefined8 local_108 [14];
  undefined8 local_98 [14];
  longlong local_28;
  ulonglong local_20;
  
  local_20 = DAT_180015010 ^ (ulonglong)auStack_168;
  cVar3 = (**(code **)(*param_1 + 0x28))();
  if (cVar3 == '\0') {
    DVar4 = 0xffffffff;
  }
  else {
    lVar1 = param_1[4];
    lVar2 = *(longlong *)(lVar1 + 8);
    local_28 = lVar2;
    DVar4 = WaitForSingleObject(*(HANDLE *)(lVar2 + 0x68),0xffffffff);
    if (DVar4 != 0) {
      plVar6 = FUN_180002510(local_148,
                             "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                            );
      FUN_180004310(local_108,plVar6,0x279,"Error claiming write mutex.");
                    /* WARNING: Subroutine does not return */
      _CxxThrowException(local_108,(ThrowInfo *)&DAT_1800134b8);
    }
    DVar4 = FUN_180007150(lVar1,param_2,param_3);
    BVar5 = ReleaseMutex(*(HANDLE *)(lVar2 + 0x68));
    if (BVar5 == 0) {
      plVar6 = FUN_180002510(local_128,
                             "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                            );
      FUN_180004310(local_98,plVar6,0x281,"Error releasing write mutex.");
                    /* WARNING: Subroutine does not return */
      _CxxThrowException(local_98,(ThrowInfo *)&DAT_1800134b8);
    }
  }
  return DVar4;
}


==================================================================

### EXPORT FUNC 1800076c0 (579 bytes) name=FUN_1800076c0

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

void FUN_1800076c0(longlong param_1)

{
  char cVar1;
  longlong lVar2;
  longlong lVar3;
  undefined8 *puVar4;
  DWORD DVar5;
  DWORD DVar6;
  BOOL BVar7;
  basic_ostream<char,std::char_traits<char>_> *this;
  longlong *plVar8;
  char *pcVar9;
  longlong *plVar10;
  undefined1 auStack_738 [32];
  longlong local_718 [4];
  longlong local_6f8 [4];
  longlong local_6d8 [4];
  longlong local_6b8 [4];
  undefined8 local_698 [14];
  undefined8 local_628 [14];
  undefined8 local_5b8 [14];
  longlong local_548;
  _COMSTAT local_540 [2];
  basic_iostream<char,std::char_traits<char>_> local_528 [16];
  basic_ostream<char,std::char_traits<char>_> local_518 [240];
  undefined1 local_428 [1024];
  ulonglong local_28;
  
  local_28 = DAT_180015010 ^ (ulonglong)auStack_738;
  *(undefined1 *)(param_1 + 0x18) = 1;
  cVar1 = *(char *)(param_1 + 0x18);
  do {
    if (cVar1 == '\0') {
      return;
    }
    lVar2 = *(longlong *)(*(longlong *)(param_1 + 0x20) + 8);
    if (*(char *)(lVar2 + 0x30) == '\0') {
      DVar6 = 0;
    }
    else {
      BVar7 = ClearCommError(*(HANDLE *)(lVar2 + 0x28),(LPDWORD)0x0,local_540);
      DVar6 = local_540[0].cbInQue;
      if (BVar7 == 0) {
        FUN_180004300(local_528);
        FUN_1800060f0(local_528);
        DVar6 = GetLastError();
        this = FUN_180006310(local_518,"Error while checking status of the serial port: ");
        std::basic_ostream<char,std::char_traits<char>_>::operator<<(this,DVar6);
        plVar10 = FUN_180006050((longlong)local_528,local_6b8);
        plVar8 = FUN_180002510(local_6d8,
                               "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                              );
        pcVar9 = (char *)FUN_1800061b0(plVar10);
        FUN_180004310(local_5b8,plVar8,0x138,pcVar9);
                    /* WARNING: Subroutine does not return */
        _CxxThrowException(local_5b8,(ThrowInfo *)&DAT_1800134b8);
      }
    }
    if (0 < (int)DVar6) {
      memset(local_428,0,0x400);
      if (0x400 < (int)DVar6) {
        DVar6 = 0x400;
      }
      lVar2 = *(longlong *)(param_1 + 0x20);
      lVar3 = *(longlong *)(lVar2 + 8);
      local_548 = lVar3;
      DVar5 = WaitForSingleObject(*(HANDLE *)(lVar3 + 0x60),0xffffffff);
      if (DVar5 != 0) {
        plVar10 = FUN_180002510(local_6f8,
                                "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                               );
        FUN_180004310(local_628,plVar10,0x269,"Error claiming read mutex.");
                    /* WARNING: Subroutine does not return */
        _CxxThrowException(local_628,(ThrowInfo *)&DAT_1800134b8);
      }
      DVar6 = FUN_180005890(*(longlong *)(lVar2 + 8),local_428,DVar6);
      BVar7 = ReleaseMutex(*(HANDLE *)(lVar3 + 0x60));
      if (BVar7 == 0) {
        plVar10 = FUN_180002510(local_718,
                                "C:\\Users\\Derek\\source\\repos\\EloThermal-windows\\ThermalSDK\\serial\\impl\\win.cc"
                               );
        FUN_180004310(local_698,plVar10,0x271,"Error releasing read mutex.");
                    /* WARNING: Subroutine does not return */
        _CxxThrowException(local_698,(ThrowInfo *)&DAT_1800134b8);
      }
      puVar4 = *(undefined8 **)(param_1 + 0x28);
      if (puVar4 != (undefined8 *)0x0) {
        (**(code **)*puVar4)(puVar4,local_428,DVar6);
      }
    }
    cVar1 = *(char *)(param_1 + 0x18);
  } while( true );
}


==================================================================

### EXPORT FUNC 180007930 (45 bytes) name=FUN_180007930

undefined8 FUN_180007930(undefined8 *param_1)

{
  (*(code *)param_1[1])(*param_1);
  _Cnd_do_broadcast_at_thread_exit();
  free(param_1);
  return 0;
}


==================================================================

### EXPORT FUNC 180007960 (85 bytes) name=FUN_180007960

void FUN_180007960(undefined8 param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)

{
  undefined8 uVar1;
  undefined8 *puVar2;
  undefined8 local_res10;
  undefined8 local_res18;
  undefined8 local_res20;
  
  local_res10 = param_2;
  local_res18 = param_3;
  local_res20 = param_4;
  uVar1 = __acrt_iob_func(1);
  puVar2 = (undefined8 *)FUN_180002fc0();
  __stdio_common_vfprintf(*puVar2,uVar1,param_1,0,&local_res10);
  return;
}


==================================================================

### EXPORT FUNC 1800079c0 (119 bytes) name=FUN_1800079c0

undefined8 * FUN_1800079c0(undefined8 *param_1,ulonglong param_2)

{
  void *_Memory;
  
  *param_1 = TCMVirtualDevice::vftable;
  _Mtx_destroy_in_situ(param_1 + 0x10);
  _Cnd_destroy_in_situ(param_1 + 7);
  FUN_180002550((longlong)(param_1 + 1));
  _Memory = (void *)param_1[1];
  param_1[1] = 0;
  free(_Memory);
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 180007a40 (651 bytes) name=FUN_180007a40

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

ulonglong FUN_180007a40(longlong param_1,int param_2)

{
  longlong lVar1;
  byte bVar2;
  undefined8 *puVar3;
  code *pcVar4;
  bool bVar5;
  int iVar6;
  undefined8 *puVar7;
  ulonglong uVar8;
  longlong lVar9;
  void *_Memory;
  char *pcVar10;
  char cVar11;
  longlong *plVar12;
  void **ppvVar13;
  undefined1 auStack_88 [32];
  char local_68 [8];
  void *local_60;
  char *pcStack_58;
  char *local_50;
  undefined8 *local_48;
  undefined8 uStack_40;
  longlong local_38;
  int local_30;
  ulonglong local_28;
  
  local_28 = DAT_180015010 ^ (ulonglong)auStack_88;
  if (param_2 == 0) {
    uVar8 = CONCAT71((int7)(local_28 >> 8),1);
  }
  else {
    iVar6 = 0x80;
    if ((param_2 < 0x81) && (iVar6 = param_2, param_2 < -0x80)) {
      iVar6 = -0x80;
    }
    local_60 = (void *)0x0;
    pcStack_58 = (char *)0x0;
    local_50 = (char *)0x0;
    cVar11 = (char)iVar6;
    if (iVar6 < 0) {
      local_68[0] = '\x01';
      FUN_180007d30((longlong *)&local_60,(void *)0x0,local_68);
      local_68[0] = -cVar11;
      if (pcStack_58 == local_50) {
        pcVar10 = pcStack_58;
        FUN_180007d30((longlong *)&local_60,pcStack_58,local_68);
      }
      else {
        *pcStack_58 = local_68[0];
        pcVar10 = pcStack_58 + 1;
        pcStack_58 = pcVar10;
      }
    }
    else {
      local_68[0] = '\0';
      FUN_180007d30((longlong *)&local_60,(void *)0x0,local_68);
      local_68[0] = cVar11;
      if (pcStack_58 == local_50) {
        pcVar10 = pcStack_58;
        FUN_180007d30((longlong *)&local_60,pcStack_58,local_68);
      }
      else {
        *pcStack_58 = cVar11;
        pcVar10 = pcStack_58 + 1;
        pcStack_58 = pcVar10;
      }
    }
    *(undefined1 *)(param_1 + 0x30) = 0;
    puVar7 = (undefined8 *)FUN_18000c554(0x28);
    *puVar7 = 0;
    puVar7[1] = 0;
    puVar7[2] = 0;
    puVar7[3] = 0;
    puVar7[4] = 0;
    *puVar7 = FTDICommand::vftable;
    puVar7[1] = 0;
    puVar7[2] = 0;
    puVar7[3] = 0;
    ppvVar13 = &local_60;
    local_48 = puVar7;
    FUN_180009d70((longlong)puVar7,pcVar10,0x77,(longlong *)ppvVar13);
    puVar3 = *(undefined8 **)(param_1 + 0xd0);
    if (puVar3 != (undefined8 *)0x0) {
      ppvVar13 = (void **)*puVar3;
      (*ppvVar13[1])(puVar3,puVar7[1],puVar7[2] - puVar7[1]);
    }
    bVar5 = true;
    (**(code **)*puVar7)(puVar7,1);
    lVar1 = param_1 + 0x80;
    uStack_40 = 0;
    local_48 = (undefined8 *)lVar1;
    iVar6 = _Mtx_lock(lVar1);
    if (iVar6 != 0) {
      std::_Throw_C_error(iVar6);
      pcVar4 = (code *)swi(3);
      uVar8 = (*pcVar4)();
      return uVar8;
    }
    uStack_40 = CONCAT71(uStack_40._1_7_,1);
    lVar9 = _Xtime_get_ticks();
    lVar9 = (lVar9 + 1000000) * 100;
    local_38 = lVar9 / 1000000000;
    local_30 = (int)lVar9 + (int)local_38 * -1000000000;
    iVar6 = _Mtx_current_owns(lVar1);
    if (iVar6 == 0) {
      std::_Throw_Cpp_error(4);
      pcVar4 = (code *)swi(3);
      uVar8 = (*pcVar4)();
      return uVar8;
    }
    plVar12 = &local_38;
    lVar9 = lVar1;
    iVar6 = _Cnd_timedwait(param_1 + 0x38);
    if (iVar6 == 0) {
      bVar5 = false;
    }
    else if (iVar6 != 2) {
      std::_Throw_C_error(iVar6);
      pcVar4 = (code *)swi(3);
      uVar8 = (*pcVar4)();
      return uVar8;
    }
    if (DAT_180015ff0 != '\0') {
      if (bVar5) {
        FUN_180007960("EloMotorDevice timeout\n",lVar9,plVar12,ppvVar13);
      }
      else {
        FUN_180007960("EloMotorDevice:%d\n",(ulonglong)*(byte *)(param_1 + 0x30),plVar12,ppvVar13);
      }
    }
    bVar2 = *(byte *)(param_1 + 0x30);
    iVar6 = _Mtx_unlock(lVar1);
    if (iVar6 != 0) {
      std::_Throw_C_error(iVar6);
    }
    if (local_60 != (void *)0x0) {
      _Memory = local_60;
      if ((0xfff < (ulonglong)((longlong)local_50 - (longlong)local_60)) &&
         (_Memory = *(void **)((longlong)local_60 + -8),
         0x1f < (ulonglong)((longlong)local_60 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(_Memory);
    }
    uVar8 = (ulonglong)bVar2;
  }
  return uVar8;
}


==================================================================

### EXPORT FUNC 180007cd0 (17 bytes) name=FUN_180007cd0

undefined1 FUN_180007cd0(undefined8 param_1,char param_2,char param_3)

{
  if ((param_2 == '\x02') && (param_3 == 'w')) {
    return 1;
  }
  return 0;
}


==================================================================

### EXPORT FUNC 180007cf0 (57 bytes) name=FUN_180007cf0

void FUN_180007cf0(longlong param_1,longlong *param_2)

{
  longlong lVar1;
  int iVar2;
  
  lVar1 = *param_2;
  if ((*(char *)(lVar1 + 4) == '\x02') && (*(char *)(lVar1 + 5) == 'w')) {
    *(bool *)(param_1 + 0x30) = *(char *)(lVar1 + 8) == '\x01';
    iVar2 = _Cnd_broadcast(param_1 + 0x38);
    if (iVar2 != 0) {
      std::_Throw_C_error(iVar2);
    }
  }
  return;
}


==================================================================

### EXPORT FUNC 180007d30 (308 bytes) name=FUN_180007d30

undefined1 * FUN_180007d30(longlong *param_1,void *param_2,undefined1 *param_3)

{
  longlong lVar1;
  void *_Src;
  ulonglong uVar2;
  longlong lVar3;
  undefined1 *_Dst;
  ulonglong uVar4;
  ulonglong uVar5;
  undefined1 *_Dst_00;
  size_t _Size;
  undefined1 *puVar6;
  
  lVar1 = *param_1;
  if (param_1[1] - lVar1 == 0x7fffffffffffffff) {
                    /* WARNING: Subroutine does not return */
    FUN_180002b80();
  }
  uVar5 = (param_1[1] - lVar1) + 1;
  uVar2 = param_1[2] - lVar1;
  uVar4 = uVar5;
  if ((uVar2 <= 0x7fffffffffffffff - (uVar2 >> 1)) && (uVar4 = (uVar2 >> 1) + uVar2, uVar4 < uVar5))
  {
    uVar4 = uVar5;
  }
  if (uVar4 < 0x1000) {
    if (uVar4 == 0) {
      _Dst_00 = (undefined1 *)0x0;
    }
    else {
      _Dst_00 = (undefined1 *)FUN_18000c554(uVar4);
    }
  }
  else {
    if (uVar4 + 0x27 <= uVar4) {
                    /* WARNING: Subroutine does not return */
      FUN_180001750();
    }
    lVar3 = FUN_18000c554(uVar4 + 0x27);
    if (lVar3 == 0) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    _Dst_00 = (undefined1 *)(lVar3 + 0x27U & 0xffffffffffffffe0);
    *(longlong *)(_Dst_00 + -8) = lVar3;
  }
  puVar6 = _Dst_00 + ((longlong)param_2 - lVar1);
  *puVar6 = *param_3;
  _Src = (void *)*param_1;
  if (param_2 == (void *)param_1[1]) {
    _Size = param_1[1] - (longlong)_Src;
    _Dst = _Dst_00;
    param_2 = _Src;
  }
  else {
    memmove(_Dst_00,_Src,(longlong)param_2 - (longlong)_Src);
    _Dst = puVar6 + 1;
    _Size = param_1[1] - (longlong)param_2;
  }
  memmove(_Dst,param_2,_Size);
  FUN_180007280(param_1,(longlong)_Dst_00,uVar5,uVar4);
  return puVar6;
}


==================================================================

### EXPORT FUNC 180007e70 (119 bytes) name=FUN_180007e70

undefined8 * FUN_180007e70(undefined8 *param_1,ulonglong param_2)

{
  void *_Memory;
  
  *param_1 = TCMVirtualDevice::vftable;
  _Mtx_destroy_in_situ(param_1 + 0x10);
  _Cnd_destroy_in_situ(param_1 + 7);
  FUN_180002550((longlong)(param_1 + 1));
  _Memory = (void *)param_1[1];
  param_1[1] = 0;
  free(_Memory);
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 180007ef0 (17 bytes) name=FUN_180007ef0

undefined1 FUN_180007ef0(undefined8 param_1,char param_2,char param_3)

{
  if ((param_2 == '\x02') && (param_3 == 'x')) {
    return 1;
  }
  return 0;
}


==================================================================

### EXPORT FUNC 180007f10 (60 bytes) name=FUN_180007f10

void FUN_180007f10(longlong param_1,longlong *param_2)

{
  longlong lVar1;
  undefined8 *puVar2;
  ulonglong uVar3;
  
  lVar1 = *param_2;
  if ((*(char *)(lVar1 + 4) == '\x02') && (*(char *)(lVar1 + 5) == 'x')) {
    if (*(char *)(lVar1 + 8) == '\0') {
      uVar3 = 0xffffffff;
    }
    else {
      uVar3 = (ulonglong)CONCAT11(*(undefined1 *)(lVar1 + 9),*(undefined1 *)(lVar1 + 10));
    }
    puVar2 = *(undefined8 **)(param_1 + 0xd8);
    if (puVar2 != (undefined8 *)0x0) {
                    /* WARNING: Could not recover jumptable at 0x000180007f48. Too many branches */
                    /* WARNING: Treating indirect jump as call */
      (**(code **)*puVar2)(puVar2,uVar3);
      return;
    }
  }
  return;
}


==================================================================

### EXPORT FUNC 180007f50 (17 bytes) name=FUN_180007f50

undefined1 FUN_180007f50(undefined8 param_1,char param_2,char param_3)

{
  if ((param_2 == '\x02') && (param_3 == 'P')) {
    return 1;
  }
  return 0;
}


==================================================================

### EXPORT FUNC 180007f70 (57 bytes) name=FUN_180007f70

void FUN_180007f70(longlong param_1,longlong *param_2)

{
  longlong lVar1;
  int iVar2;
  
  lVar1 = *param_2;
  if ((*(char *)(lVar1 + 4) == '\x02') && (*(char *)(lVar1 + 5) == 'P')) {
    *(bool *)(param_1 + 0x30) = *(char *)(lVar1 + 8) == '\x01';
    iVar2 = _Cnd_broadcast(param_1 + 0x38);
    if (iVar2 != 0) {
      std::_Throw_C_error(iVar2);
    }
  }
  return;
}


==================================================================

### EXPORT FUNC 180007fb0 (17 bytes) name=FUN_180007fb0

undefined1 FUN_180007fb0(undefined8 param_1,char param_2,char param_3)

{
  if ((param_2 == '\x02') && (param_3 == '1')) {
    return 1;
  }
  return 0;
}


==================================================================

### EXPORT FUNC 180007fd0 (57 bytes) name=FUN_180007fd0

void FUN_180007fd0(longlong param_1,longlong *param_2)

{
  longlong lVar1;
  int iVar2;
  
  lVar1 = *param_2;
  if ((*(char *)(lVar1 + 4) == '\x02') && (*(char *)(lVar1 + 5) == '1')) {
    *(bool *)(param_1 + 0x30) = *(char *)(lVar1 + 8) == '\x01';
    iVar2 = _Cnd_broadcast(param_1 + 0x38);
    if (iVar2 != 0) {
      std::_Throw_C_error(iVar2);
    }
  }
  return;
}


==================================================================

### EXPORT FUNC 180008010 (17 bytes) name=FUN_180008010

undefined1 FUN_180008010(undefined8 param_1,char param_2,char param_3)

{
  if ((param_2 == '\x02') && (param_3 == 'A')) {
    return 1;
  }
  return 0;
}


==================================================================

### EXPORT FUNC 180008030 (57 bytes) name=FUN_180008030

void FUN_180008030(longlong param_1,longlong *param_2)

{
  longlong lVar1;
  int iVar2;
  
  lVar1 = *param_2;
  if ((*(char *)(lVar1 + 4) == '\x02') && (*(char *)(lVar1 + 5) == 'A')) {
    *(bool *)(param_1 + 0x30) = *(char *)(lVar1 + 8) == '\x01';
    iVar2 = _Cnd_broadcast(param_1 + 0x38);
    if (iVar2 != 0) {
      std::_Throw_C_error(iVar2);
    }
  }
  return;
}


==================================================================

### EXPORT FUNC 180008070 (52 bytes) name=FUN_180008070

undefined8 * FUN_180008070(undefined8 *param_1,uint param_2)

{
  FUN_1800080b0(param_1);
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 1800080b0 (470 bytes) name=FUN_1800080b0

void FUN_1800080b0(undefined8 *param_1)

{
  undefined8 *_Memory;
  void *pvVar1;
  void *pvVar2;
  
  _Memory = (undefined8 *)param_1[0x1e];
  *param_1 = EloTCMScannerDevice::vftable;
  param_1[0x1b] = EloTCMScannerDevice::vftable;
  if (_Memory != (undefined8 *)0x0) {
    *_Memory = HoneywellUpdaterDevice::vftable;
    _Mtx_destroy_in_situ(_Memory + 0x14);
    _Cnd_destroy_in_situ(_Memory + 0xb);
    FUN_180002550((longlong)(_Memory + 4));
    pvVar1 = (void *)_Memory[4];
    _Memory[4] = 0;
    free(pvVar1);
    pvVar1 = (void *)_Memory[1];
    if (pvVar1 != (void *)0x0) {
      pvVar2 = pvVar1;
      if ((0xfff < (ulonglong)(_Memory[3] - (longlong)pvVar1)) &&
         (pvVar2 = *(void **)((longlong)pvVar1 + -8),
         0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)pvVar2)))) goto LAB_180008280;
      free(pvVar2);
      _Memory[1] = 0;
      _Memory[2] = 0;
      _Memory[3] = 0;
    }
    free(_Memory);
    param_1[0x1e] = 0;
  }
  pvVar1 = (void *)param_1[0x23];
  if (pvVar1 != (void *)0x0) {
    pvVar2 = pvVar1;
    if ((0xfff < (ulonglong)(param_1[0x25] - (longlong)pvVar1)) &&
       (pvVar2 = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)pvVar2)))) goto LAB_180008280;
    free(pvVar2);
    param_1[0x23] = 0;
    param_1[0x24] = 0;
    param_1[0x25] = 0;
  }
  if (0xf < (ulonglong)param_1[0x22]) {
    pvVar1 = (void *)param_1[0x1f];
    pvVar2 = pvVar1;
    if ((0xfff < param_1[0x22] + 1) &&
       (pvVar2 = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)pvVar2)))) {
LAB_180008280:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(pvVar2);
  }
  param_1[0x21] = 0;
  param_1[0x22] = 0xf;
  *(undefined1 *)(param_1 + 0x1f) = 0;
  *param_1 = TCMVirtualDevice::vftable;
  _Mtx_destroy_in_situ(param_1 + 0x10);
  _Cnd_destroy_in_situ(param_1 + 7);
  FUN_180002550((longlong)(param_1 + 1));
  pvVar1 = (void *)param_1[1];
  param_1[1] = 0;
  free(pvVar1);
  return;
}


==================================================================

### EXPORT FUNC 180008290 (50 bytes) name=FUN_180008290

ulonglong FUN_180008290(undefined8 param_1,char param_2,byte param_3)

{
  uint uVar1;
  ulonglong in_RAX;
  undefined7 in_register_00000081;
  
  if (param_2 == -0x7f) {
    if (param_3 == 3) {
LAB_1800082bf:
      return CONCAT71((int7)(in_RAX >> 8),1);
    }
  }
  else if (param_2 == '\x02') {
    uVar1 = (int)CONCAT71(in_register_00000081,param_3) - 0x60;
    in_RAX = (ulonglong)uVar1;
    if ((((byte)uVar1 < 0x10) && ((0xa3ffU >> (uVar1 & 0x1f) & 1) != 0)) ||
       ((byte)(param_3 - 8) < 4)) goto LAB_1800082bf;
  }
  return in_RAX & 0xffffffffffffff00;
}


==================================================================

### EXPORT FUNC 1800082d0 (1870 bytes) name=FUN_1800082d0

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

void FUN_1800082d0(longlong param_1,longlong *param_2)

{
  undefined1 *puVar1;
  undefined2 *puVar2;
  char cVar3;
  char cVar4;
  undefined1 uVar5;
  void *_Src;
  ulonglong uVar6;
  undefined *******pppppppuVar7;
  undefined8 *puVar8;
  undefined8 *puVar9;
  int iVar10;
  undefined8 uVar11;
  undefined8 **ppuVar12;
  longlong lVar13;
  longlong lVar14;
  ulonglong uVar15;
  undefined ********ppppppppuVar16;
  ulonglong uVar17;
  undefined1 *puVar18;
  size_t sVar19;
  longlong lVar20;
  undefined1 auStack_a8 [32];
  undefined1 local_88 [8];
  undefined8 *local_80;
  undefined *******local_78;
  undefined *******pppppppuStack_70;
  undefined *******local_68;
  undefined *******local_60;
  undefined *******pppppppuStack_58;
  undefined1 *local_50;
  undefined1 *puStack_48;
  ulonglong local_40;
  ulonglong local_38;
  
  local_38 = DAT_180015010 ^ (ulonglong)auStack_a8;
  lVar20 = *param_2;
  cVar3 = *(char *)(lVar20 + 4);
  cVar4 = *(char *)(lVar20 + 5);
  lVar14 = 0;
  if (cVar3 == -0x7f) {
    if (cVar4 != '\x03') {
      return;
    }
LAB_180008341:
    local_50 = (undefined1 *)0x0;
    puStack_48 = (undefined1 *)0xf;
    local_60 = (undefined *******)((ulonglong)local_60 & 0xffffffffffffff00);
    lVar13 = 8;
    lVar20 = (longlong)(((int)param_2[1] - (int)lVar20) + -1);
    if (8 < lVar20) {
      do {
        puVar18 = local_50;
        if (local_50 < puStack_48) {
          ppppppppuVar16 = &local_60;
          if ((undefined1 *)0xf < puStack_48) {
            ppppppppuVar16 = (undefined ********)local_60;
          }
          puVar1 = (undefined1 *)((longlong)ppppppppuVar16 + (longlong)local_50);
          local_50 = local_50 + 1;
          *puVar1 = *(undefined1 *)(lVar13 + *param_2);
          ((undefined1 *)((longlong)ppppppppuVar16 + 1))[(longlong)puVar18] = 0;
        }
        else {
          FUN_180002770(&local_60,local_50,puStack_48,*(undefined1 *)(lVar13 + *param_2));
        }
        lVar13 = lVar13 + 1;
      } while (lVar13 < lVar20);
    }
    if (local_50 < puStack_48) {
      ppppppppuVar16 = &local_60;
      if ((undefined1 *)0xf < puStack_48) {
        ppppppppuVar16 = (undefined ********)local_60;
      }
      puVar2 = (undefined2 *)((longlong)ppppppppuVar16 + (longlong)local_50);
      local_50 = local_50 + 1;
      *puVar2 = 0;
    }
    else {
      FUN_180002770(&local_60,local_50,puStack_48,0);
    }
    if (*(code **)(param_1 + 0xe0) != (code *)0x0) {
      ppppppppuVar16 = &local_60;
      if ((undefined1 *)0xf < puStack_48) {
        ppppppppuVar16 = (undefined ********)local_60;
      }
      (**(code **)(param_1 + 0xe0))(ppppppppuVar16);
    }
    if ((cVar3 == '\x02') && (cVar4 == '`')) {
      local_78 = (undefined *******)0x0;
      pppppppuStack_70 = (undefined *******)0x0;
      local_68 = (undefined *******)0x0;
      local_88[0] = 1;
      uVar11 = 0;
      FUN_180007d30((longlong *)&local_78,(void *)0x0,local_88);
      puVar8 = (undefined8 *)FUN_18000c554(0x28);
      *puVar8 = 0;
      puVar8[1] = 0;
      puVar8[2] = 0;
      puVar8[3] = 0;
      puVar8[4] = 0;
      *puVar8 = FTDICommand::vftable;
      puVar8[1] = 0;
      puVar8[2] = 0;
      puVar8[3] = 0;
      local_80 = puVar8;
      FUN_180009d70((longlong)puVar8,uVar11,0x60,(longlong *)&local_78);
      if (*(longlong **)(param_1 + 0xd0) != (longlong *)0x0) {
        (**(code **)(**(longlong **)(param_1 + 0xd0) + 8))();
      }
      (**(code **)*puVar8)(puVar8,1);
      if ((undefined ********)local_78 != (undefined ********)0x0) {
        ppppppppuVar16 = (undefined ********)local_78;
        if ((0xfff < (ulonglong)((longlong)local_68 - (longlong)local_78)) &&
           (ppppppppuVar16 = (undefined ********)local_78[-1],
           (undefined1 *)0x1f < (undefined1 *)((longlong)local_78 + (-8 - (longlong)ppppppppuVar16))
           )) {
                    /* WARNING: Subroutine does not return */
          _invalid_parameter_noinfo_noreturn();
        }
        free(ppppppppuVar16);
      }
    }
    if ((undefined1 *)0xf < puStack_48) {
      ppppppppuVar16 = (undefined ********)local_60;
      if (((undefined1 *)0xfff < puStack_48 + 1) &&
         (ppppppppuVar16 = (undefined ********)local_60[-1],
         (undefined1 *)0x1f < (undefined1 *)((longlong)local_60 + (-8 - (longlong)ppppppppuVar16))))
      {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(ppppppppuVar16);
    }
    if (cVar3 != '\x02') {
      return;
    }
  }
  else {
    if (cVar3 != '\x02') {
      return;
    }
    if (cVar4 == '`') goto LAB_180008341;
  }
  if ((byte)(cVar4 + 0x9fU) < 9) {
    *(bool *)(param_1 + 0x30) = *(char *)(*param_2 + 8) == '\x01';
    iVar10 = _Cnd_broadcast(param_1 + 0x38);
    if (iVar10 == 0) {
      return;
    }
    std::_Throw_C_error(iVar10);
    return;
  }
  if (cVar4 == '\b') {
    local_60 = (undefined *******)FTDICommand::vftable;
    pppppppuStack_58 = (undefined *******)0x0;
    local_50 = (undefined1 *)0x0;
    puStack_48 = (undefined1 *)0x0;
    _Src = (void *)*param_2;
    iVar10 = ((int)param_2[1] - (int)_Src) + -9;
    if (iVar10 < 0) {
      iVar10 = 0;
    }
    local_40 = (ulonglong)CONCAT24(*(undefined2 *)((longlong)_Src + 4),iVar10);
    uVar15 = param_2[1] - (longlong)_Src;
    if (uVar15 != 0) {
      FUN_180002ba0((ulonglong *)&pppppppuStack_58,uVar15);
    }
    pppppppuVar7 = pppppppuStack_58;
    uVar17 = uVar15;
    memmove(pppppppuStack_58,_Src,uVar15);
    local_50 = (undefined1 *)((longlong)pppppppuVar7 + uVar15);
    local_78 = (undefined *******)0x0;
    pppppppuStack_70 = (undefined *******)0x0;
    local_68 = (undefined *******)0x0;
    FUN_18000a360((longlong)&local_60,(longlong *)&local_78);
    pppppppuVar7 = pppppppuStack_70;
    puVar8 = (undefined8 *)(param_1 + 0xf8);
    *(undefined8 *)(param_1 + 0x108) = 0;
    puVar9 = puVar8;
    if (0xf < *(ulonglong *)(param_1 + 0x110)) {
      puVar9 = (undefined8 *)*puVar8;
    }
    *(undefined1 *)puVar9 = 0;
    for (ppppppppuVar16 = (undefined ********)local_78;
        ppppppppuVar16 != (undefined ********)pppppppuVar7;
        ppppppppuVar16 = (undefined ********)((longlong)ppppppppuVar16 + 1)) {
      uVar5 = *(undefined1 *)ppppppppuVar16;
      uVar15 = *(ulonglong *)(param_1 + 0x108);
      uVar6 = *(ulonglong *)(param_1 + 0x110);
      if (uVar15 < uVar6) {
        *(ulonglong *)(param_1 + 0x108) = uVar15 + 1;
        puVar9 = puVar8;
        if (0xf < uVar6) {
          puVar9 = (undefined8 *)*puVar8;
        }
        *(undefined1 *)((longlong)puVar9 + uVar15) = uVar5;
        *(undefined1 *)((longlong)puVar9 + uVar15 + 1) = 0;
      }
      else {
        FUN_180002770(puVar8,uVar6,uVar17,uVar5);
      }
    }
    iVar10 = _Cnd_broadcast(param_1 + 0x38);
    if (iVar10 != 0) {
      std::_Throw_C_error(iVar10);
    }
    if ((undefined ********)local_78 != (undefined ********)0x0) {
      ppppppppuVar16 = (undefined ********)local_78;
      if ((0xfff < (ulonglong)((longlong)local_68 - (longlong)local_78)) &&
         (ppppppppuVar16 = (undefined ********)local_78[-1],
         (undefined1 *)0x1f < (undefined1 *)((longlong)local_78 + (-8 - (longlong)ppppppppuVar16))))
      {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(ppppppppuVar16);
      local_78 = (undefined *******)0x0;
      pppppppuStack_70 = (undefined *******)0x0;
      local_68 = (undefined *******)0x0;
    }
    if ((undefined ********)pppppppuStack_58 == (undefined ********)0x0) {
      return;
    }
    ppppppppuVar16 = (undefined ********)pppppppuStack_58;
    if ((0xfff < (ulonglong)((longlong)puStack_48 - (longlong)pppppppuStack_58)) &&
       (ppppppppuVar16 = (undefined ********)pppppppuStack_58[-1],
       (undefined1 *)0x1f <
       (undefined1 *)((longlong)pppppppuStack_58 + (-8 - (longlong)ppppppppuVar16)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    goto LAB_1800087fa;
  }
  if (cVar4 == '\t') {
    *(bool *)(param_1 + 0x30) = *(char *)(*param_2 + 8) == '\x01';
    iVar10 = _Cnd_broadcast(param_1 + 0x38);
    if (iVar10 == 0) {
      return;
    }
    std::_Throw_C_error(iVar10);
  }
  if (cVar4 == '\n') {
    *(bool *)(param_1 + 0x30) = *(char *)(*param_2 + 8) == '\x01';
    iVar10 = _Cnd_broadcast(param_1 + 0x38);
    if (iVar10 == 0) {
      return;
    }
    std::_Throw_C_error(iVar10);
  }
  if (cVar4 == '\v') {
    iVar10 = ((int)param_2[1] - (int)*param_2) + -9;
    local_78 = (undefined *******)0x0;
    pppppppuStack_70 = (undefined *******)0x0;
    local_68 = (undefined *******)0x0;
    if (0 < iVar10) {
      do {
        puVar18 = (undefined1 *)(*param_2 + 8 + lVar14);
        if (pppppppuStack_70 == local_68) {
          FUN_180007d30((longlong *)&local_78,pppppppuStack_70,puVar18);
        }
        else {
          *(undefined1 *)pppppppuStack_70 = *puVar18;
          pppppppuStack_70 = (undefined *******)((longlong)pppppppuStack_70 + 1);
        }
        lVar14 = lVar14 + 1;
      } while (lVar14 < iVar10);
    }
    (**(code **)**(undefined8 **)(param_1 + 0xf0))(*(undefined8 **)(param_1 + 0xf0),&local_78);
    if ((undefined ********)local_78 == (undefined ********)0x0) {
      return;
    }
    ppppppppuVar16 = (undefined ********)local_78;
    if ((0xfff < (ulonglong)((longlong)local_68 - (longlong)local_78)) &&
       (ppppppppuVar16 = (undefined ********)local_78[-1],
       (undefined1 *)0x1f < (undefined1 *)((longlong)local_78 + (-8 - (longlong)ppppppppuVar16)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    goto LAB_1800087fa;
  }
  if (cVar4 != 'o') {
    return;
  }
  uVar5 = *(undefined1 *)(*param_2 + 8);
  local_50 = (undefined1 *)0x0;
  puStack_48 = (undefined1 *)0xf;
  local_60 = (undefined *******)((ulonglong)local_60 & 0xffffffffffffff00);
  FUN_180002610((longlong *)&local_60,&PTR_18000fde8,0);
  switch(uVar5) {
  case 0x61:
    ppuVar12 = &DAT_180015180;
    sVar19 = DAT_180015190;
    if (0xf < DAT_180015198) {
      ppuVar12 = (undefined8 **)DAT_180015180;
    }
    break;
  case 0x62:
    ppuVar12 = &DAT_1800150e0;
    sVar19 = DAT_1800150f0;
    if (0xf < DAT_1800150f8) {
      ppuVar12 = (undefined8 **)DAT_1800150e0;
    }
    break;
  case 99:
    ppuVar12 = &DAT_180015160;
    sVar19 = DAT_180015170;
    if (0xf < DAT_180015178) {
      ppuVar12 = (undefined8 **)DAT_180015160;
    }
    break;
  case 100:
    ppuVar12 = &DAT_1800151c0;
    sVar19 = DAT_1800151d0;
    if (0xf < DAT_1800151d8) {
      ppuVar12 = (undefined8 **)DAT_1800151c0;
    }
    break;
  case 0x65:
    ppuVar12 = &DAT_180015120;
    sVar19 = DAT_180015130;
    if (0xf < DAT_180015138) {
      ppuVar12 = (undefined8 **)DAT_180015120;
    }
    break;
  case 0x66:
    ppuVar12 = &DAT_1800150c0;
    sVar19 = DAT_1800150d0;
    if (0xf < DAT_1800150d8) {
      ppuVar12 = (undefined8 **)DAT_1800150c0;
    }
    break;
  case 0x67:
    ppuVar12 = &DAT_180015140;
    sVar19 = DAT_180015150;
    if (0xf < DAT_180015158) {
      ppuVar12 = (undefined8 **)DAT_180015140;
    }
    break;
  case 0x68:
    ppuVar12 = &DAT_180015080;
    sVar19 = DAT_180015090;
    if (0xf < DAT_180015098) {
      ppuVar12 = (undefined8 **)DAT_180015080;
    }
    break;
  case 0x69:
    ppuVar12 = &DAT_1800151a0;
    sVar19 = DAT_1800151b0;
    if (0xf < DAT_1800151b8) {
      ppuVar12 = (undefined8 **)DAT_1800151a0;
    }
    break;
  default:
    goto switchD_180008858_default;
  }
  FUN_180002610((longlong *)&local_60,ppuVar12,sVar19);
switchD_180008858_default:
  if (puStack_48 < (undefined1 *)0x10) {
    return;
  }
  ppppppppuVar16 = (undefined ********)local_60;
  if (((undefined1 *)0xfff < puStack_48 + 1) &&
     (ppppppppuVar16 = (undefined ********)local_60[-1],
     (undefined1 *)0x1f < (undefined1 *)((longlong)local_60 + (-8 - (longlong)ppppppppuVar16)))) {
                    /* WARNING: Subroutine does not return */
    _invalid_parameter_noinfo_noreturn();
  }
LAB_1800087fa:
  free(ppppppppuVar16);
  return;
}


==================================================================

### EXPORT FUNC 180008a50 (395 bytes) name=FUN_180008a50

void FUN_180008a50(longlong param_1,undefined8 *param_2,ulonglong param_3,undefined8 param_4)

{
  longlong *plVar1;
  longlong lVar2;
  void *pvVar3;
  undefined8 *puVar4;
  void *local_48;
  void *pvStack_40;
  longlong local_38;
  void **local_30;
  undefined8 *local_28;
  
  local_48 = (void *)0x0;
  pvStack_40 = (void *)0x0;
  pvVar3 = (void *)0x0;
  local_38 = 0;
  puVar4 = (undefined8 *)*param_2;
  if (puVar4 != (undefined8 *)param_2[1]) {
    param_3 = (longlong)param_2[1] - (longlong)puVar4;
    if (param_3 < 0x1000) {
      if (param_3 != 0) {
        pvVar3 = (void *)FUN_18000c554(param_3);
      }
    }
    else {
      if (param_3 + 0x27 <= param_3) {
                    /* WARNING: Subroutine does not return */
        FUN_180001750();
      }
      lVar2 = FUN_18000c554(param_3 + 0x27);
      if (lVar2 == 0) goto LAB_180008bb6;
      pvVar3 = (void *)(lVar2 + 0x27U & 0xffffffffffffffe0);
      *(longlong *)((longlong)pvVar3 - 8) = lVar2;
    }
    lVar2 = (longlong)pvVar3 + param_3;
    local_48 = pvVar3;
    pvStack_40 = pvVar3;
    local_38 = lVar2;
    memmove(pvVar3,puVar4,param_3);
    param_2 = puVar4;
    pvStack_40 = (void *)lVar2;
  }
  local_30 = &local_48;
  if (DAT_180015ff0 != '\0') {
    FUN_180007960("transmitData\n",param_2,param_3,param_4);
  }
  puVar4 = (undefined8 *)FUN_18000c554(0x28);
  *puVar4 = 0;
  puVar4[1] = 0;
  puVar4[2] = 0;
  puVar4[3] = 0;
  puVar4[4] = 0;
  *puVar4 = FTDICommand::vftable;
  puVar4[1] = 0;
  puVar4[2] = 0;
  puVar4[3] = 0;
  local_28 = puVar4;
  FUN_180009d70((longlong)puVar4,param_2,0xb,(longlong *)&local_48);
  plVar1 = *(longlong **)(param_1 + -8);
  if (plVar1 != (longlong *)0x0) {
    (**(code **)(*plVar1 + 8))(plVar1,puVar4[1],puVar4[2] - puVar4[1]);
  }
  (**(code **)*puVar4)(puVar4,1);
  if (local_48 != (void *)0x0) {
    pvVar3 = local_48;
    if ((0xfff < (ulonglong)(local_38 - (longlong)local_48)) &&
       (pvVar3 = *(void **)((longlong)local_48 + -8),
       0x1f < (ulonglong)((longlong)local_48 + (-8 - (longlong)pvVar3)))) {
LAB_180008bb6:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(pvVar3);
  }
  return;
}


==================================================================

### EXPORT FUNC 180008be0 (231 bytes) name=FUN_180008be0

undefined8 * FUN_180008be0(undefined8 *param_1,uint param_2)

{
  void *pvVar1;
  void *_Memory;
  
  *param_1 = EloTCMScheduleTaskDevice::vftable;
  pvVar1 = (void *)param_1[0x1c];
  if (pvVar1 != (void *)0x0) {
    _Memory = pvVar1;
    if ((0xfff < (ulonglong)(param_1[0x1e] - (longlong)pvVar1)) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
    param_1[0x1c] = 0;
    param_1[0x1d] = 0;
    param_1[0x1e] = 0;
  }
  *param_1 = TCMVirtualDevice::vftable;
  _Mtx_destroy_in_situ(param_1 + 0x10);
  _Cnd_destroy_in_situ(param_1 + 7);
  FUN_180002550((longlong)(param_1 + 1));
  pvVar1 = (void *)param_1[1];
  param_1[1] = 0;
  free(pvVar1);
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 180008cd0 (21 bytes) name=FUN_180008cd0

undefined1 FUN_180008cd0(undefined8 param_1,char param_2,char param_3)

{
  if ((param_2 == '\x02') && ((byte)(param_3 - 0x21U) < 6)) {
    return 1;
  }
  return 0;
}


==================================================================

### EXPORT FUNC 180008cf0 (430 bytes) name=FUN_180008cf0

void FUN_180008cf0(ulonglong param_1,longlong *param_2)

{
  undefined1 *puVar1;
  char extraout_AL;
  char extraout_AL_00;
  char extraout_AL_01;
  char extraout_AL_02;
  char extraout_AL_03;
  char cVar2;
  uint uVar3;
  int iVar4;
  ulonglong uVar5;
  longlong *plVar6;
  longlong lVar7;
  undefined1 *puVar8;
  
  puVar8 = (undefined1 *)*param_2;
  cVar2 = puVar8[5];
  if (puVar8[4] == '\x02') {
    uVar5 = param_1;
    plVar6 = param_2;
    if (cVar2 == '!') {
      *(bool *)(param_1 + 0x30) = puVar8[8] == '\x01';
      uVar3 = _Cnd_broadcast(param_1 + 0x38);
      if (uVar3 == 0) {
        return;
      }
      uVar5 = (ulonglong)uVar3;
      std::_Throw_C_error(uVar3);
      cVar2 = extraout_AL;
    }
    if (cVar2 == '\"') {
      *(uint *)(param_1 + 0xd8) =
           CONCAT31(CONCAT21(CONCAT11(puVar8[8],puVar8[9]),puVar8[10]),puVar8[0xb]);
      *(undefined1 *)(param_1 + 0x30) = 1;
      uVar3 = _Cnd_broadcast(param_1 + 0x38);
      if (uVar3 == 0) {
        return;
      }
      uVar5 = (ulonglong)uVar3;
      std::_Throw_C_error(uVar3);
      cVar2 = extraout_AL_00;
    }
    if (cVar2 == '#') {
      *(bool *)(uVar5 + 0x30) = puVar8[8] == '\x01';
      uVar3 = _Cnd_broadcast(uVar5 + 0x38);
      if (uVar3 == 0) {
        return;
      }
      uVar5 = (ulonglong)uVar3;
      std::_Throw_C_error(uVar3);
      cVar2 = extraout_AL_01;
    }
    if (cVar2 == '$') {
      *(bool *)(uVar5 + 0x30) = puVar8[8] == '\x01';
      uVar3 = _Cnd_broadcast(uVar5 + 0x38);
      if (uVar3 == 0) {
        return;
      }
      uVar5 = (ulonglong)uVar3;
      std::_Throw_C_error(uVar3);
      cVar2 = extraout_AL_02;
    }
    if (cVar2 == '%') {
      iVar4 = ((int)plVar6[1] - (int)puVar8) + -9;
      *(longlong *)(param_1 + 0xe8) = *(longlong *)(param_1 + 0xe0);
      if (0 < iVar4) {
        lVar7 = 0;
        do {
          puVar8 = (undefined1 *)(*param_2 + 8 + lVar7);
          puVar1 = *(undefined1 **)(param_1 + 0xe8);
          if (puVar1 == *(undefined1 **)(param_1 + 0xf0)) {
            FUN_180007d30((longlong *)(param_1 + 0xe0),puVar1,puVar8);
          }
          else {
            *puVar1 = *puVar8;
            *(longlong *)(param_1 + 0xe8) = *(longlong *)(param_1 + 0xe8) + 1;
          }
          lVar7 = lVar7 + 1;
        } while (lVar7 < iVar4);
      }
      *(undefined1 *)(param_1 + 0x30) = 1;
      uVar3 = _Cnd_broadcast(param_1 + 0x38);
      if (uVar3 == 0) {
        return;
      }
      uVar5 = (ulonglong)uVar3;
      std::_Throw_C_error(uVar3);
      cVar2 = extraout_AL_03;
    }
    if (cVar2 == '&') {
      *(bool *)(uVar5 + 0x30) = puVar8[8] == '\x01';
      iVar4 = _Cnd_broadcast(uVar5 + 0x38);
      if (iVar4 != 0) {
        std::_Throw_C_error(iVar4);
      }
    }
  }
  return;
}


==================================================================

### EXPORT FUNC 180008ea0 (337 bytes) name=FUN_180008ea0

undefined8 * FUN_180008ea0(undefined8 *param_1,ulonglong param_2)

{
  void *pvVar1;
  void *pvVar2;
  
  *param_1 = EloTCMUpdaterDevice::vftable;
  if (*(int *)(param_1 + 0x24) != 0) {
                    /* WARNING: Subroutine does not return */
    terminate();
  }
  pvVar1 = (void *)param_1[0x20];
  if (pvVar1 != (void *)0x0) {
    pvVar2 = pvVar1;
    if ((0xfff < (ulonglong)(param_1[0x22] - (longlong)pvVar1)) &&
       (pvVar2 = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)pvVar2)))) goto LAB_180008feb;
    free(pvVar2);
    param_1[0x20] = 0;
    param_1[0x21] = 0;
    param_1[0x22] = 0;
  }
  if (0xf < (ulonglong)param_1[0x1f]) {
    pvVar1 = (void *)param_1[0x1c];
    pvVar2 = pvVar1;
    if ((0xfff < param_1[0x1f] + 1) &&
       (pvVar2 = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)pvVar2)))) {
LAB_180008feb:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(pvVar2);
  }
  param_1[0x1e] = 0;
  param_1[0x1f] = 0xf;
  *(undefined1 *)(param_1 + 0x1c) = 0;
  *param_1 = TCMVirtualDevice::vftable;
  _Mtx_destroy_in_situ(param_1 + 0x10);
  _Cnd_destroy_in_situ(param_1 + 7);
  FUN_180002550((longlong)(param_1 + 1));
  pvVar1 = (void *)param_1[1];
  param_1[1] = 0;
  free(pvVar1);
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 180009000 (467 bytes) name=FUN_180009000

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

undefined8 * FUN_180009000(longlong param_1,undefined8 *param_2,undefined8 param_3,longlong param_4)

{
  longlong lVar1;
  code *pcVar2;
  int iVar3;
  undefined8 *puVar4;
  longlong lVar5;
  undefined **ppuVar6;
  longlong *plVar7;
  undefined1 auStack_68 [32];
  undefined8 *local_48;
  undefined8 uStack_40;
  longlong local_38;
  int local_30;
  ulonglong local_28;
  
  local_28 = DAT_180015010 ^ (ulonglong)auStack_68;
  local_48 = param_2;
  if (DAT_180015ff0 != '\0') {
    FUN_180007960("askVersion\n",param_2,param_3,param_4);
  }
  ppuVar6 = &PTR_18000fde8;
  FUN_180002610((longlong *)(param_1 + 0xe0),&PTR_18000fde8,0);
  local_48 = (undefined8 *)FUN_18000c554(0x28);
  *local_48 = 0;
  local_48[1] = 0;
  local_48[2] = 0;
  local_48[3] = 0;
  local_48[4] = 0;
  puVar4 = FUN_18000a240(local_48,ppuVar6,4);
  if (puVar4 != (undefined8 *)0x0) {
    plVar7 = *(longlong **)(param_1 + 0xd0);
    if (plVar7 != (longlong *)0x0) {
      param_4 = *plVar7;
      (**(code **)(param_4 + 8))(plVar7,puVar4[1],puVar4[2] - puVar4[1]);
    }
    (**(code **)*puVar4)(puVar4,1);
  }
  lVar1 = param_1 + 0x80;
  uStack_40 = 0;
  local_48 = (undefined8 *)lVar1;
  iVar3 = _Mtx_lock(lVar1);
  if (iVar3 != 0) {
    std::_Throw_C_error(iVar3);
    pcVar2 = (code *)swi(3);
    puVar4 = (undefined8 *)(*pcVar2)();
    return puVar4;
  }
  uStack_40 = CONCAT71(uStack_40._1_7_,1);
  lVar5 = _Xtime_get_ticks();
  lVar5 = (lVar5 + 1000000) * 100;
  local_38 = lVar5 / 1000000000;
  local_30 = (int)lVar5 + (int)local_38 * -1000000000;
  iVar3 = _Mtx_current_owns(lVar1);
  if (iVar3 == 0) {
    std::_Throw_Cpp_error(4);
    pcVar2 = (code *)swi(3);
    puVar4 = (undefined8 *)(*pcVar2)();
    return puVar4;
  }
  plVar7 = &local_38;
  lVar5 = lVar1;
  iVar3 = _Cnd_timedwait(param_1 + 0x38);
  if (iVar3 == 0) {
    lVar5 = param_1 + 0xe0;
    if (0xf < *(ulonglong *)(param_1 + 0xf8)) {
      lVar5 = *(longlong *)(param_1 + 0xe0);
    }
    FUN_180007960("askVersion:%s\n",lVar5,plVar7,param_4);
  }
  else {
    if (iVar3 != 2) {
      std::_Throw_C_error(iVar3);
      pcVar2 = (code *)swi(3);
      puVar4 = (undefined8 *)(*pcVar2)();
      return puVar4;
    }
    FUN_180007960("askVersion timeout\n",lVar5,plVar7,param_4);
  }
  FUN_180002e60(param_2,(undefined8 *)(param_1 + 0xe0));
  iVar3 = _Mtx_unlock(lVar1);
  if (iVar3 != 0) {
    std::_Throw_C_error(iVar3);
  }
  return param_2;
}


==================================================================

### EXPORT FUNC 1800091e0 (799 bytes) name=FUN_1800091e0

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

void FUN_1800091e0(longlong param_1,undefined8 param_2,ulonglong param_3,longlong param_4)

{
  void *_Src;
  longlong lVar1;
  int iVar2;
  ulonglong uVar3;
  longlong lVar4;
  code *pcVar5;
  undefined8 uVar6;
  undefined8 uVar7;
  void *pvVar8;
  int iVar9;
  int iVar10;
  uint uVar11;
  undefined1 auStack_98 [32];
  ulonglong local_78;
  void *local_70;
  void *pvStack_68;
  longlong local_60;
  void *local_50;
  void *pvStack_48;
  longlong local_40;
  ulonglong local_38;
  
  local_38 = DAT_180015010 ^ (ulonglong)auStack_98;
  if (*(longlong *)(param_1 + 0x108) == *(longlong *)(param_1 + 0x100)) {
    pcVar5 = *(code **)(param_1 + 0xd8);
    if (pcVar5 == (code *)0x0) {
      return;
    }
    uVar7 = 0;
    uVar6 = 0;
  }
  else {
    uVar3 = FUN_180009510(param_1,param_2,param_3,param_4);
    if ((char)uVar3 == '\0') {
      FUN_180007960("beginUpdate fail\n",param_2,param_3,param_4);
      pcVar5 = *(code **)(param_1 + 0xd8);
      if (pcVar5 == (code *)0x0) {
        return;
      }
      uVar7 = 1;
      uVar6 = 0;
    }
    else {
      if (*(code **)(param_1 + 0xd8) != (code *)0x0) {
        param_2 = 1;
        (**(code **)(param_1 + 0xd8))(1);
      }
      local_78 = (*(longlong *)(param_1 + 0x108) - *(longlong *)(param_1 + 0x100)) + 0x7fU >> 7;
      uVar11 = 0;
      if (0 < (int)local_78) {
        iVar9 = 0;
        iVar10 = 0x62;
        do {
          lVar4 = *(longlong *)(param_1 + 0x100);
          iVar2 = ((int)*(undefined8 *)(param_1 + 0x108) - (int)lVar4) - iVar9;
          if (0x80 < iVar2) {
            iVar2 = 0x80;
          }
          local_50 = (void *)0x0;
          pvStack_48 = (void *)0x0;
          local_40 = 0;
          uVar3 = (ulonglong)iVar2;
          if (iVar2 != 0) {
            FUN_180002ba0((ulonglong *)&local_50,uVar3);
          }
          lVar1 = local_40;
          _Src = local_50;
          memmove(local_50,(void *)(iVar9 + lVar4),uVar3);
          pvStack_48 = (void *)((longlong)_Src + uVar3);
          local_70 = (void *)0x0;
          pvStack_68 = (void *)0x0;
          local_60 = 0;
          if (_Src != pvStack_48) {
            if (uVar3 < 0x1000) {
              if (uVar3 == 0) {
                local_70 = (void *)0x0;
              }
              else {
                local_70 = (void *)FUN_18000c554(uVar3);
              }
            }
            else {
              if (uVar3 + 0x27 <= uVar3) {
                    /* WARNING: Subroutine does not return */
                FUN_180001750();
              }
              lVar4 = FUN_18000c554(uVar3 + 0x27);
              if (lVar4 == 0) {
                    /* WARNING: Subroutine does not return */
                _invalid_parameter_noinfo_noreturn();
              }
              local_70 = (void *)(lVar4 + 0x27U & 0xffffffffffffffe0);
              *(longlong *)((longlong)local_70 - 8) = lVar4;
            }
            lVar4 = (longlong)local_70 + uVar3;
            pvStack_68 = local_70;
            local_60 = lVar4;
            memmove(local_70,_Src,uVar3);
            pvStack_68 = (void *)lVar4;
          }
          param_3 = (ulonglong)uVar11;
          uVar3 = FUN_180009850(param_1,(longlong *)&local_70,param_3,param_4);
          iVar2 = (int)local_78;
          if ((char)uVar3 == '\0') {
            FUN_180007960("transmitData fail\n",(longlong)iVar10 % (longlong)iVar2 & 0xffffffff,
                          param_3,param_4);
            if (*(code **)(param_1 + 0xd8) != (code *)0x0) {
              (**(code **)(param_1 + 0xd8))(0,iVar10 / iVar2 + 1);
            }
            if (_Src == (void *)0x0) {
              return;
            }
            pvVar8 = _Src;
            if (((ulonglong)(lVar1 - (longlong)_Src) < 0x1000) ||
               (pvVar8 = *(void **)((longlong)_Src + -8),
               (ulonglong)((longlong)_Src + (-8 - (longlong)pvVar8)) < 0x20)) {
              free(pvVar8);
              return;
            }
LAB_1800094a8:
                    /* WARNING: Subroutine does not return */
            _invalid_parameter_noinfo_noreturn();
          }
          if (*(code **)(param_1 + 0xd8) != (code *)0x0) {
            (**(code **)(param_1 + 0xd8))(1,iVar10 / iVar2 + 1);
          }
          if (_Src != (void *)0x0) {
            pvVar8 = _Src;
            if ((0xfff < (ulonglong)(lVar1 - (longlong)_Src)) &&
               (pvVar8 = *(void **)((longlong)_Src + -8),
               0x1f < (ulonglong)((longlong)_Src + (-8 - (longlong)pvVar8)))) goto LAB_1800094a8;
            free(pvVar8);
          }
          uVar11 = uVar11 + 1;
          param_2 = 0x80;
          iVar9 = iVar9 + 0x80;
          iVar10 = iVar10 + 0x62;
        } while ((int)uVar11 < iVar2);
      }
      uVar3 = FUN_1800096b0(param_1,param_2,param_3,param_4);
      if ((char)uVar3 == '\0') {
        FUN_180007960("completeUpdate fail\n",param_2,param_3,param_4);
        pcVar5 = *(code **)(param_1 + 0xd8);
        if (pcVar5 == (code *)0x0) {
          return;
        }
        uVar7 = 99;
        uVar6 = 0;
      }
      else {
        pcVar5 = *(code **)(param_1 + 0xd8);
        if (pcVar5 == (code *)0x0) {
          return;
        }
        uVar7 = 100;
        uVar6 = 1;
      }
    }
  }
  (*pcVar5)(uVar6,uVar7);
  return;
}


==================================================================

### EXPORT FUNC 180009510 (402 bytes) name=FUN_180009510

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

ulonglong FUN_180009510(longlong param_1,undefined8 param_2,undefined8 param_3,longlong param_4)

{
  longlong lVar1;
  byte bVar2;
  code *pcVar3;
  int iVar4;
  undefined8 *puVar5;
  ulonglong uVar6;
  longlong lVar7;
  longlong *plVar8;
  undefined1 auStack_58 [32];
  undefined8 *local_38;
  undefined8 uStack_30;
  longlong local_28;
  int local_20;
  ulonglong local_18;
  
  local_18 = DAT_180015010 ^ (ulonglong)auStack_58;
  if (DAT_180015ff0 != '\0') {
    FUN_180007960("beginUpdate\n",param_2,param_3,param_4);
  }
  *(undefined1 *)(param_1 + 0x30) = 0;
  local_38 = (undefined8 *)FUN_18000c554(0x28);
  *local_38 = 0;
  local_38[1] = 0;
  local_38[2] = 0;
  local_38[3] = 0;
  local_38[4] = 0;
  puVar5 = FUN_18000a240(local_38,param_2,5);
  if (puVar5 != (undefined8 *)0x0) {
    plVar8 = *(longlong **)(param_1 + 0xd0);
    if (plVar8 != (longlong *)0x0) {
      param_4 = *plVar8;
      (**(code **)(param_4 + 8))(plVar8,puVar5[1],puVar5[2] - puVar5[1]);
    }
    (**(code **)*puVar5)(puVar5,1);
  }
  lVar1 = param_1 + 0x80;
  uStack_30 = 0;
  local_38 = (undefined8 *)lVar1;
  iVar4 = _Mtx_lock(lVar1);
  if (iVar4 != 0) {
    std::_Throw_C_error(iVar4);
    pcVar3 = (code *)swi(3);
    uVar6 = (*pcVar3)();
    return uVar6;
  }
  uStack_30 = CONCAT71(uStack_30._1_7_,1);
  lVar7 = _Xtime_get_ticks();
  lVar7 = (lVar7 + 30000000) * 100;
  local_28 = lVar7 / 1000000000;
  local_20 = (int)lVar7 + (int)local_28 * -1000000000;
  iVar4 = _Mtx_current_owns(lVar1);
  if (iVar4 == 0) {
    std::_Throw_Cpp_error(4);
    pcVar3 = (code *)swi(3);
    uVar6 = (*pcVar3)();
    return uVar6;
  }
  plVar8 = &local_28;
  lVar7 = lVar1;
  iVar4 = _Cnd_timedwait(param_1 + 0x38);
  if (iVar4 == 0) {
    FUN_180007960("beginUpdate:%d\n",(ulonglong)*(byte *)(param_1 + 0x30),plVar8,param_4);
  }
  else {
    if (iVar4 != 2) {
      std::_Throw_C_error(iVar4);
      pcVar3 = (code *)swi(3);
      uVar6 = (*pcVar3)();
      return uVar6;
    }
    FUN_180007960("beginUpdate timeout\n",lVar7,plVar8,param_4);
  }
  bVar2 = *(byte *)(param_1 + 0x30);
  iVar4 = _Mtx_unlock(lVar1);
  if (iVar4 != 0) {
    std::_Throw_C_error(iVar4);
  }
  return (ulonglong)bVar2;
}


==================================================================

### EXPORT FUNC 1800096b0 (402 bytes) name=FUN_1800096b0

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

ulonglong FUN_1800096b0(longlong param_1,undefined8 param_2,undefined8 param_3,longlong param_4)

{
  longlong lVar1;
  byte bVar2;
  code *pcVar3;
  int iVar4;
  undefined8 *puVar5;
  ulonglong uVar6;
  longlong lVar7;
  longlong *plVar8;
  undefined1 auStack_58 [32];
  undefined8 *local_38;
  undefined8 uStack_30;
  longlong local_28;
  int local_20;
  ulonglong local_18;
  
  local_18 = DAT_180015010 ^ (ulonglong)auStack_58;
  if (DAT_180015ff0 != '\0') {
    FUN_180007960("completeUpdate\n",param_2,param_3,param_4);
  }
  *(undefined1 *)(param_1 + 0x30) = 0;
  local_38 = (undefined8 *)FUN_18000c554(0x28);
  *local_38 = 0;
  local_38[1] = 0;
  local_38[2] = 0;
  local_38[3] = 0;
  local_38[4] = 0;
  puVar5 = FUN_18000a240(local_38,param_2,6);
  if (puVar5 != (undefined8 *)0x0) {
    plVar8 = *(longlong **)(param_1 + 0xd0);
    if (plVar8 != (longlong *)0x0) {
      param_4 = *plVar8;
      (**(code **)(param_4 + 8))(plVar8,puVar5[1],puVar5[2] - puVar5[1]);
    }
    (**(code **)*puVar5)(puVar5,1);
  }
  lVar1 = param_1 + 0x80;
  uStack_30 = 0;
  local_38 = (undefined8 *)lVar1;
  iVar4 = _Mtx_lock(lVar1);
  if (iVar4 != 0) {
    std::_Throw_C_error(iVar4);
    pcVar3 = (code *)swi(3);
    uVar6 = (*pcVar3)();
    return uVar6;
  }
  uStack_30 = CONCAT71(uStack_30._1_7_,1);
  lVar7 = _Xtime_get_ticks();
  lVar7 = (lVar7 + 150000000) * 100;
  local_28 = lVar7 / 1000000000;
  local_20 = (int)lVar7 + (int)local_28 * -1000000000;
  iVar4 = _Mtx_current_owns(lVar1);
  if (iVar4 == 0) {
    std::_Throw_Cpp_error(4);
    pcVar3 = (code *)swi(3);
    uVar6 = (*pcVar3)();
    return uVar6;
  }
  plVar8 = &local_28;
  lVar7 = lVar1;
  iVar4 = _Cnd_timedwait(param_1 + 0x38);
  if (iVar4 == 0) {
    FUN_180007960("completeUpdate:%d\n",(ulonglong)*(byte *)(param_1 + 0x30),plVar8,param_4);
  }
  else {
    if (iVar4 != 2) {
      std::_Throw_C_error(iVar4);
      pcVar3 = (code *)swi(3);
      uVar6 = (*pcVar3)();
      return uVar6;
    }
    FUN_180007960("completeUpdate timeout\n",lVar7,plVar8,param_4);
  }
  bVar2 = *(byte *)(param_1 + 0x30);
  iVar4 = _Mtx_unlock(lVar1);
  if (iVar4 != 0) {
    std::_Throw_C_error(iVar4);
  }
  return (ulonglong)bVar2;
}


==================================================================

### EXPORT FUNC 180009850 (494 bytes) name=FUN_180009850

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

ulonglong FUN_180009850(longlong param_1,longlong *param_2,ulonglong param_3,undefined8 param_4)

{
  longlong lVar1;
  byte bVar2;
  void *pvVar3;
  code *pcVar4;
  int iVar5;
  undefined8 *puVar6;
  ulonglong uVar7;
  longlong lVar8;
  void *_Memory;
  longlong *plVar9;
  longlong *plVar10;
  undefined1 auStackY_78 [32];
  longlong local_30;
  int local_28;
  ulonglong local_20;
  
  local_20 = DAT_180015010 ^ (ulonglong)auStackY_78;
  plVar9 = param_2;
  uVar7 = param_3;
  if (DAT_180015ff0 != '\0') {
    plVar9 = (longlong *)(param_3 & 0xffffffff);
    FUN_180007960("transmitData %d\n",plVar9,param_3,param_4);
  }
  *(undefined1 *)(param_1 + 0x30) = 0;
  puVar6 = (undefined8 *)FUN_18000c554(0x28);
  *puVar6 = 0;
  puVar6[1] = 0;
  puVar6[2] = 0;
  puVar6[3] = 0;
  puVar6[4] = 0;
  plVar10 = param_2;
  puVar6 = FUN_180009fa0(puVar6,plVar9,uVar7,param_2,(int)param_3 + 0x8001);
  if (puVar6 != (undefined8 *)0x0) {
    plVar9 = *(longlong **)(param_1 + 0xd0);
    if (plVar9 != (longlong *)0x0) {
      plVar10 = (longlong *)*plVar9;
      (*(code *)plVar10[1])(plVar9,puVar6[1],puVar6[2] - puVar6[1]);
    }
    (**(code **)*puVar6)(puVar6,1);
  }
  lVar1 = param_1 + 0x80;
  iVar5 = _Mtx_lock(lVar1);
  if (iVar5 == 0) {
    lVar8 = _Xtime_get_ticks();
    lVar8 = (lVar8 + 5000000) * 100;
    local_30 = lVar8 / 1000000000;
    local_28 = (int)lVar8 + (int)local_30 * -1000000000;
    iVar5 = _Mtx_current_owns(lVar1);
    if (iVar5 == 0) {
      std::_Throw_Cpp_error(4);
      pcVar4 = (code *)swi(3);
      uVar7 = (*pcVar4)();
      return uVar7;
    }
    plVar9 = &local_30;
    lVar8 = lVar1;
    iVar5 = _Cnd_timedwait(param_1 + 0x38);
    if (iVar5 == 0) {
      FUN_180007960("transmitData:%d\n",(ulonglong)*(byte *)(param_1 + 0x30),plVar9,plVar10);
    }
    else {
      if (iVar5 != 2) {
        std::_Throw_C_error(iVar5);
        pcVar4 = (code *)swi(3);
        uVar7 = (*pcVar4)();
        return uVar7;
      }
      FUN_180007960("transmitData timeout\n",lVar8,plVar9,plVar10);
    }
    bVar2 = *(byte *)(param_1 + 0x30);
    iVar5 = _Mtx_unlock(lVar1);
    if (iVar5 != 0) {
      std::_Throw_C_error(iVar5);
    }
    pvVar3 = (void *)*param_2;
    if (pvVar3 != (void *)0x0) {
      _Memory = pvVar3;
      if ((0xfff < (ulonglong)(param_2[2] - (longlong)pvVar3)) &&
         (_Memory = *(void **)((longlong)pvVar3 + -8),
         0x1f < (ulonglong)((longlong)pvVar3 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
        _invalid_parameter_noinfo_noreturn();
      }
      free(_Memory);
      *param_2 = 0;
      param_2[1] = 0;
      param_2[2] = 0;
    }
    return (ulonglong)bVar2;
  }
  std::_Throw_C_error(iVar5);
  pcVar4 = (code *)swi(3);
  uVar7 = (*pcVar4)();
  return uVar7;
}


==================================================================

### EXPORT FUNC 180009a40 (36 bytes) name=FUN_180009a40

undefined1 FUN_180009a40(undefined8 param_1,char param_2,char param_3)

{
  bool bVar1;
  bool bVar2;
  
  if (param_2 == '\x02') {
    bVar1 = (byte)(param_3 - 4U) < 3;
    bVar2 = (byte)(param_3 - 4U) == 3;
  }
  else {
    if (param_2 != -0x7f) {
      return 0;
    }
    bVar1 = (byte)(param_3 - 10U) < 2;
    bVar2 = (byte)(param_3 - 10U) == 2;
  }
  if (!bVar1 && !bVar2) {
    return 0;
  }
  return 1;
}


==================================================================

### EXPORT FUNC 180009a70 (755 bytes) name=FUN_180009a70

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

void FUN_180009a70(longlong param_1,undefined8 *param_2)

{
  undefined8 *puVar1;
  char cVar2;
  undefined1 uVar3;
  ulonglong uVar4;
  void *pvVar5;
  char extraout_AL;
  char extraout_AL_00;
  char cVar6;
  char extraout_AL_01;
  char extraout_AL_02;
  int iVar7;
  undefined8 *puVar8;
  undefined1 *puVar9;
  void *pvVar10;
  ulonglong uVar11;
  undefined1 *puVar12;
  ulonglong uVar13;
  undefined1 auStack_88 [32];
  undefined1 *local_68;
  undefined1 *puStack_60;
  longlong local_58;
  undefined **local_50;
  void *pvStack_48;
  longlong local_40;
  longlong lStack_38;
  ulonglong local_30;
  ulonglong local_28;
  
  local_28 = DAT_180015010 ^ (ulonglong)auStack_88;
  pvVar10 = (void *)*param_2;
  cVar2 = *(char *)((longlong)pvVar10 + 4);
  cVar6 = *(char *)((longlong)pvVar10 + 5);
  if (cVar2 == '\x02') {
    if (cVar6 == '\x04') {
      local_50 = FTDICommand::vftable;
      pvStack_48 = (void *)0x0;
      local_40 = 0;
      lStack_38 = 0;
      uVar11 = param_2[1] - (longlong)pvVar10;
      iVar7 = (int)uVar11 + -9;
      if (iVar7 < 0) {
        iVar7 = 0;
      }
      local_30 = (ulonglong)CONCAT24(*(undefined2 *)((longlong)pvVar10 + 4),iVar7);
      if (uVar11 != 0) {
        FUN_180002ba0((ulonglong *)&pvStack_48,uVar11);
      }
      pvVar5 = pvStack_48;
      uVar13 = uVar11;
      memmove(pvStack_48,pvVar10,uVar11);
      local_40 = (longlong)pvVar5 + uVar11;
      local_68 = (undefined1 *)0x0;
      puStack_60 = (undefined1 *)0x0;
      local_58 = 0;
      FUN_18000a360((longlong)&local_50,(longlong *)&local_68);
      puVar9 = puStack_60;
      puVar1 = (undefined8 *)(param_1 + 0xe0);
      *(undefined8 *)(param_1 + 0xf0) = 0;
      puVar8 = puVar1;
      if (0xf < *(ulonglong *)(param_1 + 0xf8)) {
        puVar8 = (undefined8 *)*puVar1;
      }
      *(undefined1 *)puVar8 = 0;
      for (puVar12 = local_68; puVar12 != puVar9; puVar12 = puVar12 + 1) {
        uVar3 = *puVar12;
        uVar11 = *(ulonglong *)(param_1 + 0xf0);
        uVar4 = *(ulonglong *)(param_1 + 0xf8);
        if (uVar11 < uVar4) {
          *(ulonglong *)(param_1 + 0xf0) = uVar11 + 1;
          puVar8 = puVar1;
          if (0xf < uVar4) {
            puVar8 = (undefined8 *)*puVar1;
          }
          *(undefined1 *)((longlong)puVar8 + uVar11) = uVar3;
          *(undefined1 *)((longlong)puVar8 + uVar11 + 1) = 0;
        }
        else {
          FUN_180002770(puVar1,uVar4,uVar13,uVar3);
        }
      }
      iVar7 = _Cnd_broadcast(param_1 + 0x38);
      if (iVar7 != 0) {
        std::_Throw_C_error(iVar7);
      }
      if (local_68 != (undefined1 *)0x0) {
        puVar9 = local_68;
        if ((0xfff < (ulonglong)(local_58 - (longlong)local_68)) &&
           (puVar9 = *(undefined1 **)(local_68 + -8),
           (undefined1 *)0x1f < local_68 + (-8 - (longlong)puVar9))) {
                    /* WARNING: Subroutine does not return */
          _invalid_parameter_noinfo_noreturn();
        }
        free(puVar9);
        local_68 = (undefined1 *)0x0;
        puStack_60 = (undefined1 *)0x0;
        local_58 = 0;
      }
      if (pvStack_48 != (void *)0x0) {
        pvVar10 = pvStack_48;
        if ((0xfff < (ulonglong)(lStack_38 - (longlong)pvStack_48)) &&
           (pvVar10 = *(void **)((longlong)pvStack_48 + -8),
           0x1f < (ulonglong)((longlong)pvStack_48 + (-8 - (longlong)pvVar10)))) {
                    /* WARNING: Subroutine does not return */
          _invalid_parameter_noinfo_noreturn();
        }
        free(pvVar10);
      }
    }
    else {
      if (cVar6 == '\x05') {
        *(bool *)(param_1 + 0x30) = *(char *)((longlong)pvVar10 + 8) == '\x01';
        iVar7 = _Cnd_broadcast(param_1 + 0x38);
        if (iVar7 == 0) {
          return;
        }
        std::_Throw_C_error(iVar7);
        cVar6 = extraout_AL;
      }
      if (cVar6 == '\x06') {
        *(bool *)(param_1 + 0x30) = *(char *)((longlong)pvVar10 + 8) == '\x01';
        iVar7 = _Cnd_broadcast(param_1 + 0x38);
        if (iVar7 == 0) {
          return;
        }
        std::_Throw_C_error(iVar7);
        cVar6 = extraout_AL_00;
      }
      if (cVar6 == '\a') {
        *(bool *)(param_1 + 0x30) = *(char *)((longlong)pvVar10 + 8) == '\x01';
        iVar7 = _Cnd_broadcast(param_1 + 0x38);
        if (iVar7 != 0) {
          std::_Throw_C_error(iVar7);
        }
      }
    }
  }
  else if (cVar2 == -0x7f) {
    if (cVar6 == '\f') {
      *(bool *)(param_1 + 0x30) = *(char *)((longlong)pvVar10 + 8) == '\x01';
      iVar7 = _Cnd_broadcast(param_1 + 0x38);
      if (iVar7 == 0) {
        return;
      }
      std::_Throw_C_error(iVar7);
      cVar6 = extraout_AL_01;
    }
    if (cVar6 == '\n') {
      *(bool *)(param_1 + 0x30) = *(char *)((longlong)pvVar10 + 8) == '\x01';
      iVar7 = _Cnd_broadcast(param_1 + 0x38);
      if (iVar7 == 0) {
        return;
      }
      std::_Throw_C_error(iVar7);
      cVar6 = extraout_AL_02;
    }
    if (cVar6 == '\v') {
      *(bool *)(param_1 + 0x30) = *(char *)((longlong)pvVar10 + 8) == '\x01';
      iVar7 = _Cnd_broadcast(param_1 + 0x38);
      if (iVar7 != 0) {
        std::_Throw_C_error(iVar7);
      }
    }
  }
  return;
}


==================================================================

### EXPORT FUNC 180009d70 (549 bytes) name=FUN_180009d70

void FUN_180009d70(longlong param_1,undefined8 param_2,undefined1 param_3,longlong *param_4)

{
  longlong *plVar1;
  void *_Dst;
  int iVar2;
  longlong lVar3;
  longlong lVar4;
  char cVar5;
  ulonglong uVar6;
  char cVar7;
  ulonglong uVar8;
  int iVar9;
  uint uVar10;
  char cVar11;
  longlong lVar12;
  
  plVar1 = (longlong *)(param_1 + 8);
  iVar2 = (int)param_4[1] - (int)*param_4;
  *(int *)(param_1 + 0x20) = iVar2;
  *(undefined1 *)(param_1 + 0x24) = 2;
  *(undefined1 *)(param_1 + 0x25) = param_3;
  _Dst = *(void **)(param_1 + 0x10);
  lVar3 = *plVar1;
  uVar8 = (ulonglong)(iVar2 + 9);
  uVar6 = (longlong)_Dst - lVar3;
  if (uVar8 < uVar6) {
    lVar3 = lVar3 + uVar8;
LAB_180009dfd:
    *(longlong *)(param_1 + 0x10) = lVar3;
  }
  else if (uVar6 < uVar8) {
    if (uVar8 <= (ulonglong)(*(longlong *)(param_1 + 0x18) - lVar3)) {
      memset(_Dst,0,uVar8 - uVar6);
      lVar3 = (uVar8 - uVar6) + (longlong)_Dst;
      goto LAB_180009dfd;
    }
    FUN_18000a400(plVar1,uVar8);
  }
  cVar7 = '\0';
  iVar9 = 3;
  *(undefined1 *)*plVar1 = 0x7e;
  *(char *)(*plVar1 + 1) = (char)((uint)(iVar2 + 5) >> 8);
  *(char *)(*plVar1 + 2) = (char)(iVar2 + 5);
  lVar3 = *plVar1;
  if ((ulonglong)(*(longlong *)(param_1 + 0x10) - lVar3) < 3) {
    iVar9 = (int)*(longlong *)(param_1 + 0x10) - (int)lVar3;
  }
  lVar12 = (longlong)iVar9;
  cVar5 = '\0';
  uVar6 = 0;
  cVar11 = '\0';
  if (0 < lVar12) {
    uVar8 = uVar6;
    if (lVar12 < 2) {
LAB_180009e80:
      cVar7 = *(char *)(uVar8 + lVar3);
    }
    else {
      do {
        cVar5 = cVar5 + *(char *)(uVar8 + lVar3);
        cVar11 = cVar11 + *(char *)(uVar8 + 1 + lVar3);
        uVar8 = uVar8 + 2;
      } while ((longlong)uVar8 < lVar12 + -1);
      if ((longlong)uVar8 < lVar12) goto LAB_180009e80;
    }
    cVar7 = cVar7 + cVar5 + cVar11;
  }
  *(char *)(lVar3 + 3) = cVar7;
  *(undefined1 *)(*plVar1 + 4) = 2;
  *(undefined1 *)(*plVar1 + 5) = param_3;
  *(char *)(*plVar1 + 6) = (char)((uint)DAT_180015038 >> 8);
  *(char *)(*plVar1 + 7) = (char)DAT_180015038;
  uVar8 = uVar6;
  if (param_4[1] != *param_4) {
    do {
      uVar10 = (int)uVar8 + 1;
      *(undefined1 *)(uVar6 + 8 + *plVar1) = *(undefined1 *)(uVar6 + *param_4);
      uVar6 = uVar6 + 1;
      uVar8 = (ulonglong)uVar10;
    } while ((ulonglong)(longlong)(int)uVar10 < (ulonglong)(param_4[1] - *param_4));
  }
  iVar2 = iVar2 + 8;
  lVar3 = *plVar1;
  uVar6 = (ulonglong)iVar2;
  cVar7 = '\0';
  if ((ulonglong)(*(longlong *)(param_1 + 0x10) - lVar3) < uVar6) {
    iVar2 = (int)*(longlong *)(param_1 + 0x10) - (int)lVar3;
  }
  cVar5 = '\0';
  lVar12 = (longlong)iVar2;
  cVar11 = '\0';
  if (lVar12 < 5) goto LAB_180009f5b;
  lVar4 = 4;
  if (lVar12 < 6) {
LAB_180009f50:
    cVar7 = *(char *)(lVar3 + lVar4);
  }
  else {
    do {
      cVar5 = cVar5 + *(char *)(lVar3 + lVar4);
      cVar11 = cVar11 + *(char *)(lVar3 + 1 + lVar4);
      lVar4 = lVar4 + 2;
    } while (lVar4 < lVar12 + -1);
    if (lVar4 < lVar12) goto LAB_180009f50;
  }
  cVar7 = cVar7 + cVar5 + cVar11;
LAB_180009f5b:
  iVar2 = 1;
  if (DAT_180015038 + 1 < 0x8000) {
    iVar2 = DAT_180015038 + 1;
  }
  *(char *)(uVar6 + lVar3) = cVar7;
  DAT_180015038 = iVar2;
  return;
}


==================================================================

### EXPORT FUNC 180009fa0 (527 bytes) name=FUN_180009fa0

undefined8 *
FUN_180009fa0(undefined8 *param_1,undefined8 param_2,undefined8 param_3,longlong *param_4,
             undefined4 param_5)

{
  void *_Dst;
  longlong lVar1;
  int iVar2;
  ulonglong uVar3;
  longlong lVar4;
  int iVar5;
  char cVar6;
  void *pvVar7;
  uint uVar8;
  ulonglong uVar9;
  char cVar10;
  char cVar11;
  longlong lVar12;
  
  *param_1 = FTDICommand::vftable;
  uVar9 = 0;
  param_1[1] = 0;
  param_1[2] = 0;
  param_1[3] = 0;
  iVar2 = (int)param_4[1] - (int)*param_4;
  *(int *)(param_1 + 4) = iVar2;
  *(undefined2 *)((longlong)param_1 + 0x24) = 0x702;
  pvVar7 = (void *)(longlong)(iVar2 + 9);
  _Dst = (void *)param_1[2];
  if (pvVar7 < _Dst) {
    param_1[2] = pvVar7;
  }
  else if (_Dst < pvVar7) {
    if (iVar2 + 9 == 0) {
      memset(_Dst,0,-(longlong)_Dst);
      param_1[2] = 0;
    }
    else {
      FUN_18000a400(param_1 + 1,(ulonglong)pvVar7);
    }
  }
  *(undefined1 *)param_1[1] = 0x7e;
  *(char *)(param_1[1] + 1) = (char)((uint)(iVar2 + 5) >> 8);
  *(char *)(param_1[1] + 2) = (char)(iVar2 + 5);
  cVar11 = '\0';
  lVar1 = param_1[1];
  iVar5 = 3;
  if ((ulonglong)(param_1[2] - lVar1) < 3) {
    iVar5 = (int)(param_1[2] - lVar1);
  }
  cVar6 = '\0';
  cVar10 = '\0';
  lVar12 = (longlong)iVar5;
  if (0 < iVar5) {
    uVar3 = uVar9;
    if (lVar12 < 2) {
LAB_18000a0b0:
      cVar11 = *(char *)(uVar3 + lVar1);
    }
    else {
      do {
        cVar6 = cVar6 + *(char *)(uVar3 + lVar1);
        cVar10 = cVar10 + *(char *)(uVar3 + 1 + lVar1);
        uVar3 = uVar3 + 2;
      } while ((longlong)uVar3 < lVar12 + -1);
      if ((longlong)uVar3 < lVar12) goto LAB_18000a0b0;
    }
    cVar11 = cVar11 + cVar6 + cVar10;
  }
  *(char *)(lVar1 + 3) = cVar11;
  *(undefined1 *)(param_1[1] + 4) = 2;
  *(undefined1 *)(param_1[1] + 5) = 7;
  *(char *)(param_1[1] + 6) = (char)((uint)param_5 >> 8);
  *(char *)(param_1[1] + 7) = (char)param_5;
  uVar3 = uVar9;
  if (param_4[1] != *param_4) {
    do {
      *(undefined1 *)(param_1[1] + 8 + uVar3) = *(undefined1 *)(uVar3 + *param_4);
      uVar8 = (int)uVar9 + 1;
      uVar9 = (ulonglong)uVar8;
      uVar3 = uVar3 + 1;
    } while ((ulonglong)(longlong)(int)uVar8 < (ulonglong)(param_4[1] - *param_4));
  }
  iVar2 = iVar2 + 8;
  cVar11 = '\0';
  lVar1 = param_1[1];
  cVar6 = '\0';
  cVar10 = '\0';
  iVar5 = (int)(param_1[2] - lVar1);
  if ((ulonglong)(longlong)iVar2 <= (ulonglong)(param_1[2] - lVar1)) {
    iVar5 = iVar2;
  }
  lVar12 = (longlong)iVar5;
  if (lVar12 < 5) goto LAB_18000a18b;
  lVar4 = 4;
  if (lVar12 < 6) {
LAB_18000a180:
    cVar11 = *(char *)(lVar4 + lVar1);
  }
  else {
    do {
      cVar6 = cVar6 + *(char *)(lVar4 + lVar1);
      cVar10 = cVar10 + *(char *)(lVar4 + 1 + lVar1);
      lVar4 = lVar4 + 2;
    } while (lVar4 < lVar12 + -1);
    if (lVar4 < lVar12) goto LAB_18000a180;
  }
  cVar11 = cVar11 + cVar6 + cVar10;
LAB_18000a18b:
  *(char *)(iVar2 + lVar1) = cVar11;
  return param_1;
}


==================================================================

### EXPORT FUNC 18000a1b0 (132 bytes) name=FUN_18000a1b0

undefined8 * FUN_18000a1b0(undefined8 *param_1,uint param_2)

{
  void *pvVar1;
  void *_Memory;
  
  *param_1 = FTDICommand::vftable;
  pvVar1 = (void *)param_1[1];
  if (pvVar1 != (void *)0x0) {
    _Memory = pvVar1;
    if ((0xfff < (ulonglong)(param_1[3] - (longlong)pvVar1)) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
    param_1[1] = 0;
    param_1[2] = 0;
    param_1[3] = 0;
  }
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 18000a240 (166 bytes) name=FUN_18000a240

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

undefined8 * FUN_18000a240(undefined8 *param_1,undefined8 param_2,undefined1 param_3)

{
  void *_Memory;
  undefined1 auStack_58 [32];
  undefined8 *local_38;
  void *local_30;
  undefined8 uStack_28;
  longlong local_20;
  ulonglong local_18;
  
  local_18 = DAT_180015010 ^ (ulonglong)auStack_58;
  *param_1 = FTDICommand::vftable;
  param_1[1] = 0;
  param_1[2] = 0;
  param_1[3] = 0;
  local_30 = (void *)0x0;
  uStack_28 = 0;
  local_20 = 0;
  local_38 = param_1;
  FUN_180009d70((longlong)param_1,param_2,param_3,(longlong *)&local_30);
  if (local_30 != (void *)0x0) {
    _Memory = local_30;
    if ((0xfff < (ulonglong)(local_20 - (longlong)local_30)) &&
       (_Memory = *(void **)((longlong)local_30 + -8),
       0x1f < (ulonglong)((longlong)local_30 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 18000a2f0 (99 bytes) name=FUN_18000a2f0

void FUN_18000a2f0(undefined8 *param_1)

{
  void *pvVar1;
  void *_Memory;
  
  *param_1 = FTDICommand::vftable;
  pvVar1 = (void *)param_1[1];
  if (pvVar1 != (void *)0x0) {
    _Memory = pvVar1;
    if ((0xfff < (ulonglong)(param_1[3] - (longlong)pvVar1)) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
    param_1[1] = 0;
    param_1[2] = 0;
    param_1[3] = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 18000a360 (155 bytes) name=FUN_18000a360

longlong * FUN_18000a360(longlong param_1,longlong *param_2)

{
  undefined1 *puVar1;
  ulonglong uVar2;
  uint uVar3;
  ulonglong uVar4;
  undefined1 *puVar5;
  
  uVar2 = 0;
  *param_2 = 0;
  param_2[1] = 0;
  *param_2 = 0;
  param_2[1] = 0;
  param_2[2] = 0;
  uVar4 = uVar2;
  if (0 < *(int *)(param_1 + 0x20)) {
    do {
      puVar5 = (undefined1 *)(*(longlong *)(param_1 + 8) + 8 + uVar2);
      puVar1 = (undefined1 *)param_2[1];
      if (puVar1 == (undefined1 *)param_2[2]) {
        FUN_180007d30(param_2,puVar1,puVar5);
      }
      else {
        *puVar1 = *puVar5;
        param_2[1] = param_2[1] + 1;
      }
      uVar3 = (int)uVar4 + 1;
      uVar2 = uVar2 + 1;
      uVar4 = (ulonglong)uVar3;
    } while ((int)uVar3 < *(int *)(param_1 + 0x20));
  }
  return param_2;
}


==================================================================

### EXPORT FUNC 18000a400 (255 bytes) name=FUN_18000a400

void FUN_18000a400(longlong *param_1,ulonglong param_2)

{
  longlong lVar1;
  longlong lVar2;
  longlong lVar3;
  ulonglong uVar4;
  ulonglong uVar5;
  void *_Dst;
  
  if (0x7fffffffffffffff < param_2) {
                    /* WARNING: Subroutine does not return */
    FUN_180002b80();
  }
  lVar1 = param_1[1];
  lVar2 = *param_1;
  uVar4 = param_1[2] - *param_1;
  uVar5 = param_2;
  if ((uVar4 <= 0x7fffffffffffffff - (uVar4 >> 1)) &&
     (uVar5 = (uVar4 >> 1) + uVar4, uVar5 < param_2)) {
    uVar5 = param_2;
  }
  if (uVar5 < 0x1000) {
    if (uVar5 == 0) {
      _Dst = (void *)0x0;
    }
    else {
      _Dst = (void *)FUN_18000c554(uVar5);
    }
  }
  else {
    if (uVar5 + 0x27 <= uVar5) {
                    /* WARNING: Subroutine does not return */
      FUN_180001750();
    }
    lVar3 = FUN_18000c554(uVar5 + 0x27);
    if (lVar3 == 0) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    _Dst = (void *)(lVar3 + 0x27U & 0xffffffffffffffe0);
    *(longlong *)((longlong)_Dst - 8) = lVar3;
  }
  memset((void *)((longlong)_Dst + (lVar1 - lVar2)),0,param_2 - (lVar1 - lVar2));
  memmove(_Dst,(void *)*param_1,param_1[1] - *param_1);
  FUN_180007280(param_1,(longlong)_Dst,param_2,uVar5);
  return;
}


==================================================================

### EXPORT FUNC 18000a510 (1101 bytes) name=FUN_18000a510

undefined8 * FUN_18000a510(undefined8 *param_1)

{
  undefined8 *puVar1;
  longlong *plVar2;
  undefined8 *puVar3;
  longlong *plVar4;
  undefined8 *local_res10;
  
  *param_1 = TCMDevice::vftable;
  param_1[1] = SerialPort::vftable;
  param_1[2] = 0;
  param_1[3] = 0;
  *(undefined1 *)(param_1 + 4) = 0;
  param_1[5] = 0;
  param_1[6] = 0;
  puVar1 = param_1 + 7;
  *puVar1 = 0;
  param_1[8] = 0;
  param_1[9] = 0;
  param_1[10] = 0;
  param_1[0xb] = 0;
  puVar3 = (undefined8 *)FUN_18000c554(0x10);
  puVar3[1] = 0;
  *puVar1 = puVar3;
  *puVar3 = puVar1;
  param_1[0xc] = 0;
  param_1[0xd] = 0;
  param_1[0xe] = 0;
  puVar3 = (undefined8 *)FUN_18000c554(0xd8);
  local_res10 = puVar3;
  memset(puVar3,0,0xd8);
  FUN_18000b410(puVar3);
  *puVar3 = EloTCMAudioDevice::vftable;
  *(undefined1 *)(puVar3 + 6) = 0;
  puVar1 = (undefined8 *)param_1[0xd];
  if (puVar1 == (undefined8 *)param_1[0xe]) {
    local_res10 = puVar3;
    FUN_18000b280(param_1 + 0xc,puVar1,&local_res10);
  }
  else {
    *puVar1 = puVar3;
    param_1[0xd] = param_1[0xd] + 8;
    local_res10 = puVar3;
  }
  puVar3 = (undefined8 *)FUN_18000c554(0xd8);
  local_res10 = puVar3;
  memset(puVar3,0,0xd8);
  FUN_18000b410(puVar3);
  *puVar3 = EloTCMLightDevice::vftable;
  *(undefined1 *)(puVar3 + 6) = 0;
  puVar1 = (undefined8 *)param_1[0xd];
  if (puVar1 == (undefined8 *)param_1[0xe]) {
    local_res10 = puVar3;
    FUN_18000b280(param_1 + 0xc,puVar1,&local_res10);
  }
  else {
    *puVar1 = puVar3;
    param_1[0xd] = param_1[0xd] + 8;
    local_res10 = puVar3;
  }
  puVar3 = (undefined8 *)FUN_18000c554(0xd8);
  local_res10 = puVar3;
  memset(puVar3,0,0xd8);
  FUN_18000b410(puVar3);
  *puVar3 = EloTCMPowerDevice::vftable;
  *(undefined1 *)(puVar3 + 6) = 0;
  puVar1 = (undefined8 *)param_1[0xd];
  if (puVar1 == (undefined8 *)param_1[0xe]) {
    local_res10 = puVar3;
    FUN_18000b280(param_1 + 0xc,puVar1,&local_res10);
  }
  else {
    *puVar1 = puVar3;
    param_1[0xd] = param_1[0xd] + 8;
    local_res10 = puVar3;
  }
  puVar3 = (undefined8 *)FUN_18000c554(0x138);
  local_res10 = puVar3;
  memset(puVar3,0,0x138);
  FUN_18000b410(puVar3);
  *puVar3 = EloTCMScannerDevice::vftable;
  puVar3[0x1b] = EloTCMScannerDevice::vftable;
  puVar3[0x21] = 0;
  puVar3[0x22] = 0xf;
  *(undefined1 *)(puVar3 + 0x1f) = 0;
  puVar3[0x23] = 0;
  puVar3[0x24] = 0;
  puVar3[0x25] = 0;
  puVar3[0x1c] = 0;
  puVar3[0x1d] = 0;
  puVar3[0x1e] = 0;
  *(undefined1 *)(puVar3 + 6) = 0;
  *(undefined1 *)(puVar3 + 0x26) = 0;
  puVar1 = (undefined8 *)param_1[0xd];
  if (puVar1 == (undefined8 *)param_1[0xe]) {
    local_res10 = puVar3;
    FUN_18000b280(param_1 + 0xc,puVar1,&local_res10);
  }
  else {
    *puVar1 = puVar3;
    param_1[0xd] = param_1[0xd] + 8;
    local_res10 = puVar3;
  }
  puVar3 = (undefined8 *)FUN_18000c554(0xf8);
  local_res10 = puVar3;
  memset(puVar3,0,0xf8);
  FUN_18000b410(puVar3);
  *puVar3 = EloTCMScheduleTaskDevice::vftable;
  puVar3[0x1c] = 0;
  puVar3[0x1d] = 0;
  puVar3[0x1e] = 0;
  *(undefined1 *)(puVar3 + 6) = 0;
  *(undefined4 *)(puVar3 + 0x1b) = 0;
  puVar1 = (undefined8 *)param_1[0xd];
  if (puVar1 == (undefined8 *)param_1[0xe]) {
    local_res10 = puVar3;
    FUN_18000b280(param_1 + 0xc,puVar1,&local_res10);
  }
  else {
    *puVar1 = puVar3;
    param_1[0xd] = param_1[0xd] + 8;
    local_res10 = puVar3;
  }
  puVar3 = (undefined8 *)FUN_18000c554(0x128);
  local_res10 = puVar3;
  memset(puVar3,0,0x128);
  FUN_18000b410(puVar3);
  *puVar3 = EloTCMUpdaterDevice::vftable;
  puVar3[0x1e] = 0;
  puVar3[0x1f] = 0xf;
  *(undefined1 *)(puVar3 + 0x1c) = 0;
  puVar3[0x20] = 0;
  puVar3[0x21] = 0;
  puVar3[0x22] = 0;
  puVar3[0x23] = 0;
  puVar3[0x24] = 0;
  puVar3[0x1b] = 0;
  puVar1 = (undefined8 *)param_1[0xd];
  if (puVar1 == (undefined8 *)param_1[0xe]) {
    local_res10 = puVar3;
    FUN_18000b280(param_1 + 0xc,puVar1,&local_res10);
  }
  else {
    *puVar1 = puVar3;
    param_1[0xd] = param_1[0xd] + 8;
    local_res10 = puVar3;
  }
  puVar3 = (undefined8 *)FUN_18000c554(0xd8);
  local_res10 = puVar3;
  memset(puVar3,0,0xd8);
  FUN_18000b410(puVar3);
  *puVar3 = EloMotorDevice::vftable;
  *(undefined1 *)(puVar3 + 6) = 0;
  puVar1 = (undefined8 *)param_1[0xd];
  if (puVar1 == (undefined8 *)param_1[0xe]) {
    local_res10 = puVar3;
    FUN_18000b280(param_1 + 0xc,puVar1,&local_res10);
  }
  else {
    *puVar1 = puVar3;
    param_1[0xd] = param_1[0xd] + 8;
    local_res10 = puVar3;
  }
  puVar3 = (undefined8 *)FUN_18000c554(0xe0);
  local_res10 = puVar3;
  memset(puVar3,0,0xe0);
  FUN_18000b410(puVar3);
  *puVar3 = EloProximityDevice::vftable;
  *(undefined1 *)(puVar3 + 6) = 0;
  puVar3[0x1b] = 0;
  puVar1 = (undefined8 *)param_1[0xd];
  if (puVar1 == (undefined8 *)param_1[0xe]) {
    local_res10 = puVar3;
    FUN_18000b280(param_1 + 0xc,puVar1,&local_res10);
  }
  else {
    *puVar1 = puVar3;
    param_1[0xd] = param_1[0xd] + 8;
  }
  plVar2 = (longlong *)param_1[0xd];
  for (plVar4 = (longlong *)param_1[0xc]; plVar4 != plVar2; plVar4 = plVar4 + 1) {
    *(undefined8 **)(*plVar4 + 0xd0) = param_1 + 1;
  }
  param_1[6] = param_1;
  return param_1;
}


==================================================================

### EXPORT FUNC 18000a960 (614 bytes) name=FUN_18000a960

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

ulonglong FUN_18000a960(longlong param_1,undefined8 param_2,undefined8 param_3,undefined8 param_4)

{
  bool bVar1;
  longlong *plVar2;
  byte bVar3;
  int iVar4;
  void *_Buf1;
  ulonglong uVar5;
  longlong *plVar6;
  undefined8 uVar7;
  undefined8 *******_Buf;
  undefined1 auStack_138 [32];
  longlong *local_118;
  longlong local_110 [4];
  undefined8 local_f0 [4];
  undefined8 ******local_d0 [2];
  ulonglong local_c0;
  ulonglong local_b8;
  longlong *local_b0;
  longlong *plStack_a8;
  longlong local_a0;
  longlong local_98 [4];
  undefined8 local_78 [4];
  undefined8 local_58 [4];
  ulonglong local_38;
  
  local_38 = DAT_180015010 ^ (ulonglong)auStack_138;
  local_b0 = (longlong *)0x0;
  plStack_a8 = (longlong *)0x0;
  local_a0 = 0;
  FUN_180002fd0((longlong *)&local_b0);
  plVar2 = plStack_a8;
  plVar6 = local_b0;
  do {
    if (plVar6 == plVar2) {
      uVar5 = 0;
LAB_18000aacd:
      plVar2 = plStack_a8;
      plVar6 = local_b0;
      if (local_b0 != (longlong *)0x0) {
        for (; plVar6 != plVar2; plVar6 = plVar6 + 0xc) {
          FUN_180002ca0(plVar6);
        }
        plVar6 = local_b0;
        if ((0xfff < (ulonglong)(((local_a0 - (longlong)local_b0) / 0x60) * 0x60)) &&
           (plVar6 = (longlong *)local_b0[-1],
           0x1f < (ulonglong)((longlong)local_b0 + (-8 - (longlong)plVar6)))) {
                    /* WARNING: Subroutine does not return */
          _invalid_parameter_noinfo_noreturn();
        }
        free(plVar6);
      }
      return uVar5;
    }
    FUN_180002e60(local_98,plVar6);
    FUN_180002e60(local_78,plVar6 + 4);
    FUN_180002e60(local_58,plVar6 + 8);
    local_118 = local_110;
    FUN_180002e60(local_110,local_98);
    FUN_180002e60(local_f0,local_78);
    FUN_180002e60(local_d0,local_58);
    uVar5 = local_c0;
    _Buf = local_d0;
    if (0xf < local_b8) {
      _Buf = (undefined8 *******)local_d0[0];
    }
    if (0x20 < local_c0) {
      for (_Buf1 = memchr(_Buf,0x46,local_c0 - 0x20); _Buf1 != (void *)0x0;
          _Buf1 = memchr((void *)((longlong)_Buf1 + 1),0x46,
                         (longlong)_Buf + ((uVar5 - 0x20) - ((longlong)_Buf1 + 1)))) {
        iVar4 = memcmp(_Buf1,"FTDIBUS\\COMPORT&VID_0403&PID_6001",0x21);
        if (iVar4 == 0) {
          if ((longlong)_Buf1 - (longlong)_Buf != -1) {
            bVar1 = true;
            goto LAB_18000aa9e;
          }
          break;
        }
      }
    }
    bVar1 = false;
LAB_18000aa9e:
    FUN_180002ca0(local_110);
    if (bVar1) {
      uVar7 = 0x1c200;
      bVar3 = (**(code **)(*(longlong *)(param_1 + 8) + 0x18))((longlong *)(param_1 + 8),local_98);
      uVar5 = (ulonglong)bVar3;
      FUN_180007960("TCM Open:%d\n",uVar5,uVar7,param_4);
      FUN_180002ca0(local_98);
      goto LAB_18000aacd;
    }
    FUN_180002ca0(local_98);
    plVar6 = plVar6 + 0xc;
  } while( true );
}


==================================================================

### EXPORT FUNC 18000abd0 (172 bytes) name=FUN_18000abd0

longlong * FUN_18000abd0(longlong param_1,longlong *param_2)

{
  undefined1 *puVar1;
  ulonglong uVar2;
  longlong lVar3;
  longlong lVar4;
  undefined1 local_18 [4];
  undefined4 local_14;
  longlong *local_10;
  
  lVar4 = 0;
  *param_2 = 0;
  param_2[1] = 0;
  *param_2 = 0;
  param_2[1] = 0;
  param_2[2] = 0;
  local_14 = 1;
  lVar3 = 4;
  local_10 = param_2;
  do {
    uVar2 = *(longlong *)(param_1 + 0x50) + lVar4;
    local_18[0] = *(undefined1 *)
                   ((ulonglong)((uint)uVar2 & 0xf) +
                   *(longlong *)
                    (*(longlong *)(param_1 + 0x40) +
                    (uVar2 >> 4 & *(longlong *)(param_1 + 0x48) - 1U) * 8));
    puVar1 = (undefined1 *)param_2[1];
    if (puVar1 == (undefined1 *)param_2[2]) {
      FUN_180007d30(param_2,puVar1,local_18);
    }
    else {
      *puVar1 = local_18[0];
      param_2[1] = param_2[1] + 1;
    }
    lVar4 = lVar4 + 1;
    lVar3 = lVar3 + -1;
  } while (lVar3 != 0);
  return param_2;
}


==================================================================

### EXPORT FUNC 18000ac80 (1424 bytes) name=FUN_18000ac80

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

void FUN_18000ac80(longlong param_1,longlong param_2,int param_3)

{
  longlong *plVar1;
  undefined1 uVar2;
  byte bVar3;
  undefined8 *puVar4;
  bool bVar5;
  char cVar6;
  ulonglong uVar7;
  undefined8 uVar8;
  longlong lVar9;
  char *pcVar10;
  int iVar11;
  uint uVar12;
  longlong lVar13;
  ulonglong uVar14;
  void *_Memory;
  char *pcVar15;
  int iVar16;
  void **ppvVar17;
  char cVar18;
  uint uVar19;
  undefined8 *puVar20;
  void **ppvVar21;
  void **ppvVar22;
  void **ppvVar23;
  void **ppvVar24;
  char cVar25;
  byte bVar26;
  char cVar27;
  void **ppvVar28;
  longlong lVar29;
  undefined1 auStack_98 [32];
  byte local_78 [8];
  longlong local_70;
  longlong local_68;
  void *local_60;
  void **ppvStack_58;
  void **local_50;
  char *local_48;
  longlong lStack_40;
  longlong local_38;
  ulonglong local_30;
  
  local_30 = DAT_180015010 ^ (ulonglong)auStack_98;
  lVar29 = 0;
  local_70 = param_2;
  local_68 = param_1;
  if (0 < param_3) {
    lVar13 = *(longlong *)(param_1 + 0x58);
    do {
      uVar2 = *(undefined1 *)(lVar29 + local_70);
      uVar7 = *(ulonglong *)(param_1 + 0x50);
      if ((((int)lVar13 + (int)uVar7 & 0xfU) == 0) &&
         (*(ulonglong *)(param_1 + 0x48) <= lVar13 + 0x10U >> 4)) {
        FUN_1800028d0(param_1 + 0x38);
        uVar7 = *(ulonglong *)(param_1 + 0x50);
        lVar13 = *(longlong *)(param_1 + 0x58);
      }
      uVar7 = *(longlong *)(param_1 + 0x48) * 0x10 - 1U & uVar7;
      *(ulonglong *)(param_1 + 0x50) = uVar7;
      uVar7 = uVar7 + lVar13;
      lVar9 = *(longlong *)(param_1 + 0x40);
      lVar13 = (*(longlong *)(param_1 + 0x48) - 1U & uVar7 >> 4) * 8;
      if (*(longlong *)(lVar13 + lVar9) == 0) {
        uVar8 = FUN_18000c554(0x10);
        *(undefined8 *)(lVar13 + *(longlong *)(param_1 + 0x40)) = uVar8;
        lVar9 = *(longlong *)(param_1 + 0x40);
      }
      *(undefined1 *)((ulonglong)((uint)uVar7 & 0xf) + *(longlong *)(lVar13 + lVar9)) = uVar2;
      *(longlong *)(param_1 + 0x58) = *(longlong *)(param_1 + 0x58) + 1;
      lVar13 = *(longlong *)(param_1 + 0x58);
      lVar29 = lVar29 + 1;
    } while (lVar29 < param_3);
  }
  uVar12 = *(uint *)(param_1 + 0x58);
  do {
    if ((int)uVar12 < 9) {
      return;
    }
    ppvVar17 = (void **)0x0;
    local_48 = (char *)0x0;
    lStack_40 = 0;
    local_38 = 0;
    FUN_18000abd0(param_1,(longlong *)&local_48);
    if (*local_48 == DAT_180010101) {
      uVar7 = lStack_40 - (longlong)local_48;
      iVar11 = (int)uVar7 + -1;
      cVar18 = '\0';
      cVar6 = '\0';
      cVar25 = '\0';
      cVar27 = '\0';
      iVar16 = (int)uVar7;
      if ((ulonglong)(longlong)iVar11 <= uVar7) {
        iVar16 = iVar11;
      }
      lVar29 = (longlong)iVar16;
      if (0 < iVar16) {
        ppvVar23 = ppvVar17;
        if (lVar29 < 2) {
LAB_18000ae17:
          cVar6 = local_48[(longlong)ppvVar23];
        }
        else {
          do {
            cVar25 = cVar25 + local_48[(longlong)ppvVar23];
            cVar27 = cVar27 + (local_48 + 1)[(longlong)ppvVar23];
            ppvVar23 = (void **)((longlong)ppvVar23 + 2);
          } while ((longlong)ppvVar23 < lVar29 + -1);
          if ((longlong)ppvVar23 < lVar29) goto LAB_18000ae17;
        }
        cVar18 = cVar6 + cVar25 + cVar27;
      }
      if (local_48[uVar7 - 1] != cVar18) goto LAB_18000aee2;
      uVar19 = CONCAT11(local_48[1],local_48[2]) + 4;
      if (uVar12 < uVar19) {
        if (local_48 == (char *)0x0) {
          return;
        }
        pcVar15 = local_48;
        if (((ulonglong)(local_38 - (longlong)local_48) < 0x1000) ||
           (pcVar15 = *(char **)(local_48 + -8), local_48 + (-8 - (longlong)pcVar15) < (char *)0x20)
           ) {
          free(pcVar15);
          return;
        }
        goto LAB_18000b158;
      }
      iVar16 = 4;
      bVar26 = 0;
      uVar12 = CONCAT11(local_48[1],local_48[2]) - 1;
      if (0 < (int)uVar12) {
        uVar7 = (ulonglong)uVar12;
        do {
          uVar14 = (longlong)iVar16 + *(longlong *)(param_1 + 0x50);
          bVar26 = bVar26 + *(char *)((ulonglong)((uint)uVar14 & 0xf) +
                                     *(longlong *)
                                      (*(longlong *)(param_1 + 0x40) +
                                      (uVar14 >> 4 & *(longlong *)(param_1 + 0x48) - 1U) * 8));
          iVar16 = iVar16 + 1;
          uVar7 = uVar7 - 1;
        } while (uVar7 != 0);
      }
      ppvVar24 = *(void ***)(param_1 + 0x50);
      ppvVar23 = (void **)(ulonglong)((uint)(byte *)((longlong)iVar16 + (longlong)ppvVar24) & 0xf);
      bVar3 = *(byte *)((longlong)ppvVar23 +
                       *(longlong *)
                        (*(longlong *)(param_1 + 0x40) +
                        (*(longlong *)(param_1 + 0x48) - 1U &
                        (ulonglong)((longlong)iVar16 + (longlong)ppvVar24) >> 4) * 8));
      if (bVar26 != bVar3) {
        if (DAT_180015ff0 != '\0') {
          FUN_180007960("checksum not same:%.2x, %.2x",(ulonglong)bVar26,(ulonglong)bVar3,ppvVar24);
        }
        goto LAB_18000aee2;
      }
      local_60 = (void *)0x0;
      ppvStack_58 = (void **)0x0;
      local_50 = (void **)0x0;
      ppvVar22 = ppvVar17;
      if (uVar19 != 0) {
        uVar7 = (ulonglong)uVar19;
        do {
          local_78[0] = *(byte *)((ulonglong)((uint)ppvVar24 & 0xf) +
                                 *(longlong *)
                                  (*(longlong *)(param_1 + 0x40) +
                                  (*(longlong *)(param_1 + 0x48) - 1U & (ulonglong)ppvVar24 >> 4) *
                                  8));
          if (ppvStack_58 == local_50) {
            ppvVar22 = (void **)local_78;
            FUN_180007d30((longlong *)&local_60,ppvStack_58,(undefined1 *)ppvVar22);
          }
          else {
            *(byte *)ppvStack_58 = local_78[0];
            ppvStack_58 = (void **)((longlong)ppvStack_58 + 1);
            ppvVar22 = local_50;
          }
          plVar1 = (longlong *)(param_1 + 0x58);
          *plVar1 = *plVar1 + -1;
          if (*plVar1 == 0) {
            *(undefined8 *)(param_1 + 0x50) = 0;
            ppvVar24 = ppvVar17;
          }
          else {
            *(longlong *)(param_1 + 0x50) = *(longlong *)(param_1 + 0x50) + 1;
            ppvVar24 = *(void ***)(param_1 + 0x50);
          }
          uVar7 = uVar7 - 1;
          ppvVar23 = ppvStack_58;
        } while (uVar7 != 0);
      }
      ppvVar28 = (void **)(ulonglong)*(byte *)((longlong)local_60 + 4);
      local_78[0] = *(byte *)((longlong)local_60 + 5);
      ppvVar21 = (void **)(ulonglong)local_78[0];
      uVar12 = (uint)CONCAT11(*(undefined1 *)((longlong)local_60 + 6),
                              *(undefined1 *)((longlong)local_60 + 7));
      if (DAT_180015ff0 != '\0') {
        FUN_180007960("\nRecv:",ppvVar23,ppvVar22,ppvVar24);
        ppvVar23 = ppvVar17;
        if ((int)ppvStack_58 != (int)local_60 && -1 < (int)ppvStack_58 - (int)local_60) {
          do {
            FUN_180007960("%.2X ",(ulonglong)*(byte *)((longlong)local_60 + (longlong)ppvVar17),
                          ppvVar22,ppvVar24);
            uVar19 = (int)ppvVar23 + 1;
            ppvVar17 = (void **)((longlong)ppvVar17 + 1);
            ppvVar23 = (void **)(ulonglong)uVar19;
          } while ((int)uVar19 < (int)ppvStack_58 - (int)local_60);
        }
        ppvVar24 = (void **)(ulonglong)uVar12;
        ppvVar23 = ppvVar28;
        FUN_180007960("Main:%.2X Sub:%.2X Frame:%d \n",ppvVar28,ppvVar21,ppvVar24);
        ppvVar22 = ppvVar21;
      }
      bVar26 = local_78[0];
      DAT_180015038 = 1;
      if (uVar12 + 1 < 0x8000) {
        DAT_180015038 = uVar12 + 1;
      }
      bVar5 = false;
      puVar4 = *(undefined8 **)(param_1 + 0x68);
      puVar20 = *(undefined8 **)(param_1 + 0x60);
      if (puVar20 == puVar4) {
LAB_18000b079:
        FUN_180007960("Unhandled:",ppvVar23,ppvVar22,ppvVar24);
        iVar16 = 0;
        lVar29 = 0;
        if ((int)ppvStack_58 != (int)local_60 && -1 < (int)ppvStack_58 - (int)local_60) {
          do {
            FUN_180007960("%.2X ",(ulonglong)*(byte *)((longlong)local_60 + lVar29),ppvVar22,
                          ppvVar24);
            iVar16 = iVar16 + 1;
            lVar29 = lVar29 + 1;
          } while (iVar16 < (int)ppvStack_58 - (int)local_60);
        }
        FUN_180007960("Main:%.2X Sub:%.2X Frame:%d \n",ppvVar28,(ulonglong)local_78[0],
                      (ulonglong)uVar12);
      }
      else {
        do {
          plVar1 = (longlong *)*puVar20;
          ppvVar22 = (void **)(ulonglong)bVar26;
          ppvVar23 = ppvVar28;
          cVar6 = (**(code **)*plVar1)(plVar1);
          if (cVar6 != '\0') {
            bVar5 = true;
            ppvVar23 = &local_60;
            (**(code **)(*plVar1 + 8))(plVar1);
          }
          puVar20 = puVar20 + 1;
        } while (puVar20 != puVar4);
        param_1 = local_68;
        if (!bVar5) goto LAB_18000b079;
      }
      if (local_60 != (void *)0x0) {
        _Memory = local_60;
        if ((0xfff < (ulonglong)((longlong)local_50 - (longlong)local_60)) &&
           (_Memory = *(void **)((longlong)local_60 + -8),
           0x1f < (ulonglong)((longlong)local_60 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
          _invalid_parameter_noinfo_noreturn();
        }
        free(_Memory);
        local_60 = (void *)0x0;
        ppvStack_58 = (void **)0x0;
        local_50 = (void **)0x0;
      }
      if (local_48 != (char *)0x0) {
        pcVar15 = local_48;
        if (0xfff < (ulonglong)(local_38 - (longlong)local_48)) {
          pcVar15 = *(char **)(local_48 + -8);
          pcVar10 = local_48 + (-8 - (longlong)pcVar15);
          goto joined_r0x00018000b18e;
        }
        goto LAB_18000b193;
      }
    }
    else {
LAB_18000aee2:
      plVar1 = (longlong *)(param_1 + 0x58);
      *plVar1 = *plVar1 + -1;
      if (*plVar1 == 0) {
        *(undefined8 *)(param_1 + 0x50) = 0;
      }
      else {
        *(longlong *)(param_1 + 0x50) = *(longlong *)(param_1 + 0x50) + 1;
      }
      if (local_48 != (char *)0x0) {
        pcVar15 = local_48;
        if (0xfff < (ulonglong)(local_38 - (longlong)local_48)) {
          pcVar15 = *(char **)(local_48 + -8);
          pcVar10 = local_48 + (-8 - (longlong)pcVar15);
joined_r0x00018000b18e:
          if ((char *)0x1f < pcVar10) {
LAB_18000b158:
                    /* WARNING: Subroutine does not return */
            _invalid_parameter_noinfo_noreturn();
          }
        }
LAB_18000b193:
        free(pcVar15);
      }
    }
    uVar12 = *(uint *)(param_1 + 0x58);
  } while( true );
}


==================================================================

### EXPORT FUNC 18000b220 (91 bytes) name=FID_conflict:~vector<CHN*___ptr64,std::allocator<CHN*___ptr64>_>

/* Library Function - Multiple Matches With Different Base Names
    public: __cdecl std::priority_queue<unsigned __int64,class std::vector<unsigned __int64,struct
   std::_Parallelism_allocator<unsigned __int64> >,struct std::greater<void>
   >::~priority_queue<unsigned __int64,class std::vector<unsigned __int64,struct
   std::_Parallelism_allocator<unsigned __int64> >,struct std::greater<void> >(void) __ptr64
    public: __cdecl std::vector<struct CHN * __ptr64,class std::allocator<struct CHN * __ptr64>
   >::~vector<struct CHN * __ptr64,class std::allocator<struct CHN * __ptr64> >(void) __ptr64
    public: __cdecl std::vector<unsigned __int64,struct std::_Parallelism_allocator<unsigned
   __int64> >::~vector<unsigned __int64,struct std::_Parallelism_allocator<unsigned __int64> >(void)
   __ptr64
    public: __cdecl std::vector<unsigned __int64,class std::allocator<unsigned __int64>
   >::~vector<unsigned __int64,class std::allocator<unsigned __int64> >(void) __ptr64
     7 names - too many to list
   
   Library: Visual Studio 2019 Release */

void FID_conflict__vector<CHN*___ptr64,std::allocator<CHN*___ptr64>_>(longlong *param_1)

{
  void *pvVar1;
  void *_Memory;
  
  pvVar1 = (void *)*param_1;
  if (pvVar1 != (void *)0x0) {
    _Memory = pvVar1;
    if ((0xfff < (param_1[2] - (longlong)pvVar1 & 0xfffffffffffffff8U)) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
    *param_1 = 0;
    param_1[1] = 0;
    param_1[2] = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 18000b280 (397 bytes) name=FUN_18000b280

undefined8 * FUN_18000b280(longlong *param_1,void *param_2,undefined8 *param_3)

{
  ulonglong uVar1;
  undefined8 *puVar2;
  longlong lVar3;
  void *pvVar4;
  longlong lVar5;
  ulonglong uVar6;
  ulonglong uVar7;
  undefined8 *_Dst;
  void *_Memory;
  undefined8 *_Dst_00;
  size_t _Size;
  
  lVar3 = *param_1;
  lVar5 = param_1[1] - lVar3 >> 3;
  if (lVar5 == 0x1fffffffffffffff) {
                    /* WARNING: Subroutine does not return */
    FUN_180002b80();
  }
  uVar7 = param_1[2] - lVar3 >> 3;
  uVar1 = lVar5 + 1;
  uVar6 = uVar1;
  if ((uVar7 <= 0x1fffffffffffffff - (uVar7 >> 1)) && (uVar6 = (uVar7 >> 1) + uVar7, uVar6 < uVar1))
  {
    uVar6 = uVar1;
  }
  if (0x1fffffffffffffff < uVar6) {
LAB_18000b40a:
                    /* WARNING: Subroutine does not return */
    FUN_180001750();
  }
  uVar7 = uVar6 * 8;
  if (uVar7 < 0x1000) {
    if (uVar7 == 0) {
      _Dst_00 = (undefined8 *)0x0;
    }
    else {
      _Dst_00 = (undefined8 *)FUN_18000c554(uVar7);
    }
  }
  else {
    if (uVar7 + 0x27 <= uVar7) goto LAB_18000b40a;
    lVar5 = FUN_18000c554(uVar7 + 0x27);
    if (lVar5 == 0) goto LAB_18000b3fd;
    _Dst_00 = (undefined8 *)(lVar5 + 0x27U & 0xffffffffffffffe0);
    _Dst_00[-1] = lVar5;
  }
  puVar2 = _Dst_00 + ((longlong)param_2 - lVar3 >> 3);
  *puVar2 = *param_3;
  pvVar4 = (void *)*param_1;
  if (param_2 == (void *)param_1[1]) {
    _Size = param_1[1] - (longlong)pvVar4;
    _Dst = _Dst_00;
    param_2 = pvVar4;
  }
  else {
    memmove(_Dst_00,pvVar4,(longlong)param_2 - (longlong)pvVar4);
    _Dst = puVar2 + 1;
    _Size = param_1[1] - (longlong)param_2;
  }
  memmove(_Dst,param_2,_Size);
  pvVar4 = (void *)*param_1;
  if (pvVar4 != (void *)0x0) {
    _Memory = pvVar4;
    if ((0xfff < (param_1[2] - (longlong)pvVar4 & 0xfffffffffffffff8U)) &&
       (_Memory = *(void **)((longlong)pvVar4 + -8),
       0x1f < (ulonglong)((longlong)pvVar4 + (-8 - (longlong)_Memory)))) {
LAB_18000b3fd:
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  *param_1 = (longlong)_Dst_00;
  param_1[1] = (longlong)(_Dst_00 + uVar1);
  param_1[2] = (longlong)(_Dst_00 + uVar6);
  return puVar2;
}


==================================================================

### EXPORT FUNC 18000b410 (123 bytes) name=FUN_18000b410

undefined8 * FUN_18000b410(undefined8 *param_1)

{
  undefined8 *puVar1;
  undefined8 *puVar2;
  
  puVar1 = param_1 + 1;
  *param_1 = TCMVirtualDevice::vftable;
  *puVar1 = 0;
  param_1[2] = 0;
  param_1[3] = 0;
  param_1[4] = 0;
  param_1[5] = 0;
  puVar2 = (undefined8 *)FUN_18000c554(0x10);
  puVar2[1] = 0;
  *puVar1 = puVar2;
  *puVar2 = puVar1;
  _Cnd_init_in_situ(param_1 + 7);
  _Mtx_init_in_situ(param_1 + 0x10,2);
  param_1[0x1a] = 0;
  return param_1;
}


==================================================================

### EXPORT FUNC 18000b490 (3 bytes) name=_guard_check_icall

void _guard_check_icall(void)

{
  return;
}


==================================================================

### EXPORT FUNC 18000b4a0 (3 bytes) name=FUN_18000b4a0

undefined1 FUN_18000b4a0(void)

{
  return 0;
}


==================================================================

### EXPORT FUNC 18000b4b0 (116 bytes) name=FUN_18000b4b0

void FUN_18000b4b0(undefined8 param_1,undefined4 param_2,undefined8 param_3,undefined8 param_4,
                  int param_5,longlong param_6)

{
  if (param_5 == 2) {
    *(undefined4 *)(param_6 + 0x240) = param_2;
    MAG_GetOutputBMPdataRGB24
              (*(undefined4 *)(param_6 + 0x18),*(undefined8 *)(param_6 + 0x220),
               *(undefined4 *)(param_6 + 0x218),1);
    if (*(code **)(param_6 + 0x228) != (code *)0x0) {
                    /* WARNING: Could not recover jumptable at 0x00018000b517. Too many branches */
                    /* WARNING: Treating indirect jump as call */
      (**(code **)(param_6 + 0x228))
                (*(undefined8 *)(param_6 + 0x220),*(undefined4 *)(param_6 + 0x208),
                 *(undefined4 *)(param_6 + 0x20c),3);
      return;
    }
  }
  return;
}


==================================================================

### EXPORT FUNC 18000b530 (442 bytes) name=FUN_18000b530

undefined8 * FUN_18000b530(void)

{
  undefined8 *puVar1;
  undefined8 *_Dst;
  undefined8 *puVar2;
  longlong lVar3;
  
  _Dst = DAT_180015ff8;
  if (DAT_180015ff8 == (undefined8 *)0x0) {
    _Dst = (undefined8 *)FUN_18000c554(0x2b0);
    memset(_Dst,0,0x2b0);
    *_Dst = ThermalController::vftable;
    *(int *)(_Dst + 1) = 0;
    _Dst[2] = 0;
    *(undefined4 *)(_Dst + 3) = 0xffffffff;
    _Dst[0x3e] = 0;
    *(undefined4 *)(_Dst + 0x3f) = 0;
    *(undefined8 *)((longlong)_Dst + 0x1c) = 0;
    *(undefined8 *)((longlong)_Dst + 0x24) = 0;
    *(undefined8 *)((longlong)_Dst + 0x2c) = 0;
    *(undefined8 *)((longlong)_Dst + 0x34) = 0;
    *(undefined8 *)((longlong)_Dst + 0x3c) = 0;
    *(undefined8 *)((longlong)_Dst + 0x44) = 0;
    *(undefined8 *)((longlong)_Dst + 0x4c) = 0;
    *(undefined8 *)((longlong)_Dst + 0x54) = 0;
    *(undefined8 *)((longlong)_Dst + 0x5c) = 0;
    FUN_1800015d0((int *)(_Dst + 1));
    _Dst[0x44] = 0;
    _Dst[0x45] = 0;
    _Dst[0x47] = 0;
    *(undefined4 *)((longlong)_Dst + 0x27c) = 0;
    _Dst[0x48] = 0;
    _Dst[0x49] = 0x3fef5c28f5c28f5c;
    _Dst[0x53] = 0;
    _Dst[0x54] = 0xffffffffffffffff;
    _Dst[0x51] = 0x4040000000000000;
    _Dst[0x52] = 0x4044000000000000;
    _Dst[0x50] = 0x4042800000000000;
    *(undefined2 *)(_Dst + 0x55) = 0;
    if (DAT_180015fe8 == (undefined8 *)0x0) {
      puVar2 = (undefined8 *)FUN_18000c554(0x78);
      *puVar2 = 0;
      puVar2[1] = 0;
      puVar2[2] = 0;
      puVar2[3] = 0;
      puVar2[4] = 0;
      puVar2[5] = 0;
      puVar2[6] = 0;
      puVar2[7] = 0;
      puVar2[8] = 0;
      puVar2[9] = 0;
      puVar2[10] = 0;
      puVar2[0xb] = 0;
      puVar2[0xc] = 0;
      puVar2[0xd] = 0;
      puVar2[0xe] = 0;
      DAT_180015fe8 = FUN_18000a510(puVar2);
    }
    puVar2 = DAT_180015fe8;
    _Dst[0x46] = DAT_180015fe8;
    puVar1 = (undefined8 *)puVar2[0xd];
    for (puVar2 = (undefined8 *)puVar2[0xc]; puVar2 != puVar1; puVar2 = puVar2 + 1) {
      lVar3 = __RTDynamicCast(*puVar2,0,&TCMVirtualDevice::RTTI_Type_Descriptor,
                              &EloProximityDevice::RTTI_Type_Descriptor,0);
      if (lVar3 != 0) {
        *(undefined8 **)(lVar3 + 0xd8) = _Dst;
        DAT_180015ff8 = _Dst;
        return _Dst;
      }
    }
  }
  DAT_180015ff8 = _Dst;
  return _Dst;
}


==================================================================

### EXPORT FUNC 18000b6f0 (425 bytes) name=FUN_18000b6f0

undefined8 FUN_18000b6f0(longlong param_1,undefined4 *param_2,undefined *param_3,undefined8 param_4)

{
  undefined4 *puVar1;
  undefined1 uVar2;
  int iVar3;
  undefined8 uVar4;
  ulonglong uVar5;
  uint7 uVar6;
  code *pcVar7;
  
  if (*(int *)(param_1 + 8) != 0) {
    MAG_EnumCameras(*(undefined4 *)(param_1 + 0x18));
    Sleep(0x32);
    if (*(int *)(param_1 + 8) != 0) {
      param_2 = (undefined4 *)0x0;
      iVar3 = MAG_GetTerminalList(0);
      if (iVar3 != 0) {
        param_2 = (undefined4 *)0x0;
        param_3 = (code *)0x3e8;
        iVar3 = MAG_LinkCamera(*(undefined4 *)(param_1 + 0x18));
        if (iVar3 != 0) {
          puVar1 = (undefined4 *)(param_1 + 0x1c);
          param_3 = (code *)0x48;
          param_2 = puVar1;
          MAG_GetCamInfo(*(undefined4 *)(param_1 + 0x18));
          if (puVar1 != (undefined4 *)0x0) {
            *(undefined4 *)(param_1 + 0x200) = *puVar1;
            *(undefined4 *)(param_1 + 0x204) = *(undefined4 *)(param_1 + 0x20);
            *(undefined4 *)(param_1 + 0x208) = *(undefined4 *)(param_1 + 0x5c);
            *(undefined4 *)(param_1 + 0x20c) = *(undefined4 *)(param_1 + 0x60);
            *(undefined4 *)(param_1 + 0x210) = 0x10;
            *(undefined4 *)(param_1 + 0x214) = *(undefined4 *)(param_1 + 0x60);
            MAG_GetFixPara(*(undefined4 *)(param_1 + 0x18),param_1 + 0x250);
            *(undefined4 *)(param_1 + 0x250) = 0x3f266666;
            *(float *)(param_1 + 0x254) = (float)*(double *)(param_1 + 0x248);
            MAG_SetFixPara(*(undefined4 *)(param_1 + 0x18),param_1 + 0x250,2);
            iVar3 = *(int *)(param_1 + 0x208) * *(int *)(param_1 + 0x20c) * 3;
            *(int *)(param_1 + 0x218) = iVar3;
            uVar4 = thunk_FUN_18000c554((longlong)iVar3);
            pcVar7 = FUN_18000b4b0;
            param_4 = 2;
            *(undefined8 *)(param_1 + 0x220) = uVar4;
            param_2 = (undefined4 *)(param_1 + 0x200);
            iVar3 = MAG_StartProcessImage(*(undefined4 *)(param_1 + 0x18));
            if (iVar3 != 0) {
              param_2 = (undefined4 *)0x2;
              MAG_SetColorPalette(*(undefined4 *)(param_1 + 0x18));
              uVar2 = 1;
              param_3 = pcVar7;
              goto LAB_18000b84d;
            }
            MAG_DisLinkCamera();
            param_3 = pcVar7;
          }
        }
      }
    }
  }
  uVar2 = 0;
LAB_18000b84d:
  *(undefined1 *)(param_1 + 0x2a8) = uVar2;
  uVar5 = FUN_18000a960(*(longlong *)(param_1 + 0x230),param_2,param_3,param_4);
  *(char *)(param_1 + 0x2a9) = (char)uVar5;
  uVar6 = (uint7)(uVar5 >> 8);
  if ((*(char *)(param_1 + 0x2a8) != '\0') && ((char)uVar5 != '\0')) {
    return CONCAT71(uVar6,1);
  }
  return (ulonglong)uVar6 << 8;
}


==================================================================

### EXPORT FUNC 18000b8a0 (177 bytes) name=FUN_18000b8a0

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000b8a0(longlong param_1,int param_2)

{
  DWORD DVar1;
  float fVar2;
  
  *(int *)(param_1 + 0x2a0) = param_2;
  if (*(code **)(param_1 + 0x238) != (code *)0x0) {
    fVar2 = (float)param_2;
    if (param_2 < 0) {
      (**(code **)(param_1 + 0x238))(fVar2);
      DVar1 = GetTickCount();
      if ((60000 < DVar1 - *(int *)(param_1 + 0x244)) && (5000 < DVar1 - *(int *)(param_1 + 0x2a4)))
      {
        if (*(int *)(param_1 + 8) != 0) {
          MAG_TriggerFFC(*(undefined4 *)(param_1 + 0x18));
        }
        DVar1 = GetTickCount();
        *(DWORD *)(param_1 + 0x244) = DVar1;
        return;
      }
    }
    else {
      DVar1 = GetTickCount();
      *(DWORD *)(param_1 + 0x2a4) = DVar1;
      if (*(int *)(param_1 + 0x27c) != 0) {
        fVar2 = fVar2 * _DAT_1800101e0;
      }
      (**(code **)(param_1 + 0x238))(fVar2);
    }
  }
  return;
}


==================================================================

### EXPORT FUNC 18000b960 (460 bytes) name=FUN_18000b960

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

double * FUN_18000b960(longlong param_1,double *param_2,uint param_3,uint param_4)

{
  double dVar1;
  undefined4 uVar2;
  int iVar3;
  int iVar4;
  uint uVar5;
  int iVar6;
  int iVar7;
  float fVar8;
  double dVar9;
  double dVar10;
  
  if ((param_3 < 0xa0) && (param_4 < 0x78)) {
    uVar2 = MAG_GetTemperatureProbe(*(undefined4 *)(param_1 + 0x18),param_3,param_4,3);
    iVar3 = MAG_FixTemperature(*(undefined4 *)(param_1 + 0x18),uVar2);
    iVar4 = 0;
    if (-1 < (int)(param_3 - 1)) {
      iVar4 = param_3 - 1;
    }
    iVar7 = 0x9f;
    if ((int)(param_3 + 1) < 0x9f) {
      iVar7 = param_3 + 1;
    }
    iVar6 = 0;
    if (-1 < (int)(param_4 - 1)) {
      iVar6 = param_4 - 1;
    }
    dVar10 = (double)iVar3 * _DAT_1800101e8;
    iVar3 = 0x77;
    if ((int)(param_4 + 1) < 0x77) {
      iVar3 = param_4 + 1;
    }
    iVar3 = MAG_EstimateUnderArmTempFromForeheadRect
                      (*(undefined4 *)(param_1 + 0x18),iVar4,iVar6,iVar7,iVar3);
    iVar4 = *(int *)(param_1 + 0x27c);
    dVar9 = (double)iVar3 * _DAT_1800101e8;
    if (iVar4 == 1) {
      dVar10 = dVar10 * _DAT_1800101f0 + _DAT_1800101f8;
      dVar9 = dVar9 * _DAT_1800101f0 + _DAT_1800101f8;
    }
    dVar1 = *(double *)(param_1 + 0x298);
    dVar9 = dVar9 + dVar1;
    if ((*(double *)(param_1 + 0x290) <= dVar9 && dVar9 != *(double *)(param_1 + 0x290)) ||
       (dVar9 < *(double *)(param_1 + 0x288))) {
      uVar5 = 0xffffffff;
    }
    else {
      uVar5 = (uint)(*(double *)(param_1 + 0x280) <= dVar9);
    }
    *(uint *)((longlong)param_2 + 0x24) = uVar5;
    *(int *)(param_2 + 4) = iVar4;
    fVar8 = (float)(int)param_4 / _DAT_180010200;
    *param_2 = (double)((float)(int)param_3 / _DAT_180010204);
    param_2[2] = dVar10 + dVar1;
    param_2[1] = (double)fVar8;
    param_2[3] = dVar9;
  }
  else {
    *(undefined4 *)((longlong)param_2 + 0x24) = 0xfa0a1f00;
    *param_2 = -1.0;
    param_2[1] = -1.0;
    param_2[3] = -100000000.0;
    param_2[2] = -100000000.0;
    *(undefined4 *)(param_2 + 4) = *(undefined4 *)(param_1 + 0x27c);
  }
  return param_2;
}


==================================================================

### EXPORT FUNC 18000bb30 (6 bytes) name=GetSDKVersion

undefined8 GetSDKVersion(void)

{
                    /* 0xbb30  2  GetSDKVersion */
  return 10000;
}


==================================================================

### EXPORT FUNC 18000bb40 (21 bytes) name=Start

void Start(undefined8 param_1,undefined4 *param_2,undefined *param_3,undefined8 param_4)

{
  undefined8 *puVar1;
  
                    /* 0xbb40  16  Start */
  puVar1 = FUN_18000b530();
  FUN_18000b6f0((longlong)puVar1,param_2,param_3,param_4);
  return;
}


==================================================================

### EXPORT FUNC 18000bb60 (152 bytes) name=Stop

void Stop(void)

{
  int iVar1;
  undefined8 *puVar2;
  
                    /* 0xbb60  18  Stop */
  puVar2 = FUN_18000b530();
  iVar1 = MAG_IsProcessingImage(*(undefined4 *)(puVar2 + 3));
  if (iVar1 != 0) {
    if (*(int *)(puVar2 + 0x3e) != 0) {
      MAG_LocalStorageAviStop(*(undefined4 *)(puVar2 + 3));
      *(undefined4 *)(puVar2 + 0x3e) = 0;
    }
    if (*(int *)((longlong)puVar2 + 500) != 0) {
      MAG_LocalStorageMgsStop(*(undefined4 *)(puVar2 + 3));
      *(undefined8 *)((longlong)puVar2 + 500) = 0;
    }
    MAG_StopProcessImage(*(undefined4 *)(puVar2 + 3));
  }
  iVar1 = MAG_IsLinked(*(undefined4 *)(puVar2 + 3));
  if (iVar1 != 0) {
    MAG_DisLinkCamera(*(undefined4 *)(puVar2 + 3));
  }
  *(undefined1 *)(puVar2 + 0x55) = 0;
  (**(code **)(*(longlong *)(puVar2[0x46] + 8) + 0x20))();
  *(undefined1 *)((longlong)puVar2 + 0x2a9) = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000bc00 (41 bytes) name=IsWorking

undefined8 IsWorking(void)

{
  undefined8 *puVar1;
  uint7 uVar2;
  
                    /* 0xbc00  4  IsWorking */
  puVar1 = FUN_18000b530();
  uVar2 = (uint7)((ulonglong)puVar1 >> 8);
  if ((*(char *)(puVar1 + 0x55) != '\0') && (*(char *)((longlong)puVar1 + 0x2a9) != '\0')) {
    return CONCAT71(uVar2,1);
  }
  return (ulonglong)uVar2 << 8;
}


==================================================================

### EXPORT FUNC 18000bc30 (27 bytes) name=SetNewIRFrameDelegate

void SetNewIRFrameDelegate(undefined8 param_1)

{
  undefined8 *puVar1;
  
                    /* 0xbc30  11  SetNewIRFrameDelegate */
  puVar1 = FUN_18000b530();
  puVar1[0x45] = param_1;
  return;
}


==================================================================

### EXPORT FUNC 18000bc50 (27 bytes) name=SetNewDistanceDelegate

void SetNewDistanceDelegate(undefined8 param_1)

{
  undefined8 *puVar1;
  
                    /* 0xbc50  10  SetNewDistanceDelegate */
  puVar1 = FUN_18000b530();
  puVar1[0x47] = param_1;
  return;
}


==================================================================

### EXPORT FUNC 18000bc70 (122 bytes) name=ReadTemperatureAtPoint

void ReadTemperatureAtPoint(uint param_1,uint param_2,double *param_3)

{
  undefined8 *puVar1;
  double local_38;
  double dStack_30;
  double local_28;
  double dStack_20;
  double local_18;
  
                    /* 0xbc70  5  ReadTemperatureAtPoint */
  puVar1 = FUN_18000b530();
  MAG_LockFrame(*(undefined4 *)(puVar1 + 3));
  FUN_18000b960((longlong)puVar1,&local_38,param_1,param_2);
  MAG_UnLockFrame(*(undefined4 *)(puVar1 + 3));
  *param_3 = local_38;
  param_3[1] = dStack_30;
  param_3[2] = local_28;
  param_3[3] = dStack_20;
  param_3[4] = local_18;
  return;
}


==================================================================

### EXPORT FUNC 18000bcf0 (361 bytes) name=ReadTemperatureInRect

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void ReadTemperatureInRect(int param_1,int param_2,int param_3,int param_4,undefined4 *param_5)

{
  int iVar1;
  char cVar2;
  undefined8 *puVar3;
  uint uVar4;
  undefined1 auStack_c8 [32];
  int local_a8;
  undefined8 *local_a0;
  undefined4 local_98;
  undefined4 uStack_94;
  undefined4 uStack_90;
  undefined4 uStack_8c;
  undefined4 local_88;
  undefined4 uStack_84;
  undefined4 uStack_80;
  undefined4 uStack_7c;
  undefined4 local_78;
  undefined4 uStack_74;
  undefined8 local_70;
  undefined8 uStack_68;
  int local_60;
  ulonglong local_58;
  
                    /* 0xbcf0  6  ReadTemperatureInRect */
  local_58 = DAT_180015010 ^ (ulonglong)auStack_c8;
  puVar3 = FUN_18000b530();
  MAG_LockFrame(*(undefined4 *)(puVar3 + 3));
  local_60 = 0;
  local_a8 = 0;
  if (-1 < param_2) {
    local_a8 = param_2;
  }
  local_70 = 0;
  uStack_68 = 0;
  iVar1 = local_a8 + param_4;
  if (0x77 < local_a8 + param_4) {
    iVar1 = 0x77;
  }
  local_a8 = 0x77 - local_a8;
  local_a0 = &local_70;
  cVar2 = MAG_GetRectTemperatureInfo
                    (*(undefined4 *)(puVar3 + 3),param_1,0x77 - iVar1,param_3 + param_1);
  if (cVar2 == '\0') {
    local_78 = *(undefined4 *)((longlong)puVar3 + 0x27c);
    local_88 = _DAT_180010220;
    uStack_84 = _UNK_180010224;
    uStack_80 = _UNK_180010228;
    uStack_7c = _UNK_18001022c;
    uStack_74 = 0xfa0a1f00;
    local_98 = _DAT_180010210;
    uStack_94 = _UNK_180010214;
    uStack_90 = _UNK_180010218;
    uStack_8c = _UNK_18001021c;
  }
  else {
    iVar1 = local_60 / 0xa0;
    uVar4 = local_60 % 0xa0;
    local_a8 = iVar1;
    MAG_FixTemperature(*(undefined4 *)(puVar3 + 3),local_70._4_4_,
                       *(undefined4 *)((longlong)puVar3 + 0x254),uVar4);
    FUN_18000b960((longlong)puVar3,(double *)&local_98,uVar4,0x78 - iVar1);
  }
  MAG_UnLockFrame(*(undefined4 *)(puVar3 + 3));
  *param_5 = local_98;
  param_5[1] = uStack_94;
  param_5[2] = uStack_90;
  param_5[3] = uStack_8c;
  *(ulonglong *)(param_5 + 4) = CONCAT44(uStack_84,local_88);
  *(ulonglong *)(param_5 + 6) = CONCAT44(uStack_7c,uStack_80);
  *(ulonglong *)(param_5 + 8) = CONCAT44(uStack_74,local_78);
  return;
}


==================================================================

### EXPORT FUNC 18000be60 (81 bytes) name=SetTempBoundary

void SetTempBoundary(undefined8 param_1,undefined8 param_2,undefined8 param_3)

{
  undefined8 *puVar1;
  
                    /* 0xbe60  12  SetTempBoundary */
  puVar1 = FUN_18000b530();
  puVar1[0x51] = param_1;
  puVar1[0x52] = param_2;
  puVar1[0x50] = param_3;
  return;
}


==================================================================

### EXPORT FUNC 18000bec0 (35 bytes) name=SetTempOffset

void SetTempOffset(undefined8 param_1)

{
  undefined8 *puVar1;
  
                    /* 0xbec0  13  SetTempOffset */
  puVar1 = FUN_18000b530();
  puVar1[0x53] = param_1;
  return;
}


==================================================================

### EXPORT FUNC 18000bef0 (25 bytes) name=SetUnitMode

void SetUnitMode(undefined4 param_1)

{
  undefined8 *puVar1;
  
                    /* 0xbef0  14  SetUnitMode */
  puVar1 = FUN_18000b530();
  *(undefined4 *)((longlong)puVar1 + 0x27c) = param_1;
  return;
}


==================================================================

### EXPORT FUNC 18000bf10 (124 bytes) name=Rotate

void Rotate(int param_1)

{
  undefined8 *puVar1;
  longlong lVar2;
  undefined8 *puVar3;
  
                    /* 0xbf10  7  Rotate */
  puVar1 = FUN_18000b530();
  puVar3 = *(undefined8 **)(puVar1[0x46] + 0x60);
  puVar1 = *(undefined8 **)(puVar1[0x46] + 0x68);
  while( true ) {
    if (puVar3 == puVar1) {
      return;
    }
    lVar2 = __RTDynamicCast(*puVar3,0,&TCMVirtualDevice::RTTI_Type_Descriptor,
                            &EloMotorDevice::RTTI_Type_Descriptor,0);
    if (lVar2 != 0) break;
    puVar3 = puVar3 + 1;
  }
  FUN_180007a40(lVar2,param_1);
  return;
}


==================================================================

### EXPORT FUNC 18000bf90 (59 bytes) name=GetInnerIRCameraTemp

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

double GetInnerIRCameraTemp(void)

{
  undefined8 *puVar1;
  double dVar2;
  
                    /* 0xbf90  1  GetInnerIRCameraTemp */
  puVar1 = FUN_18000b530();
  dVar2 = (double)*(int *)(puVar1 + 0x48) * _DAT_1800101e8;
  if (*(int *)((longlong)puVar1 + 0x27c) == 1) {
    dVar2 = dVar2 * _DAT_1800101f0 + _DAT_1800101f8;
  }
  return dVar2;
}


==================================================================

### EXPORT FUNC 18000bfd0 (88 bytes) name=SetEmissivity

void SetEmissivity(double param_1)

{
  undefined8 *puVar1;
  
                    /* 0xbfd0  8  SetEmissivity */
  puVar1 = FUN_18000b530();
  if (*(int *)(puVar1 + 1) == 0) {
    puVar1[0x49] = param_1;
    return;
  }
  *(float *)((longlong)puVar1 + 0x254) = (float)param_1;
                    /* WARNING: Could not recover jumptable at 0x00018000c021. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  MAG_SetFixPara(*(undefined4 *)(puVar1 + 3),puVar1 + 0x4a,2);
  return;
}


==================================================================

### EXPORT FUNC 18000c030 (47 bytes) name=Trigger

void Trigger(void)

{
  DWORD DVar1;
  undefined8 *puVar2;
  
                    /* 0xc030  19  Trigger */
  puVar2 = FUN_18000b530();
  if (*(int *)(puVar2 + 1) != 0) {
    MAG_TriggerFFC(*(undefined4 *)(puVar2 + 3));
  }
  DVar1 = GetTickCount();
  *(DWORD *)((longlong)puVar2 + 0x244) = DVar1;
  return;
}


==================================================================

### EXPORT FUNC 18000c060 (255 bytes) name=GetTCMVersion

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
/* WARNING: Type propagation algorithm not settling */

void GetTCMVersion(void *param_1)

{
  undefined8 *puVar1;
  longlong lVar2;
  undefined8 *******pppppppuVar3;
  undefined8 *puVar4;
  TypeDescriptor *pTVar5;
  TypeDescriptor *pTVar6;
  undefined1 auStack_68 [32];
  undefined4 local_48;
  undefined8 *******local_38 [2];
  int local_28;
  ulonglong local_20;
  ulonglong local_18;
  
                    /* 0xc060  3  GetTCMVersion */
  local_18 = DAT_180015010 ^ (ulonglong)auStack_68;
  puVar1 = FUN_18000b530();
  puVar4 = *(undefined8 **)(puVar1[0x46] + 0x60);
  puVar1 = *(undefined8 **)(puVar1[0x46] + 0x68);
  while( true ) {
    if (puVar4 == puVar1) {
      return;
    }
    pTVar6 = &EloTCMUpdaterDevice::RTTI_Type_Descriptor;
    pTVar5 = &TCMVirtualDevice::RTTI_Type_Descriptor;
    local_48 = 0;
    lVar2 = __RTDynamicCast(*puVar4,0);
    if (lVar2 != 0) break;
    puVar4 = puVar4 + 1;
  }
  FUN_180009000(lVar2,local_38,pTVar5,(longlong)pTVar6);
  pppppppuVar3 = local_38;
  if (0xf < local_20) {
    pppppppuVar3 = local_38[0];
  }
  memcpy(param_1,pppppppuVar3,(longlong)local_28);
  if (local_20 < 0x10) {
    return;
  }
  pppppppuVar3 = local_38[0];
  if ((0xfff < local_20 + 1) &&
     (pppppppuVar3 = (undefined8 *******)local_38[0][-1],
     0x1f < (ulonglong)((longlong)local_38[0] + (-8 - (longlong)pppppppuVar3)))) {
                    /* WARNING: Subroutine does not return */
    _invalid_parameter_noinfo_noreturn();
  }
  free(pppppppuVar3);
  return;
}


==================================================================

### EXPORT FUNC 18000c160 (405 bytes) name=SetFirmwareData

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */

void SetFirmwareData(void *param_1,int param_2)

{
  void *_Src;
  longlong lVar1;
  undefined8 *puVar2;
  longlong lVar3;
  undefined8 *puVar4;
  void *pvVar5;
  ulonglong _Size;
  void **ppvVar6;
  undefined1 auStack_78 [32];
  undefined4 local_58;
  void *local_48;
  undefined8 uStack_40;
  longlong local_38;
  ulonglong local_30;
  
                    /* 0xc160  9  SetFirmwareData */
  local_30 = DAT_180015010 ^ (ulonglong)auStack_78;
  _Size = (ulonglong)param_2;
  puVar2 = FUN_18000b530();
  puVar4 = *(undefined8 **)(puVar2[0x46] + 0x60);
  puVar2 = *(undefined8 **)(puVar2[0x46] + 0x68);
  while( true ) {
    if (puVar4 == puVar2) {
      return;
    }
    local_58 = 0;
    lVar3 = __RTDynamicCast(*puVar4,0,&TCMVirtualDevice::RTTI_Type_Descriptor,
                            &EloTCMUpdaterDevice::RTTI_Type_Descriptor);
    if (lVar3 != 0) break;
    puVar4 = puVar4 + 1;
  }
  local_38 = 0;
  local_48 = (void *)0x0;
  uStack_40 = 0;
  if (param_2 != 0) {
    if (0x7fffffffffffffff < _Size) {
                    /* WARNING: Subroutine does not return */
      FUN_180002b80();
    }
    FUN_18000c470((longlong *)&local_48,_Size);
  }
  if ((ulonglong)(local_38 - (longlong)local_48) < _Size) {
    FUN_180002ba0((ulonglong *)&local_48,_Size);
  }
  lVar1 = local_38;
  _Src = local_48;
  memmove(local_48,param_1,_Size);
  ppvVar6 = (void **)(lVar3 + 0x100);
  if (ppvVar6 != &local_48) {
    pvVar5 = *ppvVar6;
    if ((ulonglong)(*(longlong *)(lVar3 + 0x110) - (longlong)pvVar5) < _Size) {
      FUN_180002ba0((ulonglong *)ppvVar6,_Size);
      pvVar5 = *ppvVar6;
    }
    memmove(pvVar5,_Src,_Size);
    *(ulonglong *)(lVar3 + 0x108) = (longlong)pvVar5 + _Size;
  }
  if (_Src == (void *)0x0) {
    return;
  }
  pvVar5 = _Src;
  if ((0xfff < (ulonglong)(lVar1 - (longlong)_Src)) &&
     (pvVar5 = *(void **)((longlong)_Src + -8),
     0x1f < (ulonglong)((longlong)_Src + (-8 - (longlong)pvVar5)))) {
                    /* WARNING: Subroutine does not return */
    _invalid_parameter_noinfo_noreturn();
  }
  free(pvVar5);
  return;
}


==================================================================

### EXPORT FUNC 18000c300 (122 bytes) name=SetUpdateCallback

void SetUpdateCallback(undefined8 param_1)

{
  undefined8 *puVar1;
  longlong lVar2;
  undefined8 *puVar3;
  
                    /* 0xc300  15  SetUpdateCallback */
  puVar1 = FUN_18000b530();
  puVar3 = *(undefined8 **)(puVar1[0x46] + 0x60);
  puVar1 = *(undefined8 **)(puVar1[0x46] + 0x68);
  while( true ) {
    if (puVar3 == puVar1) {
      return;
    }
    lVar2 = __RTDynamicCast(*puVar3,0,&TCMVirtualDevice::RTTI_Type_Descriptor,
                            &EloTCMUpdaterDevice::RTTI_Type_Descriptor,0);
    if (lVar2 != 0) break;
    puVar3 = puVar3 + 1;
  }
  *(undefined8 *)(lVar2 + 0xd8) = param_1;
  return;
}


==================================================================

### EXPORT FUNC 18000c380 (227 bytes) name=StartUpdate

void StartUpdate(void)

{
  code *pcVar1;
  undefined8 *puVar2;
  longlong lVar3;
  longlong *_ArgList;
  uintptr_t uVar4;
  undefined8 *puVar5;
  uint uStack_10;
  undefined4 uStack_c;
  
                    /* 0xc380  17  StartUpdate */
  puVar2 = FUN_18000b530();
  puVar5 = *(undefined8 **)(puVar2[0x46] + 0x60);
  puVar2 = *(undefined8 **)(puVar2[0x46] + 0x68);
  while( true ) {
    if (puVar5 == puVar2) {
      return;
    }
    lVar3 = __RTDynamicCast(*puVar5,0,&TCMVirtualDevice::RTTI_Type_Descriptor,
                            &EloTCMUpdaterDevice::RTTI_Type_Descriptor,0);
    if (lVar3 != 0) break;
    puVar5 = puVar5 + 1;
  }
  _ArgList = (longlong *)FUN_18000c554(0x10);
  _ArgList[1] = (longlong)FUN_1800091e0;
  *_ArgList = lVar3;
  uVar4 = _beginthreadex((void *)0x0,0,FUN_180007930,_ArgList,0,&uStack_10);
  if (uVar4 != 0) {
    if (*(int *)(lVar3 + 0x120) == 0) {
      *(uintptr_t *)(lVar3 + 0x118) = uVar4;
      *(ulonglong *)(lVar3 + 0x120) = CONCAT44(uStack_c,uStack_10);
      return;
    }
                    /* WARNING: Subroutine does not return */
    terminate();
  }
  uStack_10 = 0;
  std::_Throw_Cpp_error(6);
  pcVar1 = (code *)swi(3);
  (*pcVar1)();
  return;
}


==================================================================

### EXPORT FUNC 18000c470 (161 bytes) name=FUN_18000c470

void FUN_18000c470(longlong *param_1,ulonglong param_2)

{
  longlong lVar1;
  longlong lVar2;
  longlong lVar3;
  void *_Dst;
  
  lVar1 = param_1[1];
  lVar2 = *param_1;
  if (param_2 < 0x1000) {
    if (param_2 == 0) {
      _Dst = (void *)0x0;
    }
    else {
      _Dst = (void *)FUN_18000c554(param_2);
    }
  }
  else {
    if (param_2 + 0x27 <= param_2) {
                    /* WARNING: Subroutine does not return */
      FUN_180001750();
    }
    lVar3 = FUN_18000c554(param_2 + 0x27);
    if (lVar3 == 0) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    _Dst = (void *)(lVar3 + 0x27U & 0xffffffffffffffe0);
    *(longlong *)((longlong)_Dst - 8) = lVar3;
  }
  memmove(_Dst,(void *)*param_1,param_1[1] - *param_1);
  FUN_180007280(param_1,(longlong)_Dst,lVar1 - lVar2,param_2);
  return;
}


==================================================================

### EXPORT FUNC 18000c530 (33 bytes) name=__security_check_cookie

/* WARNING: This is an inlined function */
/* Library Function - Single Match
    __security_check_cookie
   
   Libraries: Visual Studio 2015, Visual Studio 2017, Visual Studio 2019 */

void __cdecl __security_check_cookie(uintptr_t _StackCookie)

{
  if ((_StackCookie == DAT_180015010) && ((short)(_StackCookie >> 0x30) == 0)) {
    return;
  }
                    /* WARNING: Subroutine does not return */
  __report_gsfailure(_StackCookie);
}


==================================================================

### EXPORT FUNC 18000c554 (58 bytes) name=FUN_18000c554

void FUN_18000c554(size_t param_1)

{
  int iVar1;
  void *pvVar2;
  
  do {
    pvVar2 = malloc(param_1);
    if (pvVar2 != (void *)0x0) {
      return;
    }
    iVar1 = _callnewh(param_1);
  } while (iVar1 != 0);
  if (param_1 == 0xffffffffffffffff) {
                    /* WARNING: Subroutine does not return */
    FUN_180001750();
  }
                    /* WARNING: Subroutine does not return */
  FUN_18000d200();
}


==================================================================

### EXPORT FUNC 18000c590 (57 bytes) name=__scrt_acquire_startup_lock

/* Library Function - Single Match
    __scrt_acquire_startup_lock
   
   Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release, Visual Studio 2019 Release */

ulonglong __scrt_acquire_startup_lock(void)

{
  ulonglong uVar1;
  bool bVar2;
  undefined7 extraout_var;
  ulonglong uVar3;
  
  bVar2 = __scrt_is_ucrt_dll_in_use();
  uVar3 = CONCAT71(extraout_var,bVar2);
  if ((int)uVar3 == 0) {
LAB_18000c5be:
    uVar3 = uVar3 & 0xffffffffffffff00;
  }
  else {
    do {
      uVar3 = 0;
      LOCK();
      bVar2 = DAT_1800159a8 == 0;
      uVar1 = *(ulonglong *)((longlong)Self + 8);
      if (!bVar2) {
        uVar3 = DAT_1800159a8;
        uVar1 = DAT_1800159a8;
      }
      DAT_1800159a8 = uVar1;
      UNLOCK();
      if (bVar2) goto LAB_18000c5be;
    } while (*(ulonglong *)((longlong)Self + 8) != uVar3);
    uVar3 = CONCAT71((int7)(uVar3 >> 8),1);
  }
  return uVar3;
}


==================================================================

### EXPORT FUNC 18000c5cc (52 bytes) name=__scrt_dllmain_after_initialize_c

/* Library Function - Single Match
    __scrt_dllmain_after_initialize_c
   
   Library: Visual Studio 2019 Release */

undefined8 __scrt_dllmain_after_initialize_c(void)

{
  bool bVar1;
  undefined7 extraout_var;
  undefined8 uVar2;
  ulonglong uVar3;
  
  bVar1 = __scrt_is_ucrt_dll_in_use();
  if ((int)CONCAT71(extraout_var,bVar1) == 0) {
    uVar3 = FUN_180001540();
    uVar3 = _configure_narrow_argv(uVar3 & 0xffffffff);
    if ((int)uVar3 != 0) {
      return uVar3 & 0xffffffffffffff00;
    }
    uVar2 = _initialize_narrow_environment();
  }
  else {
    uVar2 = __isa_available_init();
  }
  return CONCAT71((int7)((ulonglong)uVar2 >> 8),1);
}


==================================================================

### EXPORT FUNC 18000c600 (21 bytes) name=FUN_18000c600

bool FUN_18000c600(void)

{
  undefined8 uVar1;
  
  uVar1 = FUN_18000c748(0);
  return (char)uVar1 != '\0';
}


==================================================================

### EXPORT FUNC 18000c618 (40 bytes) name=FUN_18000c618

undefined1 FUN_18000c618(void)

{
  char cVar1;
  
  cVar1 = FUN_18000d750();
  if (cVar1 != '\0') {
    cVar1 = FUN_18000d750();
    if (cVar1 != '\0') {
      return 1;
    }
    FUN_18000d750();
  }
  return 0;
}


==================================================================

### EXPORT FUNC 18000c640 (21 bytes) name=FUN_18000c640

undefined1 FUN_18000c640(void)

{
  FUN_18000d750();
  FUN_18000d750();
  return 1;
}


==================================================================

### EXPORT FUNC 18000c658 (96 bytes) name=__scrt_dllmain_exception_filter

/* Library Function - Single Match
    __scrt_dllmain_exception_filter
   
   Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release */

void __scrt_dllmain_exception_filter
               (undefined8 param_1,int param_2,undefined8 param_3,undefined *param_4,
               undefined4 param_5,undefined8 param_6)

{
  bool bVar1;
  undefined7 extraout_var;
  
  bVar1 = __scrt_is_ucrt_dll_in_use();
  if (((int)CONCAT71(extraout_var,bVar1) == 0) && (param_2 == 1)) {
    (*(code *)PTR__guard_dispatch_icall_18000f4d8)(param_1,0,param_3);
  }
  _seh_filter_dll(param_5,param_6);
  return;
}


==================================================================

### EXPORT FUNC 18000c6b8 (48 bytes) name=__scrt_dllmain_uninitialize_c

/* Library Function - Single Match
    __scrt_dllmain_uninitialize_c
   
   Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release, Visual Studio 2019 Release */

void __scrt_dllmain_uninitialize_c(void)

{
  bool bVar1;
  undefined7 extraout_var;
  undefined8 uVar2;
  
  bVar1 = __scrt_is_ucrt_dll_in_use();
  if ((int)CONCAT71(extraout_var,bVar1) != 0) {
    _execute_onexit_table(&DAT_1800159b8);
    return;
  }
  uVar2 = FUN_18000d754();
  if ((int)uVar2 == 0) {
    _cexit();
  }
  return;
}


==================================================================

### EXPORT FUNC 18000c6e8 (20 bytes) name=FUN_18000c6e8

void FUN_18000c6e8(void)

{
  FUN_18000d750();
  FUN_18000d750();
  return;
}


==================================================================

### EXPORT FUNC 18000c6fc (73 bytes) name=__scrt_initialize_crt

/* Library Function - Single Match
    __scrt_initialize_crt
   
   Library: Visual Studio 2019 Release */

longlong __scrt_initialize_crt(int param_1)

{
  char cVar1;
  uint7 extraout_var;
  uint7 uVar2;
  undefined7 extraout_var_00;
  uint7 extraout_var_01;
  
  if (param_1 == 0) {
    DAT_1800159b0 = 1;
  }
  __isa_available_init();
  cVar1 = FUN_18000d750();
  uVar2 = extraout_var;
  if (cVar1 != '\0') {
    cVar1 = FUN_18000d750();
    if (cVar1 != '\0') {
      return CONCAT71(extraout_var_00,1);
    }
    FUN_18000d750();
    uVar2 = extraout_var_01;
  }
  return (ulonglong)uVar2 << 8;
}


==================================================================

### EXPORT FUNC 18000c748 (138 bytes) name=FUN_18000c748

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

undefined8 FUN_18000c748(uint param_1)

{
  bool bVar1;
  ulonglong in_RAX;
  undefined7 extraout_var;
  
  if (DAT_1800159b1 == '\0') {
    if (1 < param_1) {
                    /* WARNING: Subroutine does not return */
      __scrt_fastfail(5);
    }
    bVar1 = __scrt_is_ucrt_dll_in_use();
    if (((int)CONCAT71(extraout_var,bVar1) == 0) || (param_1 != 0)) {
      in_RAX = 0xffffffffffffffff;
      DAT_1800159b8 = _DAT_18000f5f0;
      uRam00000001800159c0 = _UNK_18000f5f8;
      _DAT_1800159c8 = 0xffffffffffffffff;
      _DAT_1800159d0 = _DAT_18000f5f0;
      uRam00000001800159d8 = _UNK_18000f5f8;
      _DAT_1800159e0 = 0xffffffffffffffff;
    }
    else {
      in_RAX = _initialize_onexit_table(&DAT_1800159b8);
      if (((int)in_RAX != 0) ||
         (in_RAX = _initialize_onexit_table(&DAT_1800159d0), (int)in_RAX != 0)) {
        return in_RAX & 0xffffffffffffff00;
      }
    }
    DAT_1800159b1 = '\x01';
  }
  return CONCAT71((int7)(in_RAX >> 8),1);
}


==================================================================

### EXPORT FUNC 18000c7d4 (150 bytes) name=__scrt_is_nonwritable_in_current_image

/* Library Function - Single Match
    __scrt_is_nonwritable_in_current_image
   
   Library: Visual Studio 2019 Release */

ulonglong __scrt_is_nonwritable_in_current_image(longlong param_1)

{
  ulonglong uVar1;
  uint7 uVar2;
  longlong lVar3;
  longlong lVar4;
  
  uVar1 = 0x5a4d;
  if (((IMAGE_DOS_HEADER_180000000.e_magic == (char  [2])0x5a4d) &&
      (lVar3 = (longlong)(int)IMAGE_DOS_HEADER_180000000.e_lfanew,
      *(int *)(lVar3 + 0x180000000) == 0x4550)) &&
     (uVar1 = 0x20b, *(short *)((longlong)IMAGE_DOS_HEADER_180000000.e_res_4_ + lVar3 + -4) == 0x20b
     )) {
    lVar4 = lVar3 + 0x180000018 +
            (ulonglong)*(ushort *)((longlong)IMAGE_DOS_HEADER_180000000.e_res_4_ + lVar3 + -8);
    uVar1 = (ulonglong)*(ushort *)(IMAGE_DOS_HEADER_180000000.e_magic + lVar3 + 6);
    lVar3 = lVar4 + uVar1 * 0x28;
    for (; lVar4 != lVar3; lVar4 = lVar4 + 0x28) {
      if (((ulonglong)*(uint *)(lVar4 + 0xc) <= param_1 - 0x180000000U) &&
         (uVar1 = (ulonglong)(*(int *)(lVar4 + 8) + *(uint *)(lVar4 + 0xc)),
         param_1 - 0x180000000U < uVar1)) goto LAB_18000c84a;
    }
    lVar4 = 0;
LAB_18000c84a:
    if (lVar4 == 0) {
      uVar1 = uVar1 & 0xffffffffffffff00;
    }
    else {
      uVar2 = (uint7)(uVar1 >> 8);
      if (*(int *)(lVar4 + 0x24) < 0) {
        uVar1 = (ulonglong)uVar2 << 8;
      }
      else {
        uVar1 = CONCAT71(uVar2,1);
      }
    }
  }
  else {
    uVar1 = uVar1 & 0xffffffffffffff00;
  }
  return uVar1;
}


==================================================================

### EXPORT FUNC 18000c86c (36 bytes) name=__scrt_release_startup_lock

/* Library Function - Single Match
    __scrt_release_startup_lock
   
   Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release, Visual Studio 2019 Release */

void __scrt_release_startup_lock(char param_1)

{
  bool bVar1;
  undefined3 extraout_var;
  
  bVar1 = __scrt_is_ucrt_dll_in_use();
  if ((CONCAT31(extraout_var,bVar1) != 0) && (param_1 == '\0')) {
    LOCK();
    DAT_1800159a8 = 0;
    UNLOCK();
  }
  return;
}


==================================================================

### EXPORT FUNC 18000c890 (41 bytes) name=__scrt_uninitialize_crt

/* Library Function - Single Match
    __scrt_uninitialize_crt
   
   Library: Visual Studio 2019 Release */

undefined1 __scrt_uninitialize_crt(undefined8 param_1,char param_2)

{
  if ((DAT_1800159b0 == '\0') || (param_2 == '\0')) {
    FUN_18000d750();
    FUN_18000d750();
  }
  return 1;
}


==================================================================

### EXPORT FUNC 18000c8bc (58 bytes) name=_onexit

/* Library Function - Single Match
    _onexit
   
   Library: Visual Studio 2019 Release */

_onexit_t __cdecl _onexit(_onexit_t _Func)

{
  int iVar1;
  _onexit_t p_Var2;
  
  if (DAT_1800159b8 == -1) {
    iVar1 = _crt_atexit();
  }
  else {
    iVar1 = _register_onexit_function(&DAT_1800159b8);
  }
  p_Var2 = (_onexit_t)0x0;
  if (iVar1 == 0) {
    p_Var2 = _Func;
  }
  return p_Var2;
}


==================================================================

### EXPORT FUNC 18000c8f8 (23 bytes) name=atexit

/* Library Function - Single Match
    atexit
   
   Library: Visual Studio 2019 Release */

int __cdecl atexit(_func_5014 *param_1)

{
  _onexit_t p_Var1;
  
  p_Var1 = _onexit((_onexit_t)param_1);
  return (p_Var1 != (_onexit_t)0x0) - 1;
}


==================================================================

### EXPORT FUNC 18000c910 (5 bytes) name=free

void __cdecl free(void *_Memory)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d742. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  free(_Memory);
  return;
}


==================================================================

### EXPORT FUNC 18000c918 (43 bytes) name=FUN_18000c918

undefined8 * FUN_18000c918(undefined8 *param_1,ulonglong param_2)

{
  *param_1 = type_info::vftable;
  if ((param_2 & 1) != 0) {
    free(param_1);
  }
  return param_1;
}


==================================================================

### EXPORT FUNC 18000c944 (52 bytes) name=__raise_securityfailure

/* Library Function - Single Match
    __raise_securityfailure
   
   Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release, Visual Studio 2019 Release */

void __raise_securityfailure(_EXCEPTION_POINTERS *param_1)

{
  HANDLE pvVar1;
  
  SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)0x0);
  UnhandledExceptionFilter(param_1);
  pvVar1 = GetCurrentProcess();
                    /* WARNING: Could not recover jumptable at 0x00018000c971. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  TerminateProcess(pvVar1,0xc0000409);
  return;
}


==================================================================

### EXPORT FUNC 18000c978 (209 bytes) name=__report_gsfailure

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* Library Function - Single Match
    __report_gsfailure
   
   Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release, Visual Studio 2019 Release */

void __cdecl __report_gsfailure(uintptr_t _StackCookie)

{
  code *pcVar1;
  BOOL BVar2;
  undefined1 *puVar3;
  undefined1 auStack_38 [8];
  undefined1 auStack_30 [48];
  
  puVar3 = auStack_38;
  BVar2 = IsProcessorFeaturePresent(0x17);
  if (BVar2 != 0) {
    pcVar1 = (code *)swi(0x29);
    (*pcVar1)(2);
    puVar3 = auStack_30;
  }
  *(undefined8 *)(puVar3 + -8) = 0x18000c9a2;
  capture_previous_context((PCONTEXT)&DAT_180015a90);
  _DAT_180015a00 = *(undefined8 *)(puVar3 + 0x38);
  _DAT_180015b28 = puVar3 + 0x40;
  _DAT_180015b10 = *(undefined8 *)(puVar3 + 0x40);
  _DAT_1800159f0 = 0xc0000409;
  _DAT_1800159f4 = 1;
  _DAT_180015a08 = 1;
  DAT_180015a10 = 2;
  *(undefined8 *)(puVar3 + 0x20) = DAT_180015010;
  *(undefined8 *)(puVar3 + 0x28) = DAT_180015008;
  *(undefined8 *)(puVar3 + -8) = 0x18000ca44;
  DAT_180015b88 = _DAT_180015a00;
  __raise_securityfailure((_EXCEPTION_POINTERS *)&PTR_DAT_18000f610);
  return;
}


==================================================================

### EXPORT FUNC 18000ca4c (19 bytes) name=__report_rangecheckfailure

/* Library Function - Single Match
    __report_rangecheckfailure
   
   Libraries: Visual Studio 2012, Visual Studio 2015, Visual Studio 2017, Visual Studio 2019 */

void __report_rangecheckfailure(void)

{
  __report_securityfailure(8);
  return;
}


==================================================================

### EXPORT FUNC 18000ca60 (155 bytes) name=__report_securityfailure

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* Library Function - Single Match
    __report_securityfailure
   
   Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release, Visual Studio 2019 Release */

void __report_securityfailure(undefined4 param_1)

{
  code *pcVar1;
  BOOL BVar2;
  undefined1 *puVar3;
  undefined1 auStack_28 [8];
  undefined1 auStack_20 [32];
  
  puVar3 = auStack_28;
  BVar2 = IsProcessorFeaturePresent(0x17);
  if (BVar2 != 0) {
    pcVar1 = (code *)swi(0x29);
    (*pcVar1)(param_1);
    puVar3 = auStack_20;
  }
  *(undefined8 *)(puVar3 + -8) = 0x18000ca8a;
  capture_current_context((PCONTEXT)&DAT_180015a90);
  _DAT_180015a00 = *(undefined8 *)(puVar3 + 0x28);
  _DAT_180015b28 = puVar3 + 0x30;
  _DAT_1800159f0 = 0xc0000409;
  _DAT_1800159f4 = 1;
  _DAT_180015a08 = 1;
  DAT_180015a10 = (ulonglong)*(uint *)(puVar3 + 0x30);
  *(undefined8 *)(puVar3 + -8) = 0x18000caf6;
  DAT_180015b88 = _DAT_180015a00;
  __raise_securityfailure((_EXCEPTION_POINTERS *)&PTR_DAT_18000f610);
  return;
}


==================================================================

### EXPORT FUNC 18000cafc (109 bytes) name=capture_current_context

/* Library Function - Single Match
    capture_current_context
   
   Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release, Visual Studio 2019 Release */

void capture_current_context(PCONTEXT param_1)

{
  DWORD64 ControlPc;
  PRUNTIME_FUNCTION FunctionEntry;
  DWORD64 local_res8;
  ulonglong local_res10;
  PVOID local_res18;
  
  RtlCaptureContext();
  ControlPc = param_1->Rip;
  FunctionEntry = RtlLookupFunctionEntry(ControlPc,&local_res8,(PUNWIND_HISTORY_TABLE)0x0);
  if (FunctionEntry != (PRUNTIME_FUNCTION)0x0) {
    RtlVirtualUnwind(0,local_res8,ControlPc,FunctionEntry,param_1,&local_res18,&local_res10,
                     (PKNONVOLATILE_CONTEXT_POINTERS)0x0);
  }
  return;
}


==================================================================

### EXPORT FUNC 18000cb6c (113 bytes) name=capture_previous_context

/* Library Function - Single Match
    capture_previous_context
   
   Libraries: Visual Studio 2015 Release, Visual Studio 2017 Release, Visual Studio 2019 Release */

void capture_previous_context(PCONTEXT param_1)

{
  DWORD64 ControlPc;
  PRUNTIME_FUNCTION FunctionEntry;
  int iVar1;
  DWORD64 local_res8;
  ulonglong local_res10;
  PVOID local_res18 [2];
  
  RtlCaptureContext();
  ControlPc = param_1->Rip;
  iVar1 = 0;
  do {
    FunctionEntry = RtlLookupFunctionEntry(ControlPc,&local_res8,(PUNWIND_HISTORY_TABLE)0x0);
    if (FunctionEntry == (PRUNTIME_FUNCTION)0x0) {
      return;
    }
    RtlVirtualUnwind(0,local_res8,ControlPc,FunctionEntry,param_1,local_res18,&local_res10,
                     (PKNONVOLATILE_CONTEXT_POINTERS)0x0);
    iVar1 = iVar1 + 1;
  } while (iVar1 < 2);
  return;
}


==================================================================

### EXPORT FUNC 18000cbe0 (207 bytes) name=FUN_18000cbe0

undefined8 FUN_18000cbe0(void)

{
  HMODULE hModule;
  FARPROC pFVar1;
  FARPROC pFVar2;
  undefined8 uVar3;
  
  InitializeCriticalSectionAndSpinCount((LPCRITICAL_SECTION)&DAT_180015f70,4000);
  hModule = GetModuleHandleW(L"api-ms-win-core-synch-l1-2-0.dll");
  if ((hModule != (HMODULE)0x0) ||
     (hModule = GetModuleHandleW(L"kernel32.dll"), hModule != (HMODULE)0x0)) {
    pFVar1 = GetProcAddress(hModule,"SleepConditionVariableCS");
    pFVar2 = GetProcAddress(hModule,"WakeAllConditionVariable");
    if ((((pFVar1 != (FARPROC)0x0) && (pFVar2 != (FARPROC)0x0)) ||
        (DAT_180015f68 = CreateEventW((LPSECURITY_ATTRIBUTES)0x0,1,0,(LPCWSTR)0x0),
        pFVar1 = DAT_180015f98, pFVar2 = DAT_180015fa0, DAT_180015f68 != (HANDLE)0x0)) &&
       (DAT_180015fa0 = pFVar2, DAT_180015f98 = pFVar1, uVar3 = FUN_18000c748(0),
       (char)uVar3 != '\0')) {
      atexit(FUN_18000ccb0);
      return 0;
    }
  }
                    /* WARNING: Subroutine does not return */
  __scrt_fastfail(7);
}


==================================================================

### EXPORT FUNC 18000ccb0 (40 bytes) name=FUN_18000ccb0

void FUN_18000ccb0(void)

{
  DeleteCriticalSection((LPCRITICAL_SECTION)&DAT_180015f70);
  if (DAT_180015f68 != (HANDLE)0x0) {
    CloseHandle(DAT_180015f68);
  }
  return;
}


==================================================================

### EXPORT FUNC 18000ccd8 (48 bytes) name=_Init_thread_abort

/* Library Function - Single Match
    _Init_thread_abort
   
   Library: Visual Studio 2019 Release */

void _Init_thread_abort(undefined4 *param_1)

{
  EnterCriticalSection((LPCRITICAL_SECTION)&DAT_180015f70);
  *param_1 = 0;
  LeaveCriticalSection((LPCRITICAL_SECTION)&DAT_180015f70);
  _Init_thread_notify();
  return;
}


==================================================================

### EXPORT FUNC 18000cd08 (96 bytes) name=_Init_thread_footer

/* Library Function - Single Match
    _Init_thread_footer
   
   Library: Visual Studio 2019 Release */

void _Init_thread_footer(int *param_1)

{
  ulonglong uVar1;
  
  EnterCriticalSection((LPCRITICAL_SECTION)&DAT_180015f70);
  uVar1 = (ulonglong)_tls_index;
  DAT_180015004 = DAT_180015004 + 1;
  *param_1 = DAT_180015004;
  *(int *)(*(longlong *)((longlong)ThreadLocalStoragePointer + uVar1 * 8) + 4) = DAT_180015004;
  LeaveCriticalSection((LPCRITICAL_SECTION)&DAT_180015f70);
  _Init_thread_notify();
  return;
}


==================================================================

### EXPORT FUNC 18000cd68 (103 bytes) name=_Init_thread_header

/* Library Function - Single Match
    _Init_thread_header
   
   Library: Visual Studio 2019 Release */

void _Init_thread_header(int *param_1)

{
  EnterCriticalSection((LPCRITICAL_SECTION)&DAT_180015f70);
  do {
    if (*param_1 == 0) {
      *param_1 = -1;
LAB_18000cdbc:
                    /* WARNING: Could not recover jumptable at 0x00018000cdc8. Too many branches */
                    /* WARNING: Treating indirect jump as call */
      LeaveCriticalSection((LPCRITICAL_SECTION)&DAT_180015f70);
      return;
    }
    if (*param_1 != -1) {
      *(undefined4 *)
       (*(longlong *)((longlong)ThreadLocalStoragePointer + (ulonglong)_tls_index * 8) + 4) =
           DAT_180015004;
      goto LAB_18000cdbc;
    }
    _Init_thread_wait(100);
  } while( true );
}


==================================================================

### EXPORT FUNC 18000cdd0 (65 bytes) name=_Init_thread_notify

/* WARNING: Switch with 1 destination removed at 0x00018000cdeb */
/* Library Function - Single Match
    _Init_thread_notify
   
   Library: Visual Studio 2019 Release */

void _Init_thread_notify(void)

{
  if (DAT_180015fa0 == (code *)0x0) {
    SetEvent(DAT_180015f68);
                    /* WARNING: Could not recover jumptable at 0x00018000ce0a. Too many branches */
                    /* WARNING: Treating indirect jump as call */
    ResetEvent(DAT_180015f68);
    return;
  }
                    /* WARNING: Could not recover jumptable at 0x00018000d890. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  (*DAT_180015fa0)(&DAT_180015f60);
  return;
}


==================================================================

### EXPORT FUNC 18000ce14 (99 bytes) name=_Init_thread_wait

/* WARNING: Switch with 1 destination removed at 0x00018000ce3e */
/* Library Function - Single Match
    _Init_thread_wait
   
   Library: Visual Studio 2019 Release */

void _Init_thread_wait(DWORD param_1)

{
  if (DAT_180015f98 == (code *)0x0) {
    LeaveCriticalSection((LPCRITICAL_SECTION)&DAT_180015f70);
    WaitForSingleObjectEx(DAT_180015f68,param_1,0);
                    /* WARNING: Could not recover jumptable at 0x00018000ce70. Too many branches */
                    /* WARNING: Treating indirect jump as call */
    EnterCriticalSection((LPCRITICAL_SECTION)&DAT_180015f70);
    return;
  }
                    /* WARNING: Could not recover jumptable at 0x00018000d890. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  (*DAT_180015f98)(&DAT_180015f60,&DAT_180015f70,param_1);
  return;
}


==================================================================

### EXPORT FUNC 18000ce78 (5 bytes) name=thunk_FUN_18000c554

void thunk_FUN_18000c554(size_t param_1)

{
  int iVar1;
  void *pvVar2;
  
  do {
    pvVar2 = malloc(param_1);
    if (pvVar2 != (void *)0x0) {
      return;
    }
    iVar1 = _callnewh(param_1);
  } while (iVar1 != 0);
  if (param_1 == 0xffffffffffffffff) {
                    /* WARNING: Subroutine does not return */
    FUN_180001750();
  }
                    /* WARNING: Subroutine does not return */
  FUN_18000d200();
}


==================================================================

### EXPORT FUNC 18000ce80 (80 bytes) name=FUN_18000ce80

ulonglong FUN_18000ce80(undefined8 param_1,int param_2,longlong param_3)

{
  byte bVar1;
  ulonglong uVar2;
  undefined7 extraout_var;
  
  if (param_2 == 0) {
    bVar1 = FUN_18000cfe8(CONCAT71((int7)((ulonglong)param_1 >> 8),param_3 != 0));
    return CONCAT71(extraout_var,bVar1);
  }
  if (param_2 != 1) {
    if (param_2 == 2) {
      bVar1 = FUN_18000c618();
    }
    else {
      if (param_2 != 3) {
        return 1;
      }
      bVar1 = FUN_18000c640();
    }
    return (ulonglong)bVar1;
  }
  uVar2 = FUN_18000ced0(param_1,param_3);
  return uVar2;
}


==================================================================

### EXPORT FUNC 18000ced0 (276 bytes) name=FUN_18000ced0

undefined8 FUN_18000ced0(undefined8 param_1,undefined8 param_2)

{
  bool bVar1;
  bool bVar2;
  int iVar3;
  undefined8 uVar4;
  undefined8 uVar5;
  longlong *plVar6;
  ulonglong uVar7;
  
  uVar4 = __scrt_initialize_crt(0);
  if ((char)uVar4 != '\0') {
    uVar4 = __scrt_acquire_startup_lock();
    bVar1 = true;
    if (DAT_1800159a0 != 0) {
                    /* WARNING: Subroutine does not return */
      __scrt_fastfail(7);
    }
    DAT_1800159a0 = 1;
    bVar2 = FUN_18000c600();
    if (bVar2) {
      FUN_18000d620();
      FUN_18000d5d8();
      FUN_18000d5fc();
      iVar3 = _initterm_e(&DAT_18000f5a0,&DAT_18000f5b0);
      if ((iVar3 == 0) && (uVar5 = __scrt_dllmain_after_initialize_c(), (char)uVar5 != '\0')) {
        _initterm(&DAT_18000f4e0,&DAT_18000f598);
        DAT_1800159a0 = 2;
        bVar1 = false;
      }
    }
    __scrt_release_startup_lock((char)uVar4);
    if (!bVar1) {
      plVar6 = (longlong *)FUN_18000d618();
      if ((*plVar6 != 0) &&
         (uVar7 = __scrt_is_nonwritable_in_current_image((longlong)plVar6), (char)uVar7 != '\0')) {
        (*(code *)PTR__guard_dispatch_icall_18000f4d8)(param_1,2,param_2);
      }
      DAT_180015fa8 = DAT_180015fa8 + 1;
      return 1;
    }
  }
  return 0;
}


==================================================================

### EXPORT FUNC 18000cfe8 (129 bytes) name=FUN_18000cfe8

byte FUN_18000cfe8(undefined8 param_1)

{
  undefined1 uVar1;
  char cVar2;
  undefined8 uVar3;
  undefined7 uVar4;
  byte bVar5;
  
  uVar1 = (undefined1)param_1;
  if (DAT_180015fa8 < 1) {
    bVar5 = 0;
  }
  else {
    DAT_180015fa8 = DAT_180015fa8 + -1;
    uVar3 = __scrt_acquire_startup_lock();
    if (DAT_1800159a0 != 2) {
                    /* WARNING: Subroutine does not return */
      __scrt_fastfail(7);
    }
    __scrt_dllmain_uninitialize_c();
    FUN_18000d5e8();
    FUN_18000d65c();
    DAT_1800159a0 = 0;
    uVar4 = (undefined7)((ulonglong)param_1 >> 8);
    __scrt_release_startup_lock((char)uVar3);
    cVar2 = __scrt_uninitialize_crt(CONCAT71(uVar4,uVar1),'\0');
    bVar5 = -(cVar2 != '\0') & 1;
    FUN_18000c6e8();
  }
  return bVar5;
}


==================================================================

### EXPORT FUNC 18000d06c (301 bytes) name=dllmain_dispatch

/* Library Function - Single Match
    int __cdecl dllmain_dispatch(struct HINSTANCE__ * __ptr64 const,unsigned long,void * __ptr64
   const)
   
   Library: Visual Studio 2017 Release */

int __cdecl dllmain_dispatch(HINSTANCE__ *param_1,ulong param_2,void *param_3)

{
  ulonglong uVar1;
  undefined8 uVar2;
  int iVar3;
  
  if ((param_2 == 0) && (DAT_180015fa8 < 1)) {
    iVar3 = 0;
  }
  else {
    if (param_2 - 1 < 2) {
      if ((DAT_18000f6c8 != 0) &&
         (iVar3 = (*(code *)PTR__guard_dispatch_icall_18000f4d8)(), iVar3 == 0)) {
        return 0;
      }
      uVar1 = FUN_18000ce80(param_1,param_2,(longlong)param_3);
      if ((int)uVar1 == 0) {
        return 0;
      }
    }
    uVar2 = FUN_180001540();
    iVar3 = (int)uVar2;
    if ((param_2 == 1) && (iVar3 == 0)) {
      FUN_180001540();
      FUN_18000ce80(param_1,0,(longlong)param_3);
      if (DAT_18000f6c8 != 0) {
        (*(code *)PTR__guard_dispatch_icall_18000f4d8)(param_1,0,param_3);
      }
    }
    if ((param_2 == 0) || (param_2 == 3)) {
      uVar1 = FUN_18000ce80(param_1,param_2,(longlong)param_3);
      iVar3 = 0;
      if ((int)uVar1 != 0) {
        if (DAT_18000f6c8 == 0) {
          iVar3 = 1;
        }
        else {
          iVar3 = (*(code *)PTR__guard_dispatch_icall_18000f4d8)(param_1,param_2,param_3);
        }
      }
    }
  }
  return iVar3;
}


==================================================================

### EXPORT FUNC 18000d1a0 (61 bytes) name=entry

void entry(HINSTANCE__ *param_1,ulong param_2,void *param_3)

{
  if (param_2 == 1) {
    __security_init_cookie();
  }
  dllmain_dispatch(param_1,param_2,param_3);
  return;
}


==================================================================

### EXPORT FUNC 18000d1e0 (30 bytes) name=FUN_18000d1e0

undefined8 * FUN_18000d1e0(undefined8 *param_1)

{
  param_1[2] = 0;
  param_1[1] = "bad allocation";
  *param_1 = std::bad_alloc::vftable;
  return param_1;
}


==================================================================

### EXPORT FUNC 18000d200 (31 bytes) name=FUN_18000d200

void FUN_18000d200(void)

{
  undefined8 local_28 [5];
  
  FUN_18000d1e0(local_28);
                    /* WARNING: Subroutine does not return */
  _CxxThrowException(local_28,(ThrowInfo *)&DAT_180013270);
}


==================================================================

### EXPORT FUNC 18000d220 (417 bytes) name=__isa_available_init

/* WARNING: Removing unreachable block (ram,0x00018000d2df) */
/* WARNING: Removing unreachable block (ram,0x00018000d25a) */
/* WARNING: Removing unreachable block (ram,0x00018000d233) */
/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */
/* Library Function - Single Match
    __isa_available_init
   
   Library: Visual Studio 2019 Release */

undefined8 __isa_available_init(void)

{
  int *piVar1;
  uint *puVar2;
  longlong lVar3;
  uint uVar4;
  undefined8 uVar5;
  byte bVar6;
  uint uVar7;
  uint uVar8;
  byte in_XCR0;
  
  piVar1 = (int *)cpuid_basic_info(0);
  uVar8 = 0;
  puVar2 = (uint *)cpuid_Version_info(1);
  uVar4 = puVar2[3];
  if ((piVar1[1] == 0x756e6547 && piVar1[3] == 0x6c65746e) && piVar1[2] == 0x49656e69) {
    _DAT_180015020 = 0xffffffffffffffff;
    uVar7 = *puVar2 & 0xfff3ff0;
    if ((((uVar7 == 0x106c0) || (uVar7 == 0x20660)) || (uVar7 == 0x20670)) ||
       ((uVar7 - 0x30650 < 0x21 &&
        ((0x100010001U >> ((ulonglong)(uVar7 - 0x30650) & 0x3f) & 1) != 0)))) {
      DAT_180015fac = DAT_180015fac | 1;
    }
  }
  if (6 < *piVar1) {
    lVar3 = cpuid_Extended_Feature_Enumeration_info(7);
    uVar8 = *(uint *)(lVar3 + 4);
    if ((uVar8 >> 9 & 1) != 0) {
      DAT_180015fac = DAT_180015fac | 2;
    }
  }
  _DAT_180015018 = 1;
  DAT_18001501c = 2;
  if ((uVar4 >> 0x14 & 1) != 0) {
    _DAT_180015018 = 2;
    DAT_18001501c = 6;
    if (((uVar4 >> 0x1b & 1) != 0) && ((uVar4 >> 0x1c & 1) != 0)) {
      uVar5 = xinuse(0);
      bVar6 = in_XCR0 & (byte)uVar5;
      if ((bVar6 & 6) == 6) {
        DAT_18001501c = 0xe;
        _DAT_180015018 = 3;
        if ((uVar8 & 0x20) != 0) {
          _DAT_180015018 = 5;
          DAT_18001501c = 0x2e;
          if (((uVar8 & 0xd0030000) == 0xd0030000) && ((bVar6 & 0xe0) == 0xe0)) {
            DAT_18001501c = 0x6e;
            _DAT_180015018 = 6;
          }
        }
      }
    }
  }
  return 0;
}


==================================================================

### EXPORT FUNC 18000d3c4 (12 bytes) name=__scrt_is_ucrt_dll_in_use

/* Library Function - Single Match
    __scrt_is_ucrt_dll_in_use
   
   Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release */

bool __scrt_is_ucrt_dll_in_use(void)

{
  return DAT_180015030 != 0;
}


==================================================================

### EXPORT FUNC 18000d3d0 (8 bytes) name=FUN_18000d3d0

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000d3d0(void)

{
  _DAT_180015fb0 = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000d3d8 (330 bytes) name=__scrt_fastfail

/* Library Function - Single Match
    __scrt_fastfail
   
   Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release */

void __scrt_fastfail(undefined4 param_1)

{
  code *pcVar1;
  BOOL BVar2;
  LONG LVar3;
  PRUNTIME_FUNCTION FunctionEntry;
  undefined1 *puVar4;
  undefined8 unaff_retaddr;
  DWORD64 local_res10;
  undefined1 local_res18 [8];
  undefined1 local_res20 [8];
  undefined1 auStack_5c8 [8];
  undefined1 auStack_5c0 [232];
  undefined1 local_4d8 [152];
  undefined1 *local_440;
  DWORD64 local_3e0;
  
  puVar4 = auStack_5c8;
  BVar2 = IsProcessorFeaturePresent(0x17);
  if (BVar2 != 0) {
    pcVar1 = (code *)swi(0x29);
    (*pcVar1)(param_1);
    puVar4 = auStack_5c0;
  }
  *(undefined8 *)(puVar4 + -8) = 0x18000d40b;
  FUN_18000d3d0();
  *(undefined8 *)(puVar4 + -8) = 0x18000d41c;
  memset(local_4d8,0,0x4d0);
  *(undefined8 *)(puVar4 + -8) = 0x18000d426;
  RtlCaptureContext(local_4d8);
  *(undefined8 *)(puVar4 + -8) = 0x18000d440;
  FunctionEntry = RtlLookupFunctionEntry(local_3e0,&local_res10,(PUNWIND_HISTORY_TABLE)0x0);
  if (FunctionEntry != (PRUNTIME_FUNCTION)0x0) {
    *(undefined8 *)(puVar4 + 0x38) = 0;
    *(undefined1 **)(puVar4 + 0x30) = local_res18;
    *(undefined1 **)(puVar4 + 0x28) = local_res20;
    *(undefined1 **)(puVar4 + 0x20) = local_4d8;
    *(undefined8 *)(puVar4 + -8) = 0x18000d481;
    RtlVirtualUnwind(0,local_res10,local_3e0,FunctionEntry,*(PCONTEXT *)(puVar4 + 0x20),
                     *(PVOID **)(puVar4 + 0x28),*(PDWORD64 *)(puVar4 + 0x30),
                     *(PKNONVOLATILE_CONTEXT_POINTERS *)(puVar4 + 0x38));
  }
  local_440 = &stack0x00000008;
  *(undefined8 *)(puVar4 + -8) = 0x18000d4b3;
  memset(puVar4 + 0x50,0,0x98);
  *(undefined8 *)(puVar4 + 0x60) = unaff_retaddr;
  *(undefined4 *)(puVar4 + 0x50) = 0x40000015;
  *(undefined4 *)(puVar4 + 0x54) = 1;
  *(undefined8 *)(puVar4 + -8) = 0x18000d4d5;
  BVar2 = IsDebuggerPresent();
  *(undefined1 **)(puVar4 + 0x40) = puVar4 + 0x50;
  *(undefined1 **)(puVar4 + 0x48) = local_4d8;
  *(undefined8 *)(puVar4 + -8) = 0x18000d4f6;
  SetUnhandledExceptionFilter((LPTOP_LEVEL_EXCEPTION_FILTER)0x0);
  *(undefined8 *)(puVar4 + -8) = 0x18000d501;
  LVar3 = UnhandledExceptionFilter((_EXCEPTION_POINTERS *)(puVar4 + 0x40));
  if ((LVar3 == 0) && (BVar2 != 1)) {
    *(undefined8 *)(puVar4 + -8) = 0x18000d511;
    FUN_18000d3d0();
  }
  return;
}


==================================================================

### EXPORT FUNC 18000d524 (5 bytes) name=free

void __cdecl free(void *_Memory)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d742. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  free(_Memory);
  return;
}


==================================================================

### EXPORT FUNC 18000d52c (172 bytes) name=__security_init_cookie

/* Library Function - Single Match
    __security_init_cookie
   
   Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release */

void __cdecl __security_init_cookie(void)

{
  DWORD DVar1;
  _FILETIME local_res8;
  _FILETIME local_res10;
  LARGE_INTEGER local_res18;
  
  if (DAT_180015010 == 0x2b992ddfa232) {
    local_res10.dwLowDateTime = 0;
    local_res10.dwHighDateTime = 0;
    GetSystemTimeAsFileTime(&local_res10);
    local_res8 = local_res10;
    DVar1 = GetCurrentThreadId();
    local_res8 = (_FILETIME)((ulonglong)local_res8 ^ (ulonglong)DVar1);
    DVar1 = GetCurrentProcessId();
    local_res8 = (_FILETIME)((ulonglong)local_res8 ^ (ulonglong)DVar1);
    QueryPerformanceCounter(&local_res18);
    DAT_180015010 =
         ((ulonglong)local_res18.s.LowPart << 0x20 ^
          CONCAT44(local_res18.s.HighPart,local_res18.s.LowPart) ^ (ulonglong)local_res8 ^
         (ulonglong)&local_res8) & 0xffffffffffff;
    if (DAT_180015010 == 0x2b992ddfa232) {
      DAT_180015010 = 0x2b992ddfa233;
    }
  }
  DAT_180015008 = ~DAT_180015010;
  return;
}


==================================================================

### EXPORT FUNC 18000d5d8 (14 bytes) name=FUN_18000d5d8

void FUN_18000d5d8(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d5df. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  InitializeSListHead(&DAT_180015fc0);
  return;
}


==================================================================

### EXPORT FUNC 18000d5e8 (12 bytes) name=FUN_18000d5e8

void FUN_18000d5e8(void)

{
  __std_type_info_destroy_list(&DAT_180015fc0);
  return;
}


==================================================================

### EXPORT FUNC 18000d5f4 (8 bytes) name=FUN_18000d5f4

undefined * FUN_18000d5f4(void)

{
  return &DAT_180015fd0;
}


==================================================================

### EXPORT FUNC 18000d5fc (27 bytes) name=FUN_18000d5fc

void FUN_18000d5fc(void)

{
  ulonglong *puVar1;
  
  puVar1 = (ulonglong *)FUN_180002fc0();
  *puVar1 = *puVar1 | 0x24;
  puVar1 = (ulonglong *)FUN_18000d5f4();
  *puVar1 = *puVar1 | 2;
  return;
}


==================================================================

### EXPORT FUNC 18000d618 (8 bytes) name=FUN_18000d618

undefined * FUN_18000d618(void)

{
  return &DAT_1800160e8;
}


==================================================================

### EXPORT FUNC 18000d620 (60 bytes) name=FUN_18000d620

void FUN_18000d620(void)

{
  longlong *plVar1;
  
  for (plVar1 = &DAT_180011b20; plVar1 < &DAT_180011b20; plVar1 = plVar1 + 1) {
    if (*plVar1 != 0) {
      (*(code *)PTR__guard_dispatch_icall_18000f4d8)();
    }
  }
  return;
}


==================================================================

### EXPORT FUNC 18000d65c (60 bytes) name=FUN_18000d65c

void FUN_18000d65c(void)

{
  longlong *plVar1;
  
  for (plVar1 = &DAT_180011b30; plVar1 < &DAT_180011b30; plVar1 = plVar1 + 1) {
    if (*plVar1 != 0) {
      (*(code *)PTR__guard_dispatch_icall_18000f4d8)();
    }
  }
  return;
}


==================================================================

### EXPORT FUNC 18000d6a0 (6 bytes) name=_Lock

void __thiscall
std::basic_streambuf<char,std::char_traits<char>_>::_Lock
          (basic_streambuf<char,std::char_traits<char>_> *this)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d6a0. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _Lock(this);
  return;
}


==================================================================

### EXPORT FUNC 18000d6a6 (6 bytes) name=_Unlock

void __thiscall
std::basic_streambuf<char,std::char_traits<char>_>::_Unlock
          (basic_streambuf<char,std::char_traits<char>_> *this)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d6a6. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _Unlock(this);
  return;
}


==================================================================

### EXPORT FUNC 18000d6ac (6 bytes) name=showmanyc

__int64 __thiscall
std::basic_streambuf<char,std::char_traits<char>_>::showmanyc
          (basic_streambuf<char,std::char_traits<char>_> *this)

{
  __int64 _Var1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d6ac. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _Var1 = showmanyc(this);
  return _Var1;
}


==================================================================

### EXPORT FUNC 18000d6b2 (6 bytes) name=uflow

int __thiscall
std::basic_streambuf<char,std::char_traits<char>_>::uflow
          (basic_streambuf<char,std::char_traits<char>_> *this)

{
  int iVar1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d6b2. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  iVar1 = uflow(this);
  return iVar1;
}


==================================================================

### EXPORT FUNC 18000d6b8 (6 bytes) name=xsgetn

__int64 __thiscall
std::basic_streambuf<char,std::char_traits<char>_>::xsgetn
          (basic_streambuf<char,std::char_traits<char>_> *this,char *param_1,__int64 param_2)

{
  __int64 _Var1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d6b8. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _Var1 = xsgetn(this,param_1,param_2);
  return _Var1;
}


==================================================================

### EXPORT FUNC 18000d6be (6 bytes) name=xsputn

__int64 __thiscall
std::basic_streambuf<char,std::char_traits<char>_>::xsputn
          (basic_streambuf<char,std::char_traits<char>_> *this,char *param_1,__int64 param_2)

{
  __int64 _Var1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d6be. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _Var1 = xsputn(this,param_1,param_2);
  return _Var1;
}


==================================================================

### EXPORT FUNC 18000d6c4 (6 bytes) name=setbuf

basic_streambuf<char,struct_std::char_traits<char>_> * __thiscall
std::basic_streambuf<char,std::char_traits<char>_>::setbuf
          (basic_streambuf<char,std::char_traits<char>_> *this,char *param_1,__int64 param_2)

{
  basic_streambuf<char,struct_std::char_traits<char>_> *pbVar1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d6c4. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  pbVar1 = setbuf(this,param_1,param_2);
  return pbVar1;
}


==================================================================

### EXPORT FUNC 18000d6ca (6 bytes) name=sync

int __thiscall
std::basic_streambuf<char,std::char_traits<char>_>::sync
          (basic_streambuf<char,std::char_traits<char>_> *this)

{
  int iVar1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d6ca. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  iVar1 = sync(this);
  return iVar1;
}


==================================================================

### EXPORT FUNC 18000d6d0 (6 bytes) name=imbue

void __thiscall
std::basic_streambuf<char,std::char_traits<char>_>::imbue
          (basic_streambuf<char,std::char_traits<char>_> *this,locale *param_1)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d6d0. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  imbue(this,param_1);
  return;
}


==================================================================

### EXPORT FUNC 18000d6d6 (6 bytes) name=__CxxFrameHandler4

void __CxxFrameHandler4(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d6d6. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  __CxxFrameHandler4();
  return;
}


==================================================================

### EXPORT FUNC 18000d6e8 (6 bytes) name=_CxxThrowException

void __stdcall _CxxThrowException(void *pExceptionObject,ThrowInfo *pThrowInfo)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d6e8. Too many branches */
                    /* WARNING: Subroutine does not return */
                    /* WARNING: Treating indirect jump as call */
  _CxxThrowException(pExceptionObject,pThrowInfo);
  return;
}


==================================================================

### EXPORT FUNC 18000d6ee (6 bytes) name=memset

void * __cdecl memset(void *_Dst,int _Val,size_t _Size)

{
  void *pvVar1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d6ee. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  pvVar1 = memset(_Dst,_Val,_Size);
  return pvVar1;
}


==================================================================

### EXPORT FUNC 18000d6f4 (6 bytes) name=__std_type_info_destroy_list

void __std_type_info_destroy_list(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d6f4. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  __std_type_info_destroy_list();
  return;
}


==================================================================

### EXPORT FUNC 18000d6fa (6 bytes) name=_callnewh

int __cdecl _callnewh(size_t _Size)

{
  int iVar1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d6fa. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  iVar1 = _callnewh(_Size);
  return iVar1;
}


==================================================================

### EXPORT FUNC 18000d700 (6 bytes) name=malloc

void * __cdecl malloc(size_t _Size)

{
  void *pvVar1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d700. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  pvVar1 = malloc(_Size);
  return pvVar1;
}


==================================================================

### EXPORT FUNC 18000d706 (6 bytes) name=_seh_filter_dll

void _seh_filter_dll(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d706. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _seh_filter_dll();
  return;
}


==================================================================

### EXPORT FUNC 18000d70c (6 bytes) name=_configure_narrow_argv

void _configure_narrow_argv(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d70c. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _configure_narrow_argv();
  return;
}


==================================================================

### EXPORT FUNC 18000d712 (6 bytes) name=_initialize_narrow_environment

void _initialize_narrow_environment(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d712. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _initialize_narrow_environment();
  return;
}


==================================================================

### EXPORT FUNC 18000d718 (6 bytes) name=_initialize_onexit_table

void _initialize_onexit_table(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d718. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _initialize_onexit_table();
  return;
}


==================================================================

### EXPORT FUNC 18000d71e (6 bytes) name=_register_onexit_function

void _register_onexit_function(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d71e. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _register_onexit_function();
  return;
}


==================================================================

### EXPORT FUNC 18000d724 (6 bytes) name=_execute_onexit_table

void _execute_onexit_table(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d724. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _execute_onexit_table();
  return;
}


==================================================================

### EXPORT FUNC 18000d72a (6 bytes) name=_crt_atexit

void _crt_atexit(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d72a. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _crt_atexit();
  return;
}


==================================================================

### EXPORT FUNC 18000d730 (6 bytes) name=_cexit

void __cdecl _cexit(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d730. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _cexit();
  return;
}


==================================================================

### EXPORT FUNC 18000d736 (6 bytes) name=_initterm

void _initterm(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d736. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _initterm();
  return;
}


==================================================================

### EXPORT FUNC 18000d73c (6 bytes) name=_initterm_e

void _initterm_e(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d73c. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  _initterm_e();
  return;
}


==================================================================

### EXPORT FUNC 18000d742 (6 bytes) name=free

void __cdecl free(void *_Memory)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d742. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  free(_Memory);
  return;
}


==================================================================

### EXPORT FUNC 18000d748 (6 bytes) name=IsProcessorFeaturePresent

BOOL __stdcall IsProcessorFeaturePresent(DWORD ProcessorFeature)

{
  BOOL BVar1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d748. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  BVar1 = IsProcessorFeaturePresent(ProcessorFeature);
  return BVar1;
}


==================================================================

### EXPORT FUNC 18000d750 (3 bytes) name=FUN_18000d750

undefined1 FUN_18000d750(void)

{
  return 1;
}


==================================================================

### EXPORT FUNC 18000d754 (3 bytes) name=FUN_18000d754

undefined8 FUN_18000d754(void)

{
  return 0;
}


==================================================================

### EXPORT FUNC 18000d758 (29 bytes) name=__GSHandlerCheck

/* Library Function - Single Match
    __GSHandlerCheck
   
   Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release */

undefined8
__GSHandlerCheck(undefined8 param_1,undefined8 param_2,undefined8 param_3,longlong param_4)

{
  __GSHandlerCheckCommon(param_2,param_4);
  return 1;
}


==================================================================

### EXPORT FUNC 18000d778 (91 bytes) name=__GSHandlerCheckCommon

/* WARNING: Function: __security_check_cookie replaced with injection: security_check_cookie */
/* Library Function - Single Match
    __GSHandlerCheckCommon
   
   Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release */

ulonglong __GSHandlerCheckCommon(undefined8 param_1,longlong param_2)

{
  ulonglong uVar1;
  ulonglong uVar2;
  
  uVar2 = (ulonglong)*(uint *)(*(longlong *)(param_2 + 0x10) + 8);
  uVar1 = *(ulonglong *)(param_2 + 8);
  if ((*(byte *)(uVar2 + 3 + uVar1) & 0xf) != 0) {
    uVar1 = (ulonglong)(*(byte *)(uVar2 + 3 + uVar1) & 0xfffffff0);
  }
  return uVar1;
}


==================================================================

### EXPORT FUNC 18000d7d4 (127 bytes) name=FID_conflict:__GSHandlerCheck_EH

/* Library Function - Multiple Matches With Different Base Names
    __GSHandlerCheck_EH
    __GSHandlerCheck_EH4
   
   Libraries: Visual Studio 2017 Release, Visual Studio 2019 Release */

void FID_conflict___GSHandlerCheck_EH
               (longlong param_1,undefined8 param_2,undefined8 param_3,longlong param_4)

{
  longlong lVar1;
  
  lVar1 = *(longlong *)(param_4 + 0x38);
  __GSHandlerCheckCommon(param_2,param_4);
  if ((*(uint *)(lVar1 + 4) & ((*(uint *)(param_1 + 4) & 0x66) != 0) + 1) != 0) {
    __CxxFrameHandler4(param_1,param_2,param_3,param_4);
  }
  return;
}


==================================================================

### EXPORT FUNC 18000d853 (6 bytes) name=__RTDynamicCast

void __RTDynamicCast(void)

{
                    /* WARNING: Could not recover jumptable at 0x00018000d853. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  __RTDynamicCast();
  return;
}


==================================================================

### EXPORT FUNC 18000d859 (6 bytes) name=memchr

void * __cdecl memchr(void *_Buf,int _Val,size_t _MaxCount)

{
  void *pvVar1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d859. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  pvVar1 = memchr(_Buf,_Val,_MaxCount);
  return pvVar1;
}


==================================================================

### EXPORT FUNC 18000d85f (6 bytes) name=memcmp

int __cdecl memcmp(void *_Buf1,void *_Buf2,size_t _Size)

{
  int iVar1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d85f. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  iVar1 = memcmp(_Buf1,_Buf2,_Size);
  return iVar1;
}


==================================================================

### EXPORT FUNC 18000d865 (6 bytes) name=memcpy

void * __cdecl memcpy(void *_Dst,void *_Src,size_t _Size)

{
  void *pvVar1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d865. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  pvVar1 = memcpy(_Dst,_Src,_Size);
  return pvVar1;
}


==================================================================

### EXPORT FUNC 18000d86b (6 bytes) name=memmove

void * __cdecl memmove(void *_Dst,void *_Src,size_t _Size)

{
  void *pvVar1;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d86b. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  pvVar1 = memmove(_Dst,_Src,_Size);
  return pvVar1;
}


==================================================================

### EXPORT FUNC 18000d890 (2 bytes) name=_guard_dispatch_icall

/* WARNING: This is an inlined function */

void _guard_dispatch_icall(void)

{
  code *UNRECOVERED_JUMPTABLE;
  
                    /* WARNING: Could not recover jumptable at 0x00018000d890. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  (*UNRECOVERED_JUMPTABLE)();
  return;
}


==================================================================

### EXPORT FUNC 18000d8d0 (41 bytes) name=FUN_18000d8d0

void FUN_18000d8d0(undefined8 param_1,longlong param_2)

{
  if ((*(uint *)(param_2 + 0x40) & 1) != 0) {
    *(uint *)(param_2 + 0x40) = *(uint *)(param_2 + 0x40) & 0xfffffffe;
    FUN_180002da0(*(longlong **)(param_2 + 0x88));
  }
  return;
}


==================================================================

### EXPORT FUNC 18000d98c (48 bytes) name=FUN_18000d98c

void FUN_18000d98c(undefined8 param_1,longlong param_2)

{
  FUN_180002f30(param_1,*(longlong **)(param_2 + 0x20),*(longlong **)(param_2 + 0x40));
  deallocate(param_1,*(void **)(param_2 + 0x28),*(longlong *)(param_2 + 0x30));
                    /* WARNING: Subroutine does not return */
  _CxxThrowException((void *)0x0,(ThrowInfo *)0x0);
}


==================================================================

### EXPORT FUNC 18000d9dc (46 bytes) name=FUN_18000d9dc

void FUN_18000d9dc(undefined8 param_1,longlong param_2)

{
  if ((*(uint *)(param_2 + 0x20) & 1) != 0) {
    *(uint *)(param_2 + 0x20) = *(uint *)(param_2 + 0x20) & 0xfffffffe;
    std::basic_ios<char,std::char_traits<char>_>::~basic_ios<char,std::char_traits<char>_>
              ((basic_ios<char,std::char_traits<char>_> *)(param_2 + 0xf8));
  }
  return;
}


==================================================================

### EXPORT FUNC 18000da28 (38 bytes) name=FUN_18000da28

void FUN_18000da28(undefined8 param_1,longlong param_2)

{
  if ((*(uint *)(param_2 + 0x20) & 4) != 0) {
    *(uint *)(param_2 + 0x20) = *(uint *)(param_2 + 0x20) & 0xfffffffb;
    FUN_1800024b0((longlong *)(param_2 + 0x28));
  }
  return;
}


==================================================================

### EXPORT FUNC 18000da98 (46 bytes) name=FUN_18000da98

void FUN_18000da98(undefined8 param_1,longlong param_2)

{
  if ((*(uint *)(param_2 + 0x20) & 1) != 0) {
    *(uint *)(param_2 + 0x20) = *(uint *)(param_2 + 0x20) & 0xfffffffe;
    std::basic_ios<char,std::char_traits<char>_>::~basic_ios<char,std::char_traits<char>_>
              ((basic_ios<char,std::char_traits<char>_> *)(param_2 + 0x108));
  }
  return;
}


==================================================================

### EXPORT FUNC 18000dae4 (38 bytes) name=FUN_18000dae4

void FUN_18000dae4(undefined8 param_1,longlong param_2)

{
  if ((*(uint *)(param_2 + 0x20) & 4) != 0) {
    *(uint *)(param_2 + 0x20) = *(uint *)(param_2 + 0x20) & 0xfffffffb;
    FUN_1800024b0((longlong *)(param_2 + 0x28));
  }
  return;
}


==================================================================

### EXPORT FUNC 18000db3c (38 bytes) name=FUN_18000db3c

void FUN_18000db3c(undefined8 param_1,longlong param_2)

{
  if ((*(uint *)(param_2 + 0x30) & 2) != 0) {
    *(uint *)(param_2 + 0x30) = *(uint *)(param_2 + 0x30) & 0xfffffffd;
    FUN_1800037c0(*(longlong **)(param_2 + 0x38));
  }
  return;
}


==================================================================

### EXPORT FUNC 18000db7c (49 bytes) name=FUN_18000db7c

void FUN_18000db7c(undefined8 param_1,longlong param_2)

{
  if ((*(uint *)(param_2 + 0x40) & 1) != 0) {
    *(uint *)(param_2 + 0x40) = *(uint *)(param_2 + 0x40) & 0xfffffffe;
    std::basic_ios<char,std::char_traits<char>_>::~basic_ios<char,std::char_traits<char>_>
              ((basic_ios<char,std::char_traits<char>_> *)(param_2 + 0x1d8));
  }
  return;
}


==================================================================

### EXPORT FUNC 18000dc40 (38 bytes) name=FUN_18000dc40

void FUN_18000dc40(undefined8 param_1,longlong param_2)

{
  if ((*(uint *)(param_2 + 0x20) & 2) != 0) {
    *(uint *)(param_2 + 0x20) = *(uint *)(param_2 + 0x20) & 0xfffffffd;
    FUN_1800024b0(*(longlong **)(param_2 + 0x30));
  }
  return;
}


==================================================================

### EXPORT FUNC 18000dc70 (46 bytes) name=FUN_18000dc70

void FUN_18000dc70(undefined8 param_1,longlong param_2)

{
  if ((*(uint *)(param_2 + 0x40) & 1) != 0) {
    *(uint *)(param_2 + 0x40) = *(uint *)(param_2 + 0x40) & 0xfffffffe;
    std::basic_ios<char,std::char_traits<char>_>::~basic_ios<char,std::char_traits<char>_>
              ((basic_ios<char,std::char_traits<char>_> *)(*(longlong *)(param_2 + 0x30) + 0x98));
  }
  return;
}


==================================================================

### EXPORT FUNC 18000dcc8 (58 bytes) name=FUN_18000dcc8

undefined8 FUN_18000dcc8(undefined8 param_1,longlong param_2)

{
  std::basic_ios<char,std::char_traits<char>_>::setstate
            ((basic_ios<char,std::char_traits<char>_> *)
             ((longlong)*(int *)(**(longlong **)(param_2 + 0x60) + 4) +
             (longlong)*(longlong **)(param_2 + 0x60)),4,true);
  return 0;
}


==================================================================

### EXPORT FUNC 18000dd10 (29 bytes) name=FUN_18000dd10

void FUN_18000dd10(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x20));
  return;
}


==================================================================

### EXPORT FUNC 18000dd70 (29 bytes) name=FUN_18000dd70

undefined8 FUN_18000dd70(void)

{
  return 0;
}


==================================================================

### EXPORT FUNC 18000dd90 (29 bytes) name=FUN_18000dd90

void FUN_18000dd90(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x68));
  return;
}


==================================================================

### EXPORT FUNC 18000ddb9 (41 bytes) name=FUN_18000ddb9

undefined8 FUN_18000ddb9(undefined8 param_1,longlong param_2)

{
  *(undefined8 *)(*(longlong *)(param_2 + 0x60) + 0x20) = 0;
  return 0;
}


==================================================================

### EXPORT FUNC 18000de3c (29 bytes) name=FUN_18000de3c

void FUN_18000de3c(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x40));
  return;
}


==================================================================

### EXPORT FUNC 18000de98 (29 bytes) name=FUN_18000de98

void FUN_18000de98(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x28));
  return;
}


==================================================================

### EXPORT FUNC 18000df1c (29 bytes) name=FUN_18000df1c

void FUN_18000df1c(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x40));
  return;
}


==================================================================

### EXPORT FUNC 18000df50 (29 bytes) name=FUN_18000df50

void FUN_18000df50(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x20));
  return;
}


==================================================================

### EXPORT FUNC 18000df9c (29 bytes) name=FUN_18000df9c

void FUN_18000df9c(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x38));
  return;
}


==================================================================

### EXPORT FUNC 18000e030 (38 bytes) name=FUN_18000e030

void FUN_18000e030(undefined8 param_1,longlong param_2)

{
  if ((*(uint *)(param_2 + 0x20) & 1) != 0) {
    *(uint *)(param_2 + 0x20) = *(uint *)(param_2 + 0x20) & 0xfffffffe;
    FUN_180002420(*(longlong **)(param_2 + 0x48));
  }
  return;
}


==================================================================

### EXPORT FUNC 18000e090 (29 bytes) name=FUN_18000e090

void FUN_18000e090(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x58));
  return;
}


==================================================================

### EXPORT FUNC 18000e0ad (29 bytes) name=FUN_18000e0ad

void FUN_18000e0ad(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x58));
  return;
}


==================================================================

### EXPORT FUNC 18000e0ca (29 bytes) name=FUN_18000e0ca

void FUN_18000e0ca(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x58));
  return;
}


==================================================================

### EXPORT FUNC 18000e0e7 (29 bytes) name=FUN_18000e0e7

void FUN_18000e0e7(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x58));
  return;
}


==================================================================

### EXPORT FUNC 18000e104 (29 bytes) name=FUN_18000e104

void FUN_18000e104(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x58));
  return;
}


==================================================================

### EXPORT FUNC 18000e121 (29 bytes) name=FUN_18000e121

void FUN_18000e121(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x58));
  return;
}


==================================================================

### EXPORT FUNC 18000e13e (29 bytes) name=FUN_18000e13e

void FUN_18000e13e(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x58));
  return;
}


==================================================================

### EXPORT FUNC 18000e15b (29 bytes) name=FUN_18000e15b

void FUN_18000e15b(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x58));
  return;
}


==================================================================

### EXPORT FUNC 18000e1d0 (38 bytes) name=FUN_18000e1d0

void FUN_18000e1d0(undefined8 param_1,longlong param_2)

{
  if ((*(uint *)(param_2 + 0x24) & 1) != 0) {
    *(uint *)(param_2 + 0x24) = *(uint *)(param_2 + 0x24) & 0xfffffffe;
    FUN_180002420(*(longlong **)(param_2 + 0x28));
  }
  return;
}


==================================================================

### EXPORT FUNC 18000e220 (29 bytes) name=FUN_18000e220

void FUN_18000e220(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x50));
  return;
}


==================================================================

### EXPORT FUNC 18000e24d (29 bytes) name=FUN_18000e24d

void FUN_18000e24d(undefined8 param_1,longlong param_2)

{
  free(*(void **)(param_2 + 0x58));
  return;
}


==================================================================

### EXPORT FUNC 18000e26a (23 bytes) name=FUN_18000e26a

bool FUN_18000e26a(undefined8 *param_1)

{
  return *(int *)*param_1 == -0x3ffffffb;
}


==================================================================

### EXPORT FUNC 18000e282 (22 bytes) name=FUN_18000e282

void FUN_18000e282(undefined8 param_1,longlong param_2)

{
  __scrt_release_startup_lock(*(char *)(param_2 + 0x40));
  return;
}


==================================================================

### EXPORT FUNC 18000e299 (24 bytes) name=FUN_18000e299

void FUN_18000e299(undefined8 param_1,longlong param_2)

{
  __scrt_release_startup_lock(*(char *)(param_2 + 0x20));
  return;
}


==================================================================

### EXPORT FUNC 18000e2b2 (19 bytes) name=FUN_18000e2b2

void FUN_18000e2b2(void)

{
  FUN_18000c6e8();
  return;
}


==================================================================

### EXPORT FUNC 18000e2c6 (53 bytes) name=FUN_18000e2c6

void FUN_18000e2c6(undefined8 *param_1,longlong param_2)

{
  __scrt_dllmain_exception_filter
            (*(undefined8 *)(param_2 + 0x60),*(int *)(param_2 + 0x68),
             *(undefined8 *)(param_2 + 0x70),FUN_18000ce80,*(undefined4 *)*param_1,param_1);
  return;
}


==================================================================

### EXPORT FUNC 18000e300 (97 bytes) name=FUN_18000e300

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000e300(void)

{
  void *_Memory;
  
  if (DAT_180016060 != (void *)0x0) {
    _Memory = DAT_180016060;
    if ((0xfff < (ulonglong)(DAT_180016070 - (longlong)DAT_180016060)) &&
       (_Memory = *(void **)((longlong)DAT_180016060 + -8),
       0x1f < (ulonglong)((longlong)DAT_180016060 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
    DAT_180016060 = (void *)0x0;
    _DAT_180016068 = 0;
    DAT_180016070 = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 18000e370 (97 bytes) name=FUN_18000e370

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000e370(void)

{
  void *_Memory;
  
  if (DAT_180016000 != (void *)0x0) {
    _Memory = DAT_180016000;
    if ((0xfff < (ulonglong)(DAT_180016010 - (longlong)DAT_180016000)) &&
       (_Memory = *(void **)((longlong)DAT_180016000 + -8),
       0x1f < (ulonglong)((longlong)DAT_180016000 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
    DAT_180016000 = (void *)0x0;
    _DAT_180016008 = 0;
    DAT_180016010 = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 18000e3e0 (97 bytes) name=FUN_18000e3e0

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000e3e0(void)

{
  void *_Memory;
  
  if (DAT_180016018 != (void *)0x0) {
    _Memory = DAT_180016018;
    if ((0xfff < (ulonglong)(DAT_180016028 - (longlong)DAT_180016018)) &&
       (_Memory = *(void **)((longlong)DAT_180016018 + -8),
       0x1f < (ulonglong)((longlong)DAT_180016018 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
    DAT_180016018 = (void *)0x0;
    _DAT_180016020 = 0;
    DAT_180016028 = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 18000e450 (97 bytes) name=FUN_18000e450

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000e450(void)

{
  void *_Memory;
  
  if (DAT_180016090 != (void *)0x0) {
    _Memory = DAT_180016090;
    if ((0xfff < (ulonglong)(DAT_1800160a0 - (longlong)DAT_180016090)) &&
       (_Memory = *(void **)((longlong)DAT_180016090 + -8),
       0x1f < (ulonglong)((longlong)DAT_180016090 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
    DAT_180016090 = (void *)0x0;
    _DAT_180016098 = 0;
    DAT_1800160a0 = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 18000e4c0 (97 bytes) name=FUN_18000e4c0

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000e4c0(void)

{
  void *_Memory;
  
  if (DAT_180016078 != (void *)0x0) {
    _Memory = DAT_180016078;
    if ((0xfff < (ulonglong)(DAT_180016088 - (longlong)DAT_180016078)) &&
       (_Memory = *(void **)((longlong)DAT_180016078 + -8),
       0x1f < (ulonglong)((longlong)DAT_180016078 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
    DAT_180016078 = (void *)0x0;
    _DAT_180016080 = 0;
    DAT_180016088 = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 18000e530 (97 bytes) name=FUN_18000e530

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000e530(void)

{
  void *_Memory;
  
  if (DAT_180016030 != (void *)0x0) {
    _Memory = DAT_180016030;
    if ((0xfff < (ulonglong)(DAT_180016040 - (longlong)DAT_180016030)) &&
       (_Memory = *(void **)((longlong)DAT_180016030 + -8),
       0x1f < (ulonglong)((longlong)DAT_180016030 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
    DAT_180016030 = (void *)0x0;
    _DAT_180016038 = 0;
    DAT_180016040 = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 18000e5a0 (97 bytes) name=FUN_18000e5a0

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000e5a0(void)

{
  void *_Memory;
  
  if (DAT_1800160a8 != (void *)0x0) {
    _Memory = DAT_1800160a8;
    if ((0xfff < (ulonglong)(DAT_1800160b8 - (longlong)DAT_1800160a8)) &&
       (_Memory = *(void **)((longlong)DAT_1800160a8 + -8),
       0x1f < (ulonglong)((longlong)DAT_1800160a8 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
    DAT_1800160a8 = (void *)0x0;
    _DAT_1800160b0 = 0;
    DAT_1800160b8 = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 18000e610 (97 bytes) name=FUN_18000e610

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000e610(void)

{
  void *_Memory;
  
  if (DAT_180016048 != (void *)0x0) {
    _Memory = DAT_180016048;
    if ((0xfff < (ulonglong)(DAT_180016058 - (longlong)DAT_180016048)) &&
       (_Memory = *(void **)((longlong)DAT_180016048 + -8),
       0x1f < (ulonglong)((longlong)DAT_180016048 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
    DAT_180016048 = (void *)0x0;
    _DAT_180016050 = 0;
    DAT_180016058 = 0;
  }
  return;
}


==================================================================

### EXPORT FUNC 18000e680 (108 bytes) name=FUN_18000e680

void FUN_18000e680(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (7 < DAT_1800160d8) {
    pvVar1 = (void *)CONCAT62(DAT_1800160c0._2_6_,(undefined2)DAT_1800160c0);
    _Memory = pvVar1;
    if ((0xfff < DAT_1800160d8 * 2 + 2) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  DAT_1800160d8 = 7;
  DAT_1800160d0 = 0;
  DAT_1800160c0._0_2_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000e6f0 (105 bytes) name=FUN_18000e6f0

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000e6f0(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_180015078) {
    pvVar1 = (void *)CONCAT71(DAT_180015060._1_7_,(undefined1)DAT_180015060);
    _Memory = pvVar1;
    if ((0xfff < DAT_180015078 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  _DAT_180015070 = 0;
  DAT_180015078 = 0xf;
  DAT_180015060._0_1_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000e760 (105 bytes) name=FUN_18000e760

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000e760(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_1800150b8) {
    pvVar1 = (void *)CONCAT71(DAT_1800150a0._1_7_,(undefined1)DAT_1800150a0);
    _Memory = pvVar1;
    if ((0xfff < DAT_1800150b8 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  _DAT_1800150b0 = 0;
  DAT_1800150b8 = 0xf;
  DAT_1800150a0._0_1_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000e7d0 (105 bytes) name=FUN_18000e7d0

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000e7d0(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_1800151f8) {
    pvVar1 = (void *)CONCAT71(DAT_1800151e0._1_7_,(undefined1)DAT_1800151e0);
    _Memory = pvVar1;
    if ((0xfff < DAT_1800151f8 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  _DAT_1800151f0 = 0;
  DAT_1800151f8 = 0xf;
  DAT_1800151e0._0_1_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000e840 (105 bytes) name=FUN_18000e840

void FUN_18000e840(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_180015198) {
    pvVar1 = (void *)CONCAT71(DAT_180015180._1_7_,(undefined1)DAT_180015180);
    _Memory = pvVar1;
    if ((0xfff < DAT_180015198 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  DAT_180015190 = 0;
  DAT_180015198 = 0xf;
  DAT_180015180._0_1_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000e8b0 (105 bytes) name=FUN_18000e8b0

void FUN_18000e8b0(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_1800150f8) {
    pvVar1 = (void *)CONCAT71(DAT_1800150e0._1_7_,(undefined1)DAT_1800150e0);
    _Memory = pvVar1;
    if ((0xfff < DAT_1800150f8 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  DAT_1800150f0 = 0;
  DAT_1800150f8 = 0xf;
  DAT_1800150e0._0_1_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000e920 (105 bytes) name=FUN_18000e920

void FUN_18000e920(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_180015178) {
    pvVar1 = (void *)CONCAT71(DAT_180015160._1_7_,(undefined1)DAT_180015160);
    _Memory = pvVar1;
    if ((0xfff < DAT_180015178 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  DAT_180015170 = 0;
  DAT_180015178 = 0xf;
  DAT_180015160._0_1_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000e990 (105 bytes) name=FUN_18000e990

void FUN_18000e990(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_1800151d8) {
    pvVar1 = (void *)CONCAT71(DAT_1800151c0._1_7_,(undefined1)DAT_1800151c0);
    _Memory = pvVar1;
    if ((0xfff < DAT_1800151d8 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  DAT_1800151d0 = 0;
  DAT_1800151d8 = 0xf;
  DAT_1800151c0._0_1_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000ea00 (105 bytes) name=FUN_18000ea00

void FUN_18000ea00(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_180015138) {
    pvVar1 = (void *)CONCAT71(DAT_180015120._1_7_,(undefined1)DAT_180015120);
    _Memory = pvVar1;
    if ((0xfff < DAT_180015138 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  DAT_180015130 = 0;
  DAT_180015138 = 0xf;
  DAT_180015120._0_1_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000ea70 (105 bytes) name=FUN_18000ea70

void FUN_18000ea70(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_1800150d8) {
    pvVar1 = (void *)CONCAT71(DAT_1800150c0._1_7_,(undefined1)DAT_1800150c0);
    _Memory = pvVar1;
    if ((0xfff < DAT_1800150d8 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  DAT_1800150d0 = 0;
  DAT_1800150d8 = 0xf;
  DAT_1800150c0._0_1_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000eae0 (105 bytes) name=FUN_18000eae0

void FUN_18000eae0(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_180015158) {
    pvVar1 = (void *)CONCAT71(DAT_180015140._1_7_,(undefined1)DAT_180015140);
    _Memory = pvVar1;
    if ((0xfff < DAT_180015158 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  DAT_180015150 = 0;
  DAT_180015158 = 0xf;
  DAT_180015140._0_1_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000eb50 (105 bytes) name=FUN_18000eb50

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000eb50(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_180015118) {
    pvVar1 = (void *)CONCAT71(DAT_180015100._1_7_,(undefined1)DAT_180015100);
    _Memory = pvVar1;
    if ((0xfff < DAT_180015118 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  _DAT_180015110 = 0;
  DAT_180015118 = 0xf;
  DAT_180015100._0_1_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000ebc0 (105 bytes) name=FUN_18000ebc0

void FUN_18000ebc0(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_1800151b8) {
    pvVar1 = (void *)CONCAT71(DAT_1800151a0._1_7_,(undefined1)DAT_1800151a0);
    _Memory = pvVar1;
    if ((0xfff < DAT_1800151b8 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  DAT_1800151b0 = 0;
  DAT_1800151b8 = 0xf;
  DAT_1800151a0._0_1_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000ec30 (105 bytes) name=FUN_18000ec30

/* WARNING: Globals starting with '_' overlap smaller symbols at the same address */

void FUN_18000ec30(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_180015058) {
    pvVar1 = (void *)CONCAT71(DAT_180015040._1_7_,(undefined1)DAT_180015040);
    _Memory = pvVar1;
    if ((0xfff < DAT_180015058 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  _DAT_180015050 = 0;
  DAT_180015058 = 0xf;
  DAT_180015040._0_1_ = 0;
  return;
}


==================================================================

### EXPORT FUNC 18000eca0 (105 bytes) name=FUN_18000eca0

void FUN_18000eca0(void)

{
  void *pvVar1;
  void *_Memory;
  
  if (0xf < DAT_180015098) {
    pvVar1 = (void *)CONCAT71(DAT_180015080._1_7_,(undefined1)DAT_180015080);
    _Memory = pvVar1;
    if ((0xfff < DAT_180015098 + 1) &&
       (_Memory = *(void **)((longlong)pvVar1 + -8),
       0x1f < (ulonglong)((longlong)pvVar1 + (-8 - (longlong)_Memory)))) {
                    /* WARNING: Subroutine does not return */
      _invalid_parameter_noinfo_noreturn();
    }
    free(_Memory);
  }
  DAT_180015090 = 0;
  DAT_180015098 = 0xf;
  DAT_180015080._0_1_ = 0;
  return;
}


==================================================================