### ADDR 180017200 FUNC 180017200 (297 bytes) name=FUN_180017200

void FUN_180017200(longlong param_1,ushort *param_2)

{
  longlong lVar1;
  ushort *puVar2;
  ushort uVar3;
  ushort uVar4;
  undefined4 uVar5;
  int iVar6;
  uint uVar7;
  short *psVar8;
  uint uVar9;
  ushort *puVar10;
  ulonglong uVar11;
  int iVar12;
  short *psVar13;
  int iVar14;
  undefined2 uVar15;
  uint uVar16;
  undefined2 *puVar17;
  longlong lVar18;
  
  psVar13 = *(short **)(param_1 + 0x41858);
  puVar10 = (ushort *)0x0;
  if (*(int *)(param_1 + 0x41f0c) != 0) {
    puVar10 = *(ushort **)(param_1 + 0x41ef0);
  }
  iVar12 = *(int *)(param_1 + 0x47938);
  lVar18 = *(longlong *)(param_1 + 0x41870);
  uVar5 = *(undefined4 *)(param_1 + 0x11c);
  puVar17 = *(undefined2 **)(param_1 + 0x270);
  uVar16 = *(int *)(param_1 + 0x41554) - 1;
  iVar6 = iVar12 * 2;
  if (iVar12 != 0) {
    do {
      uVar9 = 0;
      uVar3 = *puVar10;
      uVar4 = *param_2;
      puVar10 = puVar10 + 1;
      param_2 = param_2 + 1;
      iVar14 = (int)((uint)uVar4 - (uint)uVar3) >> 1;
      psVar8 = psVar13;
      uVar7 = 0;
      if (uVar16 != 0) {
        do {
          uVar9 = uVar7;
          if (iVar14 <= *psVar8) break;
          uVar9 = uVar9 + 1;
          psVar8 = psVar8 + 1;
          uVar7 = uVar9;
        } while (uVar9 < uVar16);
      }
      uVar11 = (ulonglong)(uVar9 * iVar6);
      psVar13 = psVar13 + uVar16;
      puVar2 = (ushort *)(lVar18 + uVar11 * 2);
      lVar1 = lVar18 + 2;
      lVar18 = lVar18 + 4;
      iVar14 = ((int)((uint)*puVar2 * iVar14) >> ((byte)uVar5 & 0x1f)) +
               (uint)*(ushort *)(lVar1 + uVar11 * 2);
      if (iVar14 < 0x10000) {
        uVar15 = (undefined2)iVar14;
        if (iVar14 < 0) {
          uVar15 = 0;
        }
      }
      else {
        uVar15 = 0xffff;
      }
      *puVar17 = uVar15;
      puVar17 = puVar17 + 1;
      iVar12 = iVar12 + -1;
    } while (iVar12 != 0);
  }
  return;
}


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

### ADDR 180017330 FUNC 180017330 (595 bytes) name=FUN_180017330

void FUN_180017330(longlong param_1,longlong param_2)

{
  uint uVar1;
  uint *puVar2;
  uint uVar3;
  
  puVar2 = *(uint **)(param_1 + 0x41878);
  uVar3 = 0;
  uVar1 = *(uint *)(param_1 + 0x41654 + (ulonglong)*(uint *)(param_1 + 0x41840) * 4);
  if (uVar1 != 0) {
    do {
      switch(puVar2[1]) {
      case 3:
        *(short *)(param_2 + (ulonglong)*puVar2 * 2) =
             (short)((ulonglong)
                     ((longlong)
                      (int)((uint)*(ushort *)(param_2 + (ulonglong)puVar2[4] * 2) +
                            (uint)*(ushort *)(param_2 + (ulonglong)puVar2[3] * 2) +
                           (uint)*(ushort *)(param_2 + (ulonglong)puVar2[2] * 2)) * 0x55555556) >>
                    0x20);
        break;
      case 4:
        *(short *)(param_2 + (ulonglong)*puVar2 * 2) =
             (short)((int)((uint)*(ushort *)(param_2 + (ulonglong)puVar2[5] * 2) +
                           (uint)*(ushort *)(param_2 + (ulonglong)puVar2[4] * 2) +
                           (uint)*(ushort *)(param_2 + (ulonglong)puVar2[3] * 2) +
                          (uint)*(ushort *)(param_2 + (ulonglong)puVar2[2] * 2)) >> 2);
        break;
      case 5:
        *(short *)(param_2 + (ulonglong)*puVar2 * 2) =
             (short)(((uint)*(ushort *)(param_2 + (ulonglong)puVar2[6] * 2) +
                      (uint)*(ushort *)(param_2 + (ulonglong)puVar2[5] * 2) +
                      (uint)*(ushort *)(param_2 + (ulonglong)puVar2[4] * 2) +
                      (uint)*(ushort *)(param_2 + (ulonglong)puVar2[3] * 2) +
                     (uint)*(ushort *)(param_2 + (ulonglong)puVar2[2] * 2)) / 5);
        break;
      case 6:
        *(short *)(param_2 + (ulonglong)*puVar2 * 2) =
             (short)((ulonglong)
                     ((longlong)
                      (int)((uint)*(ushort *)(param_2 + (ulonglong)puVar2[7] * 2) +
                            (uint)*(ushort *)(param_2 + (ulonglong)puVar2[6] * 2) +
                            (uint)*(ushort *)(param_2 + (ulonglong)puVar2[5] * 2) +
                            (uint)*(ushort *)(param_2 + (ulonglong)puVar2[4] * 2) +
                            (uint)*(ushort *)(param_2 + (ulonglong)puVar2[3] * 2) +
                           (uint)*(ushort *)(param_2 + (ulonglong)puVar2[2] * 2)) * 0x2aaaaaab) >>
                    0x20);
        break;
      case 7:
        *(short *)(param_2 + (ulonglong)*puVar2 * 2) =
             (short)(((uint)*(ushort *)(param_2 + (ulonglong)puVar2[8] * 2) +
                      (uint)*(ushort *)(param_2 + (ulonglong)puVar2[7] * 2) +
                      (uint)*(ushort *)(param_2 + (ulonglong)puVar2[6] * 2) +
                      (uint)*(ushort *)(param_2 + (ulonglong)puVar2[5] * 2) +
                      (uint)*(ushort *)(param_2 + (ulonglong)puVar2[4] * 2) +
                      (uint)*(ushort *)(param_2 + (ulonglong)puVar2[3] * 2) +
                     (uint)*(ushort *)(param_2 + (ulonglong)puVar2[2] * 2)) / 7);
        break;
      case 8:
        *(short *)(param_2 + (ulonglong)*puVar2 * 2) =
             (short)((int)((uint)*(ushort *)(param_2 + (ulonglong)puVar2[8] * 2) +
                           (uint)*(ushort *)(param_2 + (ulonglong)puVar2[7] * 2) +
                           (uint)*(ushort *)(param_2 + (ulonglong)puVar2[6] * 2) +
                           (uint)*(ushort *)(param_2 + (ulonglong)puVar2[5] * 2) +
                           (uint)*(ushort *)(param_2 + (ulonglong)puVar2[4] * 2) +
                           (uint)*(ushort *)(param_2 + (ulonglong)puVar2[3] * 2) +
                           (uint)*(ushort *)(param_2 + (ulonglong)puVar2[2] * 2) +
                          (uint)*(ushort *)(param_2 + (ulonglong)puVar2[9] * 2)) >> 3);
        break;
      default:
        goto switchD_18001737a_default;
      }
      uVar3 = uVar3 + 1;
      puVar2 = puVar2 + 10;
    } while (uVar3 < uVar1);
  }
switchD_18001737a_default:
  return;
}


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

### ADDR 180016ae0 FUNC 180016ae0 (617 bytes) name=FUN_180016ae0

void FUN_180016ae0(longlong param_1)

{
  DWORD DVar1;
  undefined8 uVar2;
  int *piVar3;
  longlong lVar4;
  longlong lVar5;
  ulonglong uVar6;
  uint uVar7;
  DWORD DVar8;
  bool bVar9;
  undefined8 local_48 [2];
  CFile local_38 [32];
  
  *(undefined4 *)(param_1 + 0x41348) = 0;
  uVar7 = 0;
  if (*(int *)(param_1 + 0x41558) != 2) {
    piVar3 = (int *)(param_1 + 0x41568);
    do {
      if (*(int *)(param_1 + 0x54) <= *piVar3) break;
      uVar7 = uVar7 + 1;
      piVar3 = piVar3 + 1;
    } while (uVar7 < *(int *)(param_1 + 0x41558) - 2U);
  }
  *(uint *)(param_1 + 0x41840) = uVar7;
  DVar8 = *(int *)(param_1 + 0x41560) +
          (*(int *)(param_1 + 0x41554) * 3 + -1) * *(int *)(param_1 + 0x47938) * 2 +
          *(int *)(param_1 + 0x4155c);
  do {
    if (*(int *)(param_1 + 0x41840) + 1U < uVar7) {
      uVar7 = *(uint *)(param_1 + 0x41840);
      lVar4 = (ulonglong)*(uint *)(param_1 + 0x41758 + (ulonglong)uVar7 * 4) +
              *(longlong *)(param_1 + 0x416a0);
      *(longlong *)(param_1 + 0x41848) = lVar4;
      lVar5 = (ulonglong)(uint)((*(int *)(param_1 + 0x41554) + -1) * *(int *)(param_1 + 0x47938)) +
              (ulonglong)(*(uint *)(param_1 + 0x4155c) >> 1);
      *(longlong *)(param_1 + 0x41860) = lVar4 + lVar5 * 2;
      lVar4 = (ulonglong)*(uint *)(param_1 + 0x41758 + (ulonglong)(uVar7 + 1) * 4) +
              *(longlong *)(param_1 + 0x416a0);
      *(longlong *)(param_1 + 0x41850) = lVar4;
      *(longlong *)(param_1 + 0x41868) = lVar4 + lVar5 * 2;
      *(ulonglong *)(param_1 + 0x41878) =
           (ulonglong)*(uint *)(param_1 + 0x417f4 + (ulonglong)uVar7 * 4) +
           *(longlong *)(param_1 + 0x416b0);
      return;
    }
    uVar6 = (ulonglong)uVar7;
    if (*(int *)(param_1 + 0x416b8 + uVar6 * 4) == 0) {
      FUN_180020138((undefined8 *)local_38);
      uVar2 = FUN_180020a6c((longlong)local_38,(LPCWSTR)(param_1 + 0x4134c),0x40,0);
      if ((int)uVar2 == 0) {
        FUN_1800203a4(local_38);
        return;
      }
      FUN_18001ef2c(local_48);
      CFile::Seek(local_38,(ulonglong)*(uint *)(param_1 + 0x41708 + uVar6 * 4),0);
      DVar1 = FUN_18001fd6c((longlong)local_38,
                            (LPVOID)((ulonglong)*(uint *)(param_1 + 0x41758 + uVar6 * 4) +
                                    *(longlong *)(param_1 + 0x416a0)),DVar8);
      bVar9 = DVar1 == DVar8;
      if ((*(int *)(param_1 + 0x41654 + uVar6 * 4) != 0) &&
         (uVar7 <= *(int *)(param_1 + 0x41558) - 2U)) {
        CFile::Seek(local_38,(ulonglong)*(uint *)(param_1 + 0x417a8 + uVar6 * 4),0);
        DVar1 = FUN_18001fd6c((longlong)local_38,
                              (LPVOID)((ulonglong)*(uint *)(param_1 + 0x417f4 + uVar6 * 4) +
                                      *(longlong *)(param_1 + 0x416b0)),
                              *(int *)(param_1 + 0x41654 + uVar6 * 4) * 0x28);
        if ((ulonglong)DVar1 != (ulonglong)(uint)(*(int *)(param_1 + 0x41654 + uVar6 * 4) * 10) << 2
           ) {
          bVar9 = false;
        }
      }
      FUN_18001ef94();
      CFile::Close(local_38);
      if (!bVar9) {
        FUN_1800203a4(local_38);
        return;
      }
      *(undefined4 *)(param_1 + 0x416b8 + uVar6 * 4) = 1;
      FUN_1800203a4(local_38);
    }
    uVar7 = uVar7 + 1;
  } while( true );
}


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

### ADDR 180016dd0 FUNC 180016dd0 (316 bytes) name=FUN_180016dd0

void FUN_180016dd0(longlong param_1,short *param_2,short *param_3,short *param_4,int param_5)

{
  short sVar1;
  bool bVar2;
  int iVar3;
  short sVar4;
  int iVar5;
  
  iVar3 = *(int *)(param_1 + 0x54);
  bVar2 = false;
  if ((iVar3 < *(int *)(param_1 + 0x41564)) ||
     (*(int *)(param_1 + 0x41564 + (ulonglong)(*(int *)(param_1 + 0x41558) - 1) * 4) < iVar3)) {
    bVar2 = true;
  }
  iVar5 = *(int *)(param_1 + 0x41564 + (ulonglong)*(uint *)(param_1 + 0x41840) * 4);
  iVar3 = ((iVar3 - iVar5) * 0x1000) /
          (*(int *)(param_1 + 0x41564 + (ulonglong)(*(uint *)(param_1 + 0x41840) + 1) * 4) - iVar5);
  if (iVar3 < 0x4000) {
    if (iVar3 < -0x3fff) {
      iVar3 = -0x3fff;
    }
  }
  else {
    iVar3 = 0x3fff;
  }
  if (bVar2) {
    for (; param_5 != 0; param_5 = param_5 + -1) {
      sVar4 = *param_2;
      sVar1 = *param_3;
      param_2 = param_2 + 1;
      param_3 = param_3 + 1;
      iVar5 = (((int)sVar1 - (int)sVar4) * iVar3 >> 0xc) + (int)sVar4;
      if (iVar5 < 0x8000) {
        sVar4 = (short)iVar5;
        if (iVar5 < -0x8000) {
          sVar4 = -0x8000;
        }
      }
      else {
        sVar4 = 0x7fff;
      }
      *param_4 = sVar4;
      param_4 = param_4 + 1;
    }
  }
  else if (param_5 != 0) {
    do {
      sVar4 = *param_2;
      sVar1 = *param_3;
      param_2 = param_2 + 1;
      param_3 = param_3 + 1;
      param_5 = param_5 + -1;
      *param_4 = (short)(((int)sVar1 - (int)sVar4) * iVar3 >> 0xc) + sVar4;
      param_4 = param_4 + 1;
    } while (param_5 != 0);
    return;
  }
  return;
}


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

### ADDR 180016f10 FUNC 180016f10 (289 bytes) name=FUN_180016f10

void FUN_180016f10(longlong param_1,ushort *param_2,ushort *param_3,short *param_4,int param_5)

{
  ushort uVar1;
  ushort uVar2;
  bool bVar3;
  int iVar4;
  short sVar5;
  int iVar6;
  
  iVar4 = *(int *)(param_1 + 0x54);
  bVar3 = false;
  if ((iVar4 < *(int *)(param_1 + 0x41564)) ||
     (*(int *)(param_1 + 0x41564 + (ulonglong)(*(int *)(param_1 + 0x41558) - 1) * 4) < iVar4)) {
    bVar3 = true;
  }
  iVar6 = *(int *)(param_1 + 0x41564 + (ulonglong)*(uint *)(param_1 + 0x41840) * 4);
  iVar4 = ((iVar4 - iVar6) * 0x1000) /
          (*(int *)(param_1 + 0x41564 + (ulonglong)(*(uint *)(param_1 + 0x41840) + 1) * 4) - iVar6);
  if (iVar4 < 0x4000) {
    if (iVar4 < -0x3fff) {
      iVar4 = -0x3fff;
    }
  }
  else {
    iVar4 = 0x3fff;
  }
  if (bVar3) {
    for (; param_5 != 0; param_5 = param_5 + -1) {
      uVar1 = *param_2;
      uVar2 = *param_3;
      param_2 = param_2 + 1;
      param_3 = param_3 + 1;
      iVar6 = ((int)(((uint)uVar2 - (uint)uVar1) * iVar4) >> 0xc) + (uint)uVar1;
      if (iVar6 < 0x10000) {
        sVar5 = (short)iVar6;
        if (iVar6 < 0) {
          sVar5 = 0;
        }
      }
      else {
        sVar5 = -1;
      }
      *param_4 = sVar5;
      param_4 = param_4 + 1;
    }
  }
  else {
    for (; param_5 != 0; param_5 = param_5 + -1) {
      uVar1 = *param_2;
      uVar2 = *param_3;
      param_2 = param_2 + 1;
      param_3 = param_3 + 1;
      *param_4 = (short)((int)(((uint)uVar2 - (uint)uVar1) * iVar4) >> 0xc) + uVar1;
      param_4 = param_4 + 1;
    }
  }
  return;
}


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

### ADDR 18000c760 FUNC 18000c760 (488 bytes) name=FUN_18000c760

void FUN_18000c760(longlong param_1,int param_2,uint param_3)

{
  int iVar1;
  int iVar2;
  uint uVar3;
  longlong lVar4;
  int iVar5;
  uint uVar6;
  int iVar7;
  
  EnterCriticalSection((LPCRITICAL_SECTION)(param_1 + 0x238));
  if ((*(int *)(param_1 + 0x228) != 0) && (*(int *)(param_1 + 0x41340) != 0)) {
    if (param_2 == 0) {
      FUN_180016ae0(param_1);
      if ((*(int *)(param_1 + 0x41340) != 0) && (*(int *)(param_1 + 0x41344) != 0)) {
        FUN_18000ffb0(param_1);
      }
    }
    else {
      uVar6 = 0;
      if (param_2 == 1) {
        if (1 < param_3) {
          DAT_18009a43c = 0;
          DAT_18009a438 = 0;
          DAT_18009a440 = (*(int *)(param_1 + 0x41554) + -1) * *(int *)(param_1 + 0x47938);
          DAT_18009a444 = *(int *)(param_1 + 0x47938) * *(int *)(param_1 + 0x41554) * 2;
          DAT_18009a448 =
               (DAT_18009a444 + DAT_18009a440 + -2 + param_3) / (param_3 - 1) + 7 & 0xfffffff8;
        }
      }
      else if (param_2 < 1) goto LAB_18000c92d;
      uVar3 = DAT_18009a448;
      iVar2 = DAT_18009a444;
      iVar1 = DAT_18009a43c;
      iVar5 = DAT_18009a438;
      if (DAT_18009a438 < DAT_18009a440) {
        lVar4 = (longlong)DAT_18009a438;
        uVar6 = DAT_18009a440 - DAT_18009a438;
        if ((int)DAT_18009a448 < DAT_18009a440 - DAT_18009a438) {
          uVar6 = DAT_18009a448;
        }
        FUN_180016dd0(param_1,(short *)(*(longlong *)(param_1 + 0x41848) + lVar4 * 2),
                      (short *)(*(longlong *)(param_1 + 0x41850) + lVar4 * 2),
                      (short *)(*(longlong *)(param_1 + 0x41858) + lVar4 * 2),uVar6);
        DAT_18009a438 = iVar5 + uVar6;
      }
      if (((int)uVar6 < (int)uVar3) && (iVar1 < iVar2)) {
        lVar4 = (longlong)iVar1;
        iVar7 = uVar3 - uVar6;
        iVar5 = iVar2 - iVar1;
        if (iVar7 < iVar2 - iVar1) {
          iVar5 = iVar7;
        }
        FUN_180016f10(param_1,(ushort *)(*(longlong *)(param_1 + 0x41860) + lVar4 * 2),
                      (ushort *)(*(longlong *)(param_1 + 0x41868) + lVar4 * 2),
                      (short *)(*(longlong *)(param_1 + 0x41870) + lVar4 * 2),iVar5);
        DAT_18009a43c = iVar1 + iVar5;
        if (DAT_18009a43c == iVar2) {
          *(undefined4 *)(param_1 + 0x41348) = 1;
        }
      }
    }
  }
LAB_18000c92d:
                    /* WARNING: Could not recover jumptable at 0x00018000c941. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  LeaveCriticalSection((LPCRITICAL_SECTION)(param_1 + 0x238));
  return;
}


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

### ADDR 18000c620 FUNC 18000c620 (309 bytes) name=FUN_18000c620

ulonglong FUN_18000c620(longlong param_1,ushort *param_2,int param_3)

{
  ulonglong uVar1;
  ulonglong uVar2;
  
  EnterCriticalSection((LPCRITICAL_SECTION)(param_1 + 0x238));
  if (*(int *)(param_1 + 0x228) == 0) {
    LeaveCriticalSection((LPCRITICAL_SECTION)(param_1 + 0x238));
    uVar1 = 0;
  }
  else {
    if (param_3 != 0) {
      *(undefined4 *)(param_1 + 0x22c) = 0;
      *(undefined4 *)(param_1 + 0x41ffc) = 0;
      *(undefined4 *)(param_1 + 0x42004) = 0;
      if (*(int *)(param_1 + 0x41f0c) != 0) {
        *(undefined4 *)(param_1 + 0x41f00) = 0;
      }
      if (*(int *)(param_1 + 0x41f3c) != 0) {
        *(undefined4 *)(param_1 + 0x41f30) = 0;
      }
      if ((1 < *(uint *)(param_1 + 0x41fe0)) && (*(int *)(param_1 + 0x41f7c) != 0)) {
        *(undefined4 *)(param_1 + 0x41f70) = 0;
        *(undefined8 *)(param_1 + 0x41f68) = *(undefined8 *)(param_1 + 0x41f50);
        FUN_1800357d0(*(ulonglong **)(param_1 + 0x41f58),0,
                      (ulonglong)*(uint *)(param_1 + 0x41f74) << 2);
      }
      if (*(int *)(param_1 + 0x41fbc) != 0) {
        *(undefined4 *)(param_1 + 0x41fb0) = 0;
        *(undefined8 *)(param_1 + 0x41fa8) = *(undefined8 *)(param_1 + 0x41f90);
        FUN_1800357d0(*(ulonglong **)(param_1 + 0x41f98),0,
                      (ulonglong)*(uint *)(param_1 + 0x41fb4) << 2);
      }
    }
    uVar2 = FUN_1800011a0(param_1 + 0x41ee0,param_2);
    uVar1 = uVar2 & 0xffffffff;
    if ((int)uVar2 != 0) {
      *(undefined4 *)(param_1 + 0x22c) = 1;
    }
    LeaveCriticalSection((LPCRITICAL_SECTION)(param_1 + 0x238));
  }
  return uVar1;
}


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

### ADDR 1800011a0 FUNC 1800011a0 (489 bytes) name=FUN_1800011a0

undefined8 FUN_1800011a0(longlong param_1,ushort *param_2)

{
  ushort uVar1;
  int iVar2;
  uint *puVar3;
  undefined2 *puVar4;
  ushort *puVar5;
  sbyte sVar6;
  uint uVar7;
  int iVar8;
  
  if (*(int *)(param_1 + 0x2c) == 0) {
    return 0;
  }
  *(int *)(param_1 + 0x20) = *(int *)(param_1 + 0x20) + 1;
  iVar8 = *(int *)(param_1 + 0x28);
  iVar2 = *(int *)(param_1 + 0x20);
  if (iVar8 != 1) {
    if (iVar8 != 2) {
      puVar3 = *(uint **)(param_1 + 0x18);
      if (iVar2 == 1) {
        for (uVar7 = *(uint *)(param_1 + 0x24) >> 2; uVar7 != 0; uVar7 = uVar7 - 1) {
          *puVar3 = (uint)*param_2;
          puVar3[1] = (uint)param_2[1];
          puVar3[2] = (uint)param_2[2];
          puVar3[3] = (uint)param_2[3];
          puVar3 = puVar3 + 4;
          param_2 = param_2 + 4;
        }
      }
      else if (iVar2 == iVar8) {
        if (iVar8 == 4) {
          sVar6 = 2;
        }
        else if (iVar8 == 8) {
          sVar6 = 3;
        }
        else if (iVar8 == 0x10) {
          sVar6 = 4;
        }
        else if (iVar8 == 0x20) {
          sVar6 = 5;
        }
        else {
          sVar6 = 0;
          if (iVar8 == 0x40) {
            sVar6 = 6;
          }
        }
        puVar4 = *(undefined2 **)(param_1 + 0x10);
        for (iVar8 = *(int *)(param_1 + 0x24); iVar8 != 0; iVar8 = iVar8 + -1) {
          uVar1 = *param_2;
          param_2 = param_2 + 1;
          uVar7 = *puVar3;
          *puVar4 = (short)(uVar1 + uVar7 >> sVar6);
          *puVar3 = uVar1 + uVar7;
          puVar3 = puVar3 + 1;
          puVar4 = puVar4 + 1;
        }
      }
      else {
        for (uVar7 = *(uint *)(param_1 + 0x24) >> 2; uVar7 != 0; uVar7 = uVar7 - 1) {
          *puVar3 = *puVar3 + (uint)*param_2;
          puVar3[1] = puVar3[1] + (uint)param_2[1];
          puVar3[2] = puVar3[2] + (uint)param_2[2];
          puVar3[3] = puVar3[3] + (uint)param_2[3];
          puVar3 = puVar3 + 4;
          param_2 = param_2 + 4;
        }
      }
      goto LAB_180001367;
    }
    if (iVar2 != 1) {
      puVar5 = *(ushort **)(param_1 + 0x10);
      for (uVar7 = *(uint *)(param_1 + 0x24) >> 2; uVar7 != 0; uVar7 = uVar7 - 1) {
        *puVar5 = (ushort)((int)((uint)*param_2 + (uint)*puVar5) >> 1);
        puVar5[1] = (ushort)((int)((uint)param_2[1] + (uint)puVar5[1]) >> 1);
        puVar5[2] = (ushort)((int)((uint)param_2[2] + (uint)puVar5[2]) >> 1);
        puVar5[3] = (ushort)((int)((uint)param_2[3] + (uint)puVar5[3]) >> 1);
        puVar5 = puVar5 + 4;
        param_2 = param_2 + 4;
      }
      goto LAB_180001367;
    }
  }
  memcpy(*(void **)(param_1 + 0x10),param_2,(ulonglong)*(uint *)(param_1 + 0x24) * 2);
LAB_180001367:
  if (*(int *)(param_1 + 0x20) != *(int *)(param_1 + 0x28)) {
    return 0;
  }
  *(undefined4 *)(param_1 + 0x20) = 0;
  return 1;
}


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

### ADDR 18001e920 FUNC 18001e920 (206 bytes) name=FUN_18001e920

bool FUN_18001e920(longlong param_1,ushort *param_2,int param_3)

{
  ushort uVar1;
  ushort uVar2;
  uint uVar3;
  uint uVar4;
  ushort *puVar5;
  int iVar6;
  int iVar7;
  
  if (*(int *)(param_1 + 0x3c) == 0) {
    return false;
  }
  *(int *)(param_1 + 0x30) = *(int *)(param_1 + 0x30) + 1;
  if (*(uint *)(param_1 + 0x38) < *(uint *)(param_1 + 0x30)) {
    if (*(uint *)(param_1 + 0x38) != 1) {
      return false;
    }
    puVar5 = *(ushort **)(param_1 + 0x10);
    for (iVar7 = *(int *)(param_1 + 0x34); iVar7 != 0; iVar7 = iVar7 + -1) {
      uVar1 = *puVar5;
      uVar2 = *param_2;
      *puVar5 = uVar2;
      iVar6 = (uint)uVar2 - (uint)uVar1;
      if (((iVar6 <= param_3) && (-iVar6 <= param_3)) && (iVar6 != 0)) {
        *param_2 = uVar2 - (short)(iVar6 >> 1);
      }
      param_2 = param_2 + 1;
      puVar5 = puVar5 + 1;
    }
  }
  else {
    memcpy(*(void **)(param_1 + 0x28),param_2,(ulonglong)*(uint *)(param_1 + 0x34) * 2);
  }
  uVar3 = *(uint *)(param_1 + 0x30);
  uVar4 = *(uint *)(param_1 + 0x38);
  if (uVar3 % uVar4 != 0) {
    *(longlong *)(param_1 + 0x28) =
         *(longlong *)(param_1 + 0x28) + (ulonglong)*(uint *)(param_1 + 0x34) * 2;
    return uVar4 <= uVar3;
  }
  *(undefined8 *)(param_1 + 0x28) = *(undefined8 *)(param_1 + 0x10);
  return uVar4 <= uVar3;
}


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

### ADDR 18000a1d2 FUNC 180009ee0 (1300 bytes) name=FUN_180009ee0

void FUN_180009ee0(uint param_1,longlong param_2)

{
  char cVar1;
  longlong lVar2;
  bool bVar3;
  uint uVar4;
  DWORD DVar5;
  int iVar6;
  __time64_t _Var7;
  ulonglong uVar8;
  byte *pbVar9;
  undefined7 extraout_var;
  uint uVar10;
  ulonglong uVar11;
  longlong lVar12;
  uint uVar13;
  int iVar14;
  undefined8 in_XMM1_Qa;
  uint local_res10 [2];
  undefined8 local_68;
  undefined8 local_60;
  undefined8 local_58;
  __time64_t local_50;
  undefined8 local_48;
  undefined8 local_40;
  undefined8 local_38;
  undefined8 local_30;
  
  uVar11 = (ulonglong)param_1;
  lVar12 = uVar11 * 0x4a8;
  if (*(int *)(&DAT_180073778 + lVar12) == 0) {
    return;
  }
  if ((*(uint *)(param_2 + 0xc) & 3) != 0) {
    if (*(int *)(param_2 + 0x14) != (&DAT_1800737b8)[uVar11 * 0x12a]) {
      return;
    }
    if (*(int *)(param_2 + 0x18) != *(int *)(&DAT_1800737bc + lVar12)) {
      return;
    }
  }
  if ((*(uint *)(param_2 + 0xc) & 4) != 0) {
    if (*(int *)(param_2 + 0x14) != *(int *)(&DAT_1800737f8 + lVar12)) {
      return;
    }
    if (*(int *)(param_2 + 0x18) != *(int *)(&DAT_1800737fc + lVar12)) {
      return;
    }
  }
  _Var7 = _time64((__time64_t *)0x0);
  *(int *)(&DAT_180073bf0 + lVar12) = *(int *)(&DAT_180073bf0 + lVar12) + 1;
  lVar2 = (&DAT_180073758)[uVar11 * 0x95];
  *(__time64_t *)(&DAT_180073810 + lVar12) = _Var7;
  *(undefined8 *)(&DAT_180073818 + lVar12) = 0;
  *(undefined8 *)(&DAT_180073820 + lVar12) = 0;
  *(undefined4 *)(&DAT_180073828 + lVar12) = 0;
  cVar1 = *(char *)(lVar2 + 0x2d47);
  if ((cVar1 == '\x01') || (cVar1 == '\x02')) {
    if (*(uint *)(&DAT_180073bf0 + lVar12) < 0x14) {
      return;
    }
  }
  else if ((cVar1 == '\x04') && (*(uint *)(&DAT_180073bf0 + lVar12) < 8)) {
    return;
  }
  *(int *)(param_2 + 0x28) = *(int *)(param_2 + 0x28) + (int)*(short *)(lVar2 + 0x2d86);
  *(int *)(param_2 + 0x2c) = *(int *)(param_2 + 0x2c) + (int)*(short *)(lVar2 + 0x2d86);
  *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0x60) = *(undefined4 *)(param_2 + 0x28);
  *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0x5c) = *(undefined4 *)(param_2 + 0x2c);
  iVar6 = *(int *)(&DAT_180073bec + lVar12);
  *(undefined4 *)(&DAT_180073800 + lVar12) = *(undefined4 *)(param_2 + 0x28);
  *(undefined4 *)(&DAT_180073804 + lVar12) = *(undefined4 *)(param_2 + 0x2c);
  if (iVar6 < 0) {
    FUN_180002f50(param_1);
    return;
  }
  uVar10 = iVar6 + 1;
  *(uint *)(&DAT_180073bec + lVar12) = uVar10;
  uVar13 = *(uint *)(lVar2 + 0x2d88);
  if (uVar10 <= uVar13) {
    FUN_18000c760((&DAT_180073750)[uVar11 * 0x95],iVar6,
                  *(int *)(lVar2 + 0x2d8c) + uVar13 + *(int *)(lVar2 + 0x2d78));
    return;
  }
  uVar4 = *(int *)(lVar2 + 0x2d78) + uVar13;
  if (uVar10 <= uVar4) {
    if (uVar10 == uVar4) {
      if (*(int *)((&DAT_180073758)[uVar11 * 0x95] + 0x14) == 0) {
        SetLastError(0xe4ae0005);
      }
      else {
        local_res10[0] = 0x6bb6b672;
        local_res10[1] = 1;
        FUN_18001c670((&DAT_180073758)[uVar11 * 0x95],local_res10,8);
      }
    }
    FUN_18000c620((&DAT_180073750)[uVar11 * 0x95],(ushort *)(param_2 + 0x4c),
                  (uint)(*(int *)(&DAT_180073bec + lVar12) == *(int *)(lVar2 + 0x2d88) + 1));
    FUN_18000c760((&DAT_180073750)[uVar11 * 0x95],*(int *)(&DAT_180073bec + lVar12) + -1,
                  *(int *)(lVar2 + 0x2d8c) + *(int *)(lVar2 + 0x2d78) + *(int *)(lVar2 + 0x2d88));
    return;
  }
  uVar13 = *(int *)(lVar2 + 0x2d78) + *(int *)(lVar2 + 0x2d8c) + uVar13;
  if (uVar10 <= uVar13) {
    FUN_18000c760((&DAT_180073750)[uVar11 * 0x95],iVar6,uVar13);
    return;
  }
  iVar14 = 0;
  switch(cVar1) {
  case '\0':
  case '\x03':
  case '\x05':
  case '\x06':
    if ((*(int *)(&DAT_180073bf4 + lVar12) == 0) && (iVar14 = 0, uVar10 == 0x4b)) {
      *(undefined4 *)(&DAT_180073bf4 + lVar12) = 1;
      iVar14 = iVar6 + -0x49;
    }
    iVar6 = 0x1e;
    break;
  case '\x01':
  case '\x02':
  case '\x04':
    if ((*(uint *)(&DAT_180073bf4 + lVar12) < 5) && (iVar14 = 0, uVar10 == 0x82 - uVar13)) {
      iVar14 = 1;
      *(uint *)(&DAT_180073bf4 + lVar12) = *(uint *)(&DAT_180073bf4 + lVar12) + 1;
    }
    iVar6 = 100;
    break;
  default:
    iVar6 = 100;
    goto LAB_18000a1d2;
  }
  if (iVar14 == 0) {
LAB_18000a1d2:
    if ((uVar10 < uVar13 + *(int *)(lVar2 + 0x2d90)) &&
       ((uVar10 < iVar6 + uVar13 ||
        (uVar13 = *(int *)((&DAT_180073750)[uVar11 * 0x95] + 0x54) - *(int *)(param_2 + 0x2c),
        uVar10 = (int)uVar13 >> 0x1f, (uVar13 ^ uVar10) - uVar10 <= *(uint *)(lVar2 + 0x2d94)))))
    goto LAB_18000a20a;
  }
  FUN_180002f50(param_1);
LAB_18000a20a:
  uVar8 = FUN_18000ca30((&DAT_180073750)[uVar11 * 0x95],in_XMM1_Qa,0,1,0);
  if ((uVar8 & 1) != 0) {
    if ((*(int *)((&DAT_180073768)[uVar11 * 0x95] + 0x44) != 0) &&
       (*(int *)(&DAT_180073ba4 + lVar12) = *(int *)(&DAT_180073ba4 + lVar12) + 1,
       *(int *)(&DAT_180073ba8 + lVar12) <= *(int *)(&DAT_180073ba4 + lVar12))) {
      *(undefined4 *)(&DAT_180073ba4 + lVar12) = 0;
      local_50 = 0;
      local_48 = 0;
      local_40 = 0;
      local_38 = 0;
      local_30 = 0;
      local_68 = 0x1010000000040;
      local_60 = *(undefined8 *)(&DAT_180073800 + lVar12);
      local_58 = *(undefined8 *)(&DAT_180073808 + lVar12);
      local_50 = _time64((__time64_t *)0x0);
      DVar5 = GetTickCount();
      local_48 = CONCAT44(*(undefined4 *)(param_2 + 0x38),DVar5);
      FUN_18001b1b0((&DAT_180073768)[uVar11 * 0x95],(longlong)&local_68,0x40,
                    *(longlong *)((&DAT_180073750)[uVar11 * 0x95] + 0x270),
                    *(int *)(param_2 + 0x18) * *(int *)(param_2 + 0x14) * 2);
    }
    if (*(int *)((&DAT_180073760)[uVar11 * 0x95] + 0x44) != 0) {
      pbVar9 = (byte *)FUN_1800110a0((&DAT_180073750)[uVar11 * 0x95]);
      lVar2 = (&DAT_180073750)[uVar11 * 0x95];
      if (((pbVar9 != (byte *)0x0) && (lVar2 + 0x6c8 != 0)) &&
         (iVar6 = (uint)*(ushort *)(lVar2 + 0x6d6) * *(int *)(lVar2 + 0x6d0) *
                  *(int *)(lVar2 + 0x6cc), iVar6 = iVar6 + (iVar6 >> 0x1f & 7U),
         uVar13 = iVar6 >> 0x1f,
         bVar3 = FUN_180001cd0((&DAT_180073760)[uVar11 * 0x95],pbVar9,(iVar6 >> 3 ^ uVar13) - uVar13
                               ,lVar2 + 0x6c8), (int)CONCAT71(extraout_var,bVar3) == 0)) {
        FUN_180001c50((&DAT_180073760)[uVar11 * 0x95]);
      }
    }
    if (*(code **)(&DAT_180073790 + lVar12) != (code *)0x0) {
      (**(code **)(&DAT_180073790 + lVar12))
                (param_1,*(undefined4 *)(param_2 + 0x28),*(undefined4 *)(param_2 + 0x38),
                 *(undefined4 *)(param_2 + 0x44),2,*(undefined8 *)(&DAT_180073770 + lVar12));
    }
  }
  return;
}


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

### ADDR 180002f50 FUNC 180002f50 (155 bytes) name=FUN_180002f50

undefined8 FUN_180002f50(uint param_1)

{
  undefined8 uVar1;
  ulonglong uVar2;
  uint local_res10 [6];
  
  uVar2 = (ulonglong)param_1;
  if (*(int *)((&DAT_180073758)[uVar2 * 0x95] + 0x14) == 0) {
    SetLastError(0xe4ae0005);
    return 0;
  }
  local_res10[0] = 0x6bb6b672;
  local_res10[1] = 0;
  uVar1 = FUN_18001c670((&DAT_180073758)[uVar2 * 0x95],local_res10,8);
  if ((int)uVar1 == 0) {
    return uVar1;
  }
  *(undefined4 *)((&DAT_180073750)[uVar2 * 0x95] + 0x58) =
       *(undefined4 *)((&DAT_180073750)[uVar2 * 0x95] + 0x60);
  *(undefined4 *)((&DAT_180073750)[uVar2 * 0x95] + 0x54) =
       *(undefined4 *)((&DAT_180073750)[uVar2 * 0x95] + 0x5c);
  *(undefined4 *)(&DAT_180073bec + uVar2 * 0x4a8) = 0;
  return 1;
}


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

### ADDR 180010780 FUNC 180010780 (273 bytes) name=FUN_180010780

void FUN_180010780(longlong param_1,ushort *param_2)

{
  ushort uVar1;
  uint uVar2;
  ulonglong uVar3;
  ulonglong uVar4;
  ulonglong uVar5;
  uint uVar6;
  ushort uVar8;
  uint uVar9;
  undefined4 uVar10;
  undefined4 uVar11;
  double dVar13;
  ulonglong uVar7;
  ulonglong uVar12;
  
  uVar2 = *(uint *)(param_1 + 0x47938);
  uVar8 = *param_2;
  uVar3 = 0;
  uVar10 = 0;
  uVar9 = (uint)uVar8;
  uVar5 = uVar3;
  uVar11 = uVar10;
  if (uVar2 != 0) {
    uVar4 = uVar3;
    uVar7 = uVar3;
    uVar12 = uVar3;
    do {
      uVar1 = *param_2;
      param_2 = param_2 + 1;
      uVar3 = uVar3 + uVar1;
      uVar5 = uVar5 + (uint)uVar1 * (uint)uVar1;
      if ((ushort)uVar9 < uVar1) {
        uVar9 = (uint)uVar1;
        uVar4 = uVar7;
      }
      else if (uVar1 < uVar8) {
        uVar12 = uVar7;
        uVar8 = uVar1;
      }
      uVar11 = (undefined4)uVar12;
      uVar10 = (undefined4)uVar4;
      uVar6 = (int)uVar7 + 1;
      uVar7 = (ulonglong)uVar6;
    } while (uVar6 < *(uint *)(param_1 + 0x47938));
  }
  *(uint *)(param_1 + 0x42010) = uVar9;
  *(uint *)(param_1 + 0x42014) = (uint)uVar8;
  *(undefined4 *)(param_1 + 0x42020) = uVar10;
  *(undefined4 *)(param_1 + 0x42024) = uVar11;
  *(int *)(param_1 + 0x42018) = (int)((longlong)uVar3 / (longlong)(ulonglong)uVar2);
  dVar13 = FUN_1800513c0(((double)(longlong)uVar5 -
                         ((double)(longlong)uVar3 * (double)(longlong)uVar3) / (double)uVar2) /
                         (double)(uVar2 - 1));
  *(int *)(param_1 + 0x4201c) = (int)dVar13;
  return;
}


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

### ADDR 180018f40 FUNC 180018e90 (798 bytes) name=FUN_180018e90

void FUN_180018e90(longlong param_1)

{
  byte bVar1;
  byte bVar2;
  byte bVar3;
  byte bVar4;
  int iVar5;
  ulonglong uVar6;
  undefined1 uVar7;
  int iVar8;
  undefined1 *puVar9;
  undefined1 *_Dst;
  uint uVar10;
  uint uVar11;
  void *_Src;
  byte *pbVar12;
  uint uVar13;
  byte *pbVar14;
  byte *pbVar15;
  uint local_res8;
  uint local_res10;
  
  _Src = *(void **)(param_1 + 0x2a0);
  local_res8 = 0;
  uVar10 = 0;
  puVar9 = (undefined1 *)
           (((ulonglong)(uint)((*(int *)(param_1 + 0x41fcc) + 3) * *(int *)(param_1 + 0x41fc8)) -
            (ulonglong)(uint)((*(int *)(param_1 + 0x41fc0) + 8) * (*(int *)(param_1 + 0x41fc4) + 1))
            ) + *(longlong *)(param_1 + 0x220));
  _Dst = puVar9;
  if (*(int *)(param_1 + 0x41fc4) != 0) {
    do {
      memcpy(_Dst,_Src,(ulonglong)*(uint *)(param_1 + 0x41fc0));
      iVar8 = (uint)*(byte *)((ulonglong)(*(int *)(param_1 + 0x41fc0) - 1) + (longlong)_Src) * 2 -
              (uint)*(byte *)((ulonglong)(*(int *)(param_1 + 0x41fc0) - 2) + (longlong)_Src);
      if (iVar8 < 0x100) {
        uVar7 = (undefined1)iVar8;
        if (iVar8 < 0) {
          uVar7 = 0;
        }
      }
      else {
        uVar7 = 0xff;
      }
      uVar10 = uVar10 + 1;
      _Dst[*(uint *)(param_1 + 0x41fc0)] = uVar7;
      _Src = (void *)((longlong)_Src + (ulonglong)*(uint *)(param_1 + 0x41fc0));
      _Dst = _Dst + (*(uint *)(param_1 + 0x41fc0) + 8);
    } while (uVar10 < *(uint *)(param_1 + 0x41fc4));
  }
  uVar6 = (ulonglong)(*(int *)(param_1 + 0x41fc0) + 8);
  pbVar12 = _Dst + -uVar6;
  pbVar14 = pbVar12 + -uVar6;
  for (iVar8 = *(int *)(param_1 + 0x41fc0) + 1; iVar8 != 0; iVar8 = iVar8 + -1) {
    bVar1 = *pbVar12;
    bVar2 = *pbVar14;
    pbVar14 = pbVar14 + 1;
    pbVar12 = pbVar12 + 1;
    iVar5 = (uint)bVar1 * 2 - (uint)bVar2;
    if (iVar5 < 0x100) {
      uVar7 = (undefined1)iVar5;
      if (iVar5 < 0) {
        uVar7 = 0;
      }
    }
    else {
      uVar7 = 0xff;
    }
    *_Dst = uVar7;
    _Dst = _Dst + 1;
  }
  if (*(int *)(param_1 + 0x41fc4) != 0) {
    uVar6 = 0;
    local_res10 = 0;
    do {
      pbVar12 = (byte *)((ulonglong)(uint)((int)(uVar6 >> 1) * *(int *)(param_1 + 0x41fc8)) +
                        *(longlong *)(param_1 + 0x220));
      pbVar14 = puVar9 + (*(uint *)(param_1 + 0x41fc0) + 8) * local_res8;
      for (uVar10 = *(uint *)(param_1 + 0x41fc0) >> 1; uVar10 != 0; uVar10 = uVar10 - 1) {
        uVar13 = (uint)*pbVar14;
        bVar1 = pbVar14[1];
        uVar6 = (ulonglong)*(uint *)(param_1 + 0x41fc0);
        uVar11 = (uint)pbVar14[uVar6 + 8];
        bVar2 = pbVar14[uVar6 + 10];
        bVar3 = pbVar14[2];
        iVar8 = (uint)pbVar14[uVar6 + 9] + (uint)pbVar14[uVar6 + 9];
        pbVar15 = pbVar12 + 3;
        *pbVar12 = *pbVar14 / 1;
        pbVar12[1] = (byte)(((uint)bVar1 + (uint)bVar1 + uVar13) * 0xab >> 9);
        pbVar12[2] = (byte)(((uint)bVar1 + (uint)bVar1 + (uint)bVar3) * 0xab >> 9);
        uVar6 = (ulonglong)*(uint *)(param_1 + 0x41fc8);
        pbVar15[uVar6 - 3] = (byte)((uVar11 * 2 + uVar13) * 0xab >> 9);
        pbVar15[uVar6 - 2] = (byte)((uVar13 + (iVar8 + uVar11 + (uint)bVar1) * 2) * 0x39 >> 9);
        pbVar15[uVar6 - 1] =
             (byte)(((uint)bVar3 + (iVar8 + (uint)bVar2 + (uint)bVar1) * 2) * 0x39 >> 9);
        pbVar12 = pbVar14 + (*(int *)(param_1 + 0x41fc0) * 2 + 0x10);
        uVar6 = (ulonglong)(uint)(*(int *)(param_1 + 0x41fc8) * 2);
        bVar1 = pbVar12[1];
        bVar3 = *pbVar12;
        bVar4 = pbVar12[2];
        pbVar15[uVar6 - 3] = (byte)((uVar11 * 2 + (uint)bVar3) * 0xab >> 9);
        pbVar15[uVar6 - 2] = (byte)(((uint)bVar3 + ((uint)bVar1 + iVar8 + uVar11) * 2) * 0x39 >> 9);
        pbVar15[uVar6 - 1] =
             (byte)(((uint)bVar4 + ((uint)bVar1 + iVar8 + (uint)bVar2) * 2) * 0x39 >> 9);
        pbVar12 = pbVar15;
        pbVar14 = pbVar14 + 2;
      }
      local_res8 = local_res8 + 2;
      local_res10 = local_res10 + 6;
      uVar6 = (ulonglong)local_res10;
    } while (local_res8 < *(uint *)(param_1 + 0x41fc4));
  }
  return;
}


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

### ADDR 18000c950 FUNC 18000c950 (221 bytes) name=FUN_18000c950

void FUN_18000c950(longlong param_1,ushort *param_2)

{
  undefined8 uVar1;
  ushort *puVar2;
  
  if (*(int *)(param_1 + 0x41fdc) == 1) {
    FUN_1800011a0(param_1 + 0x41f10,param_2);
    if (*(int *)(param_1 + 0x41f3c) == 0) {
      puVar2 = (ushort *)0x0;
    }
    else {
      puVar2 = *(ushort **)(param_1 + 0x41f20);
    }
    *(ushort **)(param_1 + 0x44c58) = puVar2;
    if ((*(int *)(param_1 + 0x41340) != 0) && (*(int *)(param_1 + 0x41348) != 0)) {
      FUN_180017200(param_1,puVar2);
      FUN_180017330(param_1,*(longlong *)(param_1 + 0x270));
      goto LAB_18000ca18;
    }
  }
  else {
    uVar1 = FUN_1800011a0(param_1 + 0x41f10,param_2);
    *(int *)(param_1 + 0x41ffc) = (int)uVar1;
    if ((int)uVar1 == 0) {
      return;
    }
    puVar2 = (ushort *)0x0;
    *(undefined4 *)(param_1 + 0x41ffc) = 0;
    if (*(int *)(param_1 + 0x41f3c) != 0) {
      puVar2 = *(ushort **)(param_1 + 0x41f20);
    }
    if ((*(int *)(param_1 + 0x41340) != 0) && (*(int *)(param_1 + 0x41348) != 0)) {
      FUN_180017200(param_1,puVar2);
      FUN_180017330(param_1,*(longlong *)(param_1 + 0x270));
      goto LAB_18000ca18;
    }
  }
  FUN_180017040(param_1,puVar2);
LAB_18000ca18:
  *(undefined4 *)(param_1 + 0x42004) = 1;
  return;
}


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

### ADDR 18000ca30 FUNC 18000ca30 (1760 bytes) name=FUN_18000ca30

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

undefined8
FUN_18000ca30(longlong param_1,undefined8 param_2,int param_3,undefined8 param_4,int param_5)

{
  byte *pbVar1;
  byte *pbVar2;
  byte *pbVar3;
  int *piVar4;
  ushort uVar5;
  byte *_Dst;
  undefined1 uVar6;
  DWORD DVar7;
  uint uVar8;
  uint uVar9;
  int iVar10;
  DWORD DVar11;
  undefined1 *puVar12;
  longlong lVar13;
  int iVar14;
  ushort *in_RDX;
  ulonglong uVar15;
  int iVar16;
  uint uVar17;
  int iVar18;
  ushort *puVar19;
  byte *pbVar20;
  undefined1 auStack_3518 [32];
  DWORD local_34f8;
  int local_34e8;
  ulonglong local_34e4 [63];
  int aiStack_32e8 [384];
  undefined1 local_2ce8 [11424];
  ulonglong local_48;
  
  local_48 = DAT_18006cea0 ^ (ulonglong)auStack_3518;
  EnterCriticalSection((LPCRITICAL_SECTION)(param_1 + 0x238));
  DVar7 = GetTickCount();
  local_34f8 = DVar7;
  if (((*(int *)(param_1 + 0x228) == 0) || (in_RDX == (ushort *)0x0)) ||
     ((param_3 == 0 && (*(int *)(param_1 + 0x22c) == 0)))) {
    LeaveCriticalSection((LPCRITICAL_SECTION)(param_1 + 0x238));
    return 0;
  }
  *(undefined4 *)(param_1 + 0x4203c) = 0;
  *(undefined4 *)(param_1 + 0x42040) = 0;
  *(undefined4 *)(param_1 + 0x42044) = 0;
  *(undefined4 *)(param_1 + 0x42004) = 0;
  if (param_3 == 0) {
    FUN_18000c950(param_1,in_RDX);
  }
  else {
    if (param_3 != 1) goto LAB_18000cb0b;
    memcpy(*(void **)(param_1 + 0x270),in_RDX,(ulonglong)*(uint *)(param_1 + 0x47938) * 2);
    *(undefined4 *)(param_1 + 0x42004) = 1;
  }
  if (*(int *)(param_1 + 0x42004) == 0) {
    FUN_18000d2a0(param_1);
LAB_18000cb0b:
    LeaveCriticalSection((LPCRITICAL_SECTION)(param_1 + 0x238));
    return 0;
  }
  *(undefined4 *)(param_1 + 0x44c4c) = 0;
  *(undefined4 *)(param_1 + 0x42038) = 0;
  if ((param_5 == 0) && (1 < *(uint *)(param_1 + 0x41fe0))) {
    uVar8 = FUN_180015680(param_1,30000,*(uint *)(param_1 + 0x50));
    FUN_18001e920(param_1 + 0x41f40,*(ushort **)(param_1 + 0x270),uVar8 & 0xffff);
    *(undefined4 *)(param_1 + 0x42038) = 1;
  }
  if (*(int *)(param_1 + 0x230) != 0) {
    FUN_1800175a0(param_1);
  }
  iVar10 = *(int *)(param_1 + 0x41fe8);
  if (iVar10 == 1) {
    FUN_1800184f0(param_1);
  }
  else if (iVar10 == 2) {
    FUN_180018660(param_1);
  }
  else if (iVar10 == 3) {
    FUN_1800184f0(param_1);
    FUN_180018660(param_1);
  }
  else if (iVar10 == 4) {
    FUN_180018660(param_1);
    FUN_180018660(param_1);
  }
  FUN_180010780(param_1,*(ushort **)(param_1 + 0x270));
  FUN_1800109c0(param_1);
  uVar8 = *(uint *)(param_1 + 0x30);
  if (uVar8 < 5) {
    if ((int)uVar8 < 1) goto LAB_18000cf9a;
  }
  else {
    uVar8 = 4;
  }
  if ((((*(int *)(param_1 + 0x4203c) != 0) && (*(int *)(param_1 + 0x28) == 0)) &&
      (*(int *)(param_1 + 0x10) == 0)) &&
     ((*(int *)(param_1 + 0x88) == 0 && (*(int *)(param_1 + 0x44) == 0)))) {
    if (*(int *)(param_1 + 0x84) == 0) {
      FUN_180017770(param_1,param_2);
      memcpy(local_2ce8,(void *)(param_1 + 0x41ff8),0x2ca0);
      FUN_180010780(param_1,*(ushort **)(param_1 + 0x288));
      if (*(int *)(param_1 + 0x42014) < *(int *)(param_1 + 0x42010)) {
        iVar10 = *(int *)(param_1 + 0x42018);
        uVar17 = *(int *)(param_1 + 0x42010) - iVar10;
        uVar8 = iVar10 - *(int *)(param_1 + 0x42014);
        uVar9 = FUN_180015680(param_1,30000,(uint)(*(int *)(param_1 + 0x24) * 1000) >> 1);
        puVar19 = *(ushort **)(param_1 + 0x288);
        if (uVar8 < uVar17) {
          uVar8 = uVar17;
        }
        uVar17 = uVar9 & 0xffff;
        if ((uVar9 & 0xffff) < uVar8) {
          uVar17 = uVar8;
        }
        puVar12 = *(undefined1 **)(param_1 + 0x280);
        uVar8 = 0;
        if (*(int *)(param_1 + 0x47938) != 0) {
          do {
            uVar5 = *puVar19;
            puVar19 = puVar19 + 1;
            uVar9 = ((uint)uVar5 - (iVar10 - uVar17)) * (int)(0x3fc00000 / (ulonglong)(uVar17 * 2))
                    >> 0x16;
            if (uVar9 < 0xc0) {
              uVar6 = (undefined1)uVar9;
              if (uVar9 < 0x3f) {
                uVar6 = 0x3f;
              }
            }
            else {
              uVar6 = 0xbf;
            }
            *puVar12 = uVar6;
            uVar8 = uVar8 + 1;
            puVar12 = puVar12 + 1;
          } while (uVar8 < *(uint *)(param_1 + 0x47938));
        }
        local_34e8 = 0;
        FUN_1800357d0(local_34e4,0,0x7fc);
        _Dst = *(byte **)(param_1 + 0x290);
        memcpy(_Dst,*(void **)(param_1 + 0x280),(ulonglong)*(uint *)(param_1 + 0x47938));
        uVar15 = (ulonglong)*(uint *)(param_1 + 0x41fc0);
        puVar12 = (undefined1 *)(uVar15 + 1 + *(longlong *)(param_1 + 0x280));
        pbVar1 = _Dst + 1;
        pbVar2 = pbVar1 + uVar15;
        pbVar3 = pbVar2 + uVar15;
        iVar10 = (*(int *)(param_1 + 0x41fc4) + -2) * *(uint *)(param_1 + 0x41fc0) + -2;
        if (0 < iVar10) {
          pbVar20 = pbVar3 + 1;
          iVar18 = (uint)pbVar2[uVar15 - 1] + (uint)pbVar1[uVar15 - 1] * 2 + (uint)*_Dst;
          iVar16 = (uint)*pbVar3 + (uint)*pbVar2 * 2 + (uint)*pbVar1;
          do {
            iVar14 = (uint)pbVar20[(longlong)pbVar1 - (longlong)pbVar3] +
                     (uint)pbVar20[(longlong)pbVar2 - (longlong)pbVar3] * 2 + (uint)*pbVar20;
            uVar8 = (uint)(iVar14 + iVar16 * 2 + iVar18) >> 4;
            *puVar12 = (char)uVar8;
            if (0x7f < uVar8) {
              piVar4 = (int *)((longlong)local_34e4 +
                              (longlong)
                              (int)(pbVar20[*(longlong *)(param_1 + 0x2a0) + (-1 - (longlong)pbVar3)
                                           ] + uVar8) * 4 + -4);
              *piVar4 = *piVar4 + 1;
            }
            pbVar20 = pbVar20 + 1;
            puVar12 = puVar12 + 1;
            iVar18 = iVar16;
            iVar16 = iVar14;
          } while ((longlong)(pbVar20 + (-1 - (longlong)pbVar3)) < (longlong)iVar10);
        }
        uVar8 = 0;
        if (*(int *)(param_1 + 0x41fc4) != 0) {
          do {
            uVar9 = *(int *)(param_1 + 0x41fc0) * uVar8;
            *(byte *)((ulonglong)uVar9 + *(longlong *)(param_1 + 0x280)) = _Dst[uVar9];
            uVar8 = uVar8 + 1;
            uVar9 = uVar8 * *(int *)(param_1 + 0x41fc0) - 1;
            *(byte *)((ulonglong)uVar9 + *(longlong *)(param_1 + 0x280)) = _Dst[uVar9];
          } while (uVar8 < *(uint *)(param_1 + 0x41fc4));
        }
        iVar18 = 0x1ff;
        iVar10 = 0;
        lVar13 = 0x1ff;
        do {
          iVar10 = iVar10 + *(int *)((longlong)local_34e4 + lVar13 * 4 + -4);
          if (*(uint *)(param_1 + 0x47938) < (uint)(iVar10 * 0x800)) break;
          lVar13 = lVar13 + -1;
          iVar18 = iVar18 + -1;
        } while (0x17d < lVar13);
        iVar10 = 0x1000;
        if (0x17e < iVar18) {
          iVar10 = (int)(0xff000 / (longlong)(iVar18 + -0x7f));
        }
        uVar8 = 0;
        lVar13 = 0;
        if (*(uint *)(param_1 + 0x47938) != 0) {
          do {
            iVar18 = ((*(byte *)(lVar13 + *(longlong *)(param_1 + 0x280)) - 0x7f) +
                     (uint)*(byte *)(*(longlong *)(param_1 + 0x2a0) + lVar13)) * iVar10;
            iVar18 = (int)(iVar18 + (iVar18 >> 0x1f & 0xfffU)) >> 0xc;
            if (iVar18 < 0) {
              iVar18 = 0;
            }
            else if (0xff < iVar18) {
              iVar18 = 0xff;
            }
            *(char *)(*(longlong *)(param_1 + 0x2a0) + lVar13) = (char)iVar18;
            uVar8 = uVar8 + 1;
            lVar13 = lVar13 + 1;
          } while (uVar8 < *(uint *)(param_1 + 0x47938));
        }
      }
      memcpy((void *)(param_1 + 0x41ff8),local_2ce8,0x2ca0);
      DVar7 = local_34f8;
    }
    else {
      FUN_180017c40(param_1,uVar8 << 3);
    }
  }
LAB_18000cf9a:
  uVar8 = *(uint *)(param_1 + 0x41fc8);
  uVar9 = *(uint *)(param_1 + 0x41fc0);
  if ((uVar8 == uVar9) && (*(int *)(param_1 + 0x41fcc) == *(int *)(param_1 + 0x41fc4))) {
    memcpy(*(void **)(param_1 + 0x220),*(void **)(param_1 + 0x2a0),
           (ulonglong)*(uint *)(param_1 + 0x47938));
  }
  else if ((uVar8 == uVar9 * 2) && (*(int *)(param_1 + 0x41fcc) == *(int *)(param_1 + 0x41fc4) * 2))
  {
    FUN_180019740(param_1);
  }
  else if ((uVar8 == uVar9 * 4) && (*(int *)(param_1 + 0x41fcc) == *(int *)(param_1 + 0x41fc4) << 2)
          ) {
    FUN_180019b30(param_1);
  }
  else if ((uVar8 == uVar9 * 8) && (*(int *)(param_1 + 0x41fcc) == *(int *)(param_1 + 0x41fc4) << 3)
          ) {
    FUN_180019e60(param_1);
  }
  else if ((uVar8 * 2 == uVar9 * 3) &&
          (*(int *)(param_1 + 0x41fcc) * 2 == *(int *)(param_1 + 0x41fc4) * 3)) {
    FUN_180018e90(param_1);
  }
  else if ((uVar8 * 3 == uVar9 * 5) &&
          (*(int *)(param_1 + 0x41fcc) * 3 == *(int *)(param_1 + 0x41fc4) * 5)) {
    FUN_1800191b0(param_1);
  }
  else if ((uVar9 < uVar8) && (*(uint *)(param_1 + 0x41fc4) < *(uint *)(param_1 + 0x41fcc))) {
    FUN_18001a750(param_1);
  }
  DVar11 = GetTickCount();
  *(DWORD *)(param_1 + 0x42048) = DVar11 - DVar7;
  FUN_18000d2a0(param_1);
  *(undefined4 *)(param_1 + 0x234) = 1;
  LeaveCriticalSection((LPCRITICAL_SECTION)(param_1 + 0x238));
  return 3;
}


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

### ADDR 180017040 FUNC 180017040 (413 bytes) name=FUN_180017040

void FUN_180017040(longlong param_1,ushort *param_2)

{
  int *piVar1;
  int iVar2;
  int iVar3;
  undefined **ppuVar4;
  int iVar5;
  int iVar6;
  ushort *puVar7;
  int iVar8;
  undefined2 *puVar9;
  uint uVar10;
  ulonglong uVar11;
  ushort *puVar12;
  longlong local_res8;
  
  iVar2 = DAT_18006ea60;
  puVar7 = (ushort *)0x0;
  iVar8 = 0;
  puVar12 = puVar7;
  if (*(int *)(param_1 + 0x41f0c) != 0) {
    puVar12 = *(ushort **)(param_1 + 0x41ef0);
  }
  puVar9 = *(undefined2 **)(param_1 + 0x270);
  if (*(int *)(param_1 + 0x47950) == 0) {
    iVar3 = 50000 - *(int *)(param_1 + 0x47948) >> ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f)
    ;
    if (iVar3 < 0) {
      iVar3 = iVar8;
    }
  }
  else {
    iVar3 = (DAT_1800990c4 - DAT_1800990c0) * 0xd40;
    iVar3 = ((int)((iVar3 >> 0x1f & 0xfffU) + iVar3) >> 0xc) + DAT_1800990c0;
    if (iVar3 < 0) {
      iVar3 = iVar8;
    }
    iVar3 = iVar3 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
  }
  iVar6 = iVar8;
  for (uVar10 = *(uint *)(param_1 + 0x47938); uVar11 = (ulonglong)uVar10, uVar10 != 0;
      uVar10 = uVar10 - 1) {
    iVar5 = ((uint)*param_2 - (uint)*puVar12) * iVar2 + iVar3;
    puVar12 = puVar12 + 1;
    param_2 = param_2 + 1;
    if (iVar5 < 0x10000) {
      if (iVar5 < 0) {
        puVar7 = (ushort *)(ulonglong)((int)puVar7 + 1);
        iVar5 = iVar8;
      }
    }
    else {
      puVar7 = (ushort *)(ulonglong)((int)puVar7 + 1);
      iVar5 = 0xffff;
    }
    iVar6 = (int)puVar7;
    *puVar9 = (short)iVar5;
    puVar9 = puVar9 + 1;
  }
  if (((*(int *)(param_1 + 0xfc) != 0) && (0x100 < iVar6)) && (1 < iVar2)) {
    DAT_18006ea60 = iVar2 + -1;
    ppuVar4 = FUN_18001fcc0();
    if (ppuVar4 == (undefined **)0x0) {
                    /* WARNING: Subroutine does not return */
      FUN_18000b170(-0x7fffbffb);
    }
    local_res8 = (**(code **)(*ppuVar4 + 0x18))(ppuVar4);
    local_res8 = local_res8 + 0x18;
    FUN_18001ad00(&local_res8,L"Converstation ratio adjusted to %dmK/LSB.",
                  (ulonglong)(uint)(*(int *)(param_1 + 0x47944) * DAT_18006ea60),uVar11);
    LOCK();
    piVar1 = (int *)(local_res8 + -8);
    iVar2 = *piVar1;
    *piVar1 = *piVar1 + -1;
    UNLOCK();
    if (iVar2 + -1 < 1) {
      (**(code **)(**(longlong **)(local_res8 + -0x18) + 8))();
    }
  }
  return;
}


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

### ADDR 1800109c0 FUNC 1800109c0 (640 bytes) name=FUN_1800109c0

void FUN_1800109c0(longlong param_1)

{
  uint uVar1;
  uint uVar2;
  int iVar3;
  
  if (*(int *)(param_1 + 0x42014) == *(int *)(param_1 + 0x42010)) {
    *(int *)(param_1 + 0x4202c) = *(int *)(param_1 + 0x42010);
    *(int *)(param_1 + 0x42030) = *(int *)(param_1 + 0x42014);
    FUN_1800357d0((ulonglong *)(param_1 + 0x4284c),0x80,0x400);
    FUN_1800357d0(*(ulonglong **)(param_1 + 0x2a0),0x80,(ulonglong)*(uint *)(param_1 + 0x47938));
    FUN_1800357d0((ulonglong *)(param_1 + 0x4204c),0,0x400);
    *(undefined4 *)(param_1 + 0x4224c) = *(undefined4 *)(param_1 + 0x47938);
    FUN_1800357d0((ulonglong *)(param_1 + 0x42c4c),0,0x1000);
    *(undefined4 *)(param_1 + 0x4344c) = *(undefined4 *)(param_1 + 0x47938);
    FUN_1800357d0(*(ulonglong **)(param_1 + 0x2b0),0x80,(ulonglong)*(uint *)(param_1 + 0x47940));
    *(undefined4 *)(param_1 + 0x4203c) = 1;
    return;
  }
  if (*(int *)(param_1 + 0x10) == 0) {
    iVar3 = *(int *)(param_1 + 0x42018);
    if (*(int *)(param_1 + 0x88) != 0) {
      FUN_180011380(param_1);
      iVar3 = *(int *)(param_1 + 0x44c64);
    }
    uVar1 = FUN_1800108a0(param_1);
    uVar2 = iVar3 - (uVar1 >> 1);
    if (*(uint *)(param_1 + 0x42014) < uVar2) {
      uVar2 = *(uint *)(param_1 + 0x42014);
    }
    uVar1 = (uVar1 >> 1) + iVar3;
    *(uint *)(param_1 + 0x42030) = uVar2;
    if (uVar1 < *(uint *)(param_1 + 0x42010)) {
      uVar1 = *(uint *)(param_1 + 0x42010);
    }
    *(uint *)(param_1 + 0x4202c) = uVar1;
    if ((int)uVar2 < 0) {
      *(undefined4 *)(param_1 + 0x42030) = 0;
    }
    if (0xffff < (int)uVar1) {
      *(undefined4 *)(param_1 + 0x4202c) = 0xffff;
    }
    if (*(int *)(param_1 + 0x90) == 0) {
      FUN_180011ee0(param_1,*(ushort **)(param_1 + 0x270));
    }
    else {
      FUN_180011cc0(param_1);
    }
    if (*(int *)(param_1 + 0x28) == 0) {
      if (*(int *)(param_1 + 0x44c50) != 0) {
        memcpy((void *)(param_1 + 0x6f0),(void *)(param_1 + 0x2c8),0x400);
        memcpy((void *)(param_1 + 0xb18),(void *)(param_1 + 0x2c8),0x400);
        memcpy((void *)(param_1 + 0xf40),(void *)(param_1 + 0x2c8),0x400);
        *(undefined4 *)(param_1 + 0x44c50) = 0;
      }
    }
    else {
      FUN_180010c40(param_1);
      *(undefined4 *)(param_1 + 0x44c50) = 1;
    }
  }
  else {
    FUN_1800110e0(param_1);
    if (*(int *)(param_1 + 0x44c50) != 0) {
      memcpy((void *)(param_1 + 0x6f0),(void *)(param_1 + 0x2c8),0x400);
      memcpy((void *)(param_1 + 0xb18),(void *)(param_1 + 0x2c8),0x400);
      memcpy((void *)(param_1 + 0xf40),(void *)(param_1 + 0x2c8),0x400);
      *(undefined4 *)(param_1 + 0x44c50) = 0;
    }
  }
  FUN_180010e80(param_1);
  return;
}


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

### ADDR 180017770 FUNC 180017770 (1228 bytes) name=FUN_180017770

/* WARNING: Function: __chkstk replaced with injection: alloca_probe */

void FUN_180017770(longlong param_1,undefined8 param_2)

{
  undefined2 *puVar1;
  longlong lVar2;
  ushort uVar3;
  uint uVar4;
  uint uVar5;
  uint uVar6;
  uint uVar7;
  uint uVar8;
  uint uVar9;
  uint uVar10;
  uint uVar11;
  uint uVar12;
  uint uVar13;
  uint uVar14;
  uint uVar15;
  uint uVar16;
  uint uVar17;
  uint uVar18;
  undefined2 *puVar19;
  undefined2 *puVar20;
  undefined4 *puVar21;
  longlong lVar22;
  longlong lVar23;
  undefined2 uVar24;
  uint uVar25;
  int iVar26;
  ulonglong uVar27;
  float *pfVar28;
  int iVar29;
  ulonglong uVar30;
  longlong lVar31;
  ulonglong uVar32;
  ulonglong uVar33;
  float fVar34;
  float fVar35;
  float fVar36;
  float fVar37;
  float fVar38;
  undefined4 uVar39;
  float fVar40;
  float afStack_40068 [4];
  float afStack_40058 [65548];
  
  uVar39 = (undefined4)((ulonglong)param_2 >> 0x20);
  puVar20 = *(undefined2 **)(param_1 + 0x270);
  uVar30 = 0;
  puVar19 = (undefined2 *)(*(longlong *)(param_1 + 0x290) + 2);
  uVar18 = 0;
  uVar32 = uVar30;
  if (*(int *)(param_1 + 0x41fc4) != -6) {
    do {
      uVar24 = *puVar20;
      puVar19[2] = uVar24;
      puVar19[1] = uVar24;
      *puVar19 = uVar24;
      memcpy(puVar19 + 3,puVar20,(ulonglong)*(uint *)(param_1 + 0x41fc0) * 2);
      puVar1 = puVar19 + (ulonglong)*(uint *)(param_1 + 0x41fc0) + 3;
      uVar24 = puVar20[*(uint *)(param_1 + 0x41fc0) - 1];
      puVar19 = puVar1 + 3;
      uVar17 = (uint)uVar32;
      puVar1[2] = uVar24;
      puVar1[1] = uVar24;
      *puVar1 = uVar24;
      if ((2 < (int)uVar17) && (uVar17 <= *(int *)(param_1 + 0x41fc4) + 1U)) {
        puVar20 = puVar20 + *(uint *)(param_1 + 0x41fc0);
      }
      uVar32 = (ulonglong)(uVar17 + 1);
    } while (uVar17 + 1 < *(int *)(param_1 + 0x41fc4) + 6U);
  }
  fVar34 = DAT_18005e70c;
  uVar32 = 0;
  if (DAT_18009a450 == 0.0) {
    uVar33 = uVar30;
    puVar21 = &DAT_18009a450;
    do {
      uVar32 = FUN_180050fc0(CONCAT44((int)(uVar32 >> 0x20),(float)(int)uVar33 / fVar34));
      uVar17 = (int)uVar33 - 1;
      uVar33 = (ulonglong)uVar17;
      *puVar21 = (int)uVar32;
      fVar40 = DAT_18005e708;
      puVar21 = puVar21 + 1;
    } while (-0x13 < (int)uVar17);
    uVar32 = uVar30;
    puVar21 = &DAT_18009a4a0;
    do {
      fVar34 = (float)(int)uVar32;
      uVar33 = FUN_180050fc0(CONCAT44(uVar39,fVar34 * fVar40 * fVar34));
      uVar17 = (int)uVar32 + 1;
      uVar32 = (ulonglong)uVar17;
      *puVar21 = (int)uVar33;
      puVar21 = puVar21 + 1;
    } while ((int)uVar17 < 0x10001);
  }
  uVar17 = *(int *)(param_1 + 0x42010) - *(int *)(param_1 + 0x42014);
  uVar32 = uVar30;
  if (3 < (int)(uVar17 + 1)) {
    uVar25 = 0x20000;
    uVar18 = uVar17 + 1 >> 2;
    uVar27 = (ulonglong)uVar18;
    uVar18 = uVar18 * 4;
    uVar33 = uVar30;
    do {
      uVar32 = uVar33 + 4;
      afStack_40068[uVar32] =
           (float)(&DAT_18009a4a0)[(ulonglong)(uVar25 - 0x20000) / (ulonglong)uVar17];
      afStack_40068[uVar33 + 5] =
           (float)(&DAT_18009a4a0)[(ulonglong)(uVar25 - 0x10000) / (ulonglong)uVar17];
      afStack_40068[uVar33 + 6] = (float)(&DAT_18009a4a0)[(ulonglong)uVar25 / (ulonglong)uVar17];
      uVar4 = uVar25 + 0x10000;
      uVar25 = uVar25 + 0x40000;
      uVar27 = uVar27 - 1;
      afStack_40068[uVar33 + 7] = (float)(&DAT_18009a4a0)[(ulonglong)uVar4 / (ulonglong)uVar17];
      uVar33 = uVar32;
    } while (uVar27 != 0);
    if (uVar17 < uVar18) goto LAB_1800179bd;
  }
  uVar25 = uVar18 << 0x10;
  uVar33 = (ulonglong)((uVar17 - uVar18) + 1);
  pfVar28 = afStack_40068 + uVar32 + 4;
  do {
    uVar32 = (ulonglong)uVar25;
    uVar25 = uVar25 + 0x10000;
    uVar33 = uVar33 - 1;
    *pfVar28 = (float)(&DAT_18009a4a0)[uVar32 / uVar17];
    pfVar28 = pfVar28 + 1;
  } while (uVar33 != 0);
LAB_1800179bd:
  uVar18 = *(uint *)(param_1 + 0x41fc0);
  puVar20 = *(undefined2 **)(param_1 + 0x288);
  lVar2 = *(longlong *)(param_1 + 0x290) + 8 + (ulonglong)(uVar18 * 3 + 0x12) * 2;
  if (*(int *)(param_1 + 0x41fc4) != 0) {
    do {
      uVar17 = 0;
      iVar29 = (int)uVar30;
      if (uVar18 != 0) {
        do {
          iVar26 = uVar18 + 6;
          fVar34 = 0.0;
          fVar40 = 0.0;
          lVar31 = -3;
          uVar18 = iVar26 * (iVar29 + -3);
          uVar3 = *(ushort *)(lVar2 + (ulonglong)(iVar26 * iVar29 + uVar17) * 2);
          uVar25 = (uint)uVar3;
          do {
            lVar23 = (ulonglong)uVar18 + (longlong)(int)uVar17;
            lVar22 = lVar31 * lVar31;
            uVar7 = (uint)*(ushort *)(lVar2 + -6 + lVar23 * 2);
            uVar4 = uVar25 - uVar7;
            uVar10 = (int)uVar4 >> 0x1f;
            uVar8 = (uint)*(ushort *)(lVar2 + -4 + lVar23 * 2);
            uVar5 = uVar3 - uVar8;
            uVar11 = (int)uVar5 >> 0x1f;
            uVar9 = (uint)*(ushort *)(lVar2 + -2 + lVar23 * 2);
            uVar6 = uVar25 - uVar9;
            uVar12 = (int)uVar6 >> 0x1f;
            fVar35 = afStack_40068[(longlong)(int)((uVar5 ^ uVar11) - uVar11) + 4] *
                     *(float *)(lVar22 * 4 + 0x18009a460);
            fVar36 = afStack_40068[(longlong)(int)((uVar6 ^ uVar12) - uVar12) + 4] *
                     *(float *)(lVar22 * 4 + 0x18009a454);
            uVar11 = (uint)*(ushort *)(lVar2 + lVar23 * 2);
            uVar5 = uVar25 - uVar11;
            uVar13 = (int)uVar5 >> 0x1f;
            uVar12 = (uint)*(ushort *)(lVar2 + 2 + lVar23 * 2);
            uVar6 = uVar25 - uVar12;
            uVar14 = (int)uVar6 >> 0x1f;
            fVar37 = afStack_40068[(longlong)(int)((uVar6 ^ uVar14) - uVar14) + 4] *
                     *(float *)(lVar22 * 4 + 0x18009a454);
            uVar14 = (uint)*(ushort *)(lVar2 + 4 + lVar23 * 2);
            uVar6 = uVar25 - uVar14;
            uVar15 = (int)uVar6 >> 0x1f;
            fVar38 = afStack_40068[(longlong)(int)((uVar6 ^ uVar15) - uVar15) + 4] *
                     *(float *)(lVar22 * 4 + 0x18009a460);
            uVar15 = (uint)*(ushort *)(lVar2 + 6 + lVar23 * 2);
            uVar6 = uVar25 - uVar15;
            lVar31 = lVar31 + 1;
            uVar16 = (int)uVar6 >> 0x1f;
            uVar18 = uVar18 + iVar26;
            fVar40 = fVar40 + afStack_40068[(longlong)(int)((uVar4 ^ uVar10) - uVar10) + 4] *
                              (float)(&DAT_18009a474)[lVar22] + fVar35 + fVar36 +
                     afStack_40068[(longlong)(int)((uVar5 ^ uVar13) - uVar13) + 4] *
                     (&DAT_18009a450)[lVar22] + fVar37 + fVar38 +
                     afStack_40068[(longlong)(int)((uVar6 ^ uVar16) - uVar16) + 4] *
                     (float)(&DAT_18009a474)[lVar22];
            fVar34 = fVar34 + (float)uVar7 *
                              afStack_40068[(longlong)(int)((uVar4 ^ uVar10) - uVar10) + 4] *
                              (float)(&DAT_18009a474)[lVar22] + (float)uVar8 * fVar35 +
                     (float)uVar9 * fVar36 +
                     (float)uVar11 *
                     afStack_40068[(longlong)(int)((uVar5 ^ uVar13) - uVar13) + 4] *
                     (&DAT_18009a450)[lVar22] + (float)uVar12 * fVar37 + (float)uVar14 * fVar38 +
                     (float)uVar15 *
                     afStack_40068[(longlong)(int)((uVar6 ^ uVar16) - uVar16) + 4] *
                     (float)(&DAT_18009a474)[lVar22];
          } while (lVar31 < 4);
          iVar26 = (uVar25 - (int)(fVar34 / fVar40)) + 0x8000;
          if (iVar26 < 0x10000) {
            uVar24 = (undefined2)iVar26;
            if (iVar26 < 0) {
              uVar24 = 0;
            }
          }
          else {
            uVar24 = 0;
          }
          *puVar20 = uVar24;
          uVar17 = uVar17 + 1;
          uVar18 = *(uint *)(param_1 + 0x41fc0);
          puVar20 = puVar20 + 1;
        } while (uVar17 < uVar18);
      }
      uVar30 = (ulonglong)(iVar29 + 1U);
    } while (iVar29 + 1U < *(uint *)(param_1 + 0x41fc4));
  }
  return;
}


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

### ADDR 180017c40 FUNC 180017c40 (905 bytes) name=FUN_180017c40

void FUN_180017c40(longlong param_1,int param_2)

{
  ushort uVar1;
  ushort uVar2;
  ushort uVar3;
  byte bVar4;
  int iVar5;
  uint uVar6;
  ulonglong uVar7;
  int iVar8;
  ushort *puVar9;
  int iVar10;
  uint uVar11;
  int iVar12;
  uint uVar13;
  uint uVar14;
  uint uVar15;
  int *piVar16;
  byte *pbVar17;
  ushort uVar18;
  uint uVar19;
  ushort *puVar20;
  int *piVar21;
  longlong lVar22;
  uint local_res18;
  
  if (param_2 != 0) {
    FUN_1800357d0(*(ulonglong **)(param_1 + 0x2a8),0,(ulonglong)*(uint *)(param_1 + 0x47938) << 2);
    uVar19 = *(int *)(param_1 + 0x24) * 1000;
    if (*(int *)(param_1 + 0x47950) == 0) {
      uVar19 = uVar19 >> ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
      uVar18 = (ushort)uVar19;
      if (0xffff < uVar19) {
        uVar18 = 0xffff;
      }
    }
    else {
      iVar5 = FUN_180015940(param_1,30000,uVar19);
      iVar5 = iVar5 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
      if (0xffff < iVar5) {
        iVar5 = 0xffff;
      }
      uVar18 = (ushort)iVar5;
    }
    local_res18 = 0;
    uVar19 = ((uint)uVar18 * param_2 & 0x7fffffff) >> 7;
    if (*(int *)(param_1 + 0x41fc4) != 6) {
      do {
        iVar5 = *(int *)(param_1 + 0x41fc0) + -6;
        iVar12 = *(int *)(param_1 + 0x41fc0) * local_res18;
        if (iVar5 != 0) {
          lVar22 = (longlong)iVar12 * 2;
          do {
            uVar11 = (uint)*(ushort *)(lVar22 + 2 + *(longlong *)(param_1 + 0x270));
            puVar20 = (ushort *)(lVar22 + *(longlong *)(param_1 + 0x270));
            piVar16 = (int *)(*(longlong *)(param_1 + 0x2a8) + (longlong)iVar12 * 4);
            uVar15 = (uint)*puVar20;
            puVar9 = puVar20;
            uVar13 = 0;
            iVar10 = 4;
            do {
              iVar8 = iVar10;
              uVar18 = *puVar9;
              uVar6 = (uint)uVar18;
              uVar14 = uVar6;
              if ((uVar18 < uVar11 || uVar6 == uVar11) && (uVar14 = uVar11, uVar6 < uVar15)) {
                uVar15 = uVar6;
              }
              uVar1 = puVar9[2];
              uVar6 = (uint)uVar1;
              uVar11 = uVar6;
              if ((uVar1 < uVar14 || uVar6 == uVar14) && (uVar11 = uVar14, uVar6 < uVar15)) {
                uVar15 = uVar6;
              }
              uVar2 = puVar9[4];
              uVar6 = (uint)uVar2;
              uVar14 = uVar6;
              if ((uVar2 < uVar11 || uVar6 == uVar11) && (uVar14 = uVar11, uVar6 < uVar15)) {
                uVar15 = uVar6;
              }
              uVar3 = puVar9[6];
              uVar13 = uVar13 + uVar18 + (uint)uVar1 + (uint)uVar2 + (uint)uVar3;
              uVar6 = (uint)uVar3;
              uVar11 = uVar6;
              if ((uVar3 < uVar14 || uVar6 == uVar14) && (uVar11 = uVar14, uVar6 < uVar15)) {
                uVar15 = uVar6;
              }
              puVar9 = puVar9 + (ulonglong)(*(int *)(param_1 + 0x41fc0) * 2 - 8) + 8;
              iVar10 = iVar8 + -1;
            } while (iVar10 != 0);
            if (uVar19 <= (uVar11 - uVar15) * 0x20) {
              uVar13 = uVar13 >> 4;
              uVar14 = uVar19;
              if (uVar19 < uVar11 - uVar13) {
                uVar14 = uVar11 - uVar13;
              }
              if (uVar14 < uVar13 - uVar15) {
                uVar14 = uVar13 - uVar15;
              }
              iVar8 = iVar8 + 3;
              do {
                iVar10 = (int)(0x8000 / (ulonglong)uVar14);
                *piVar16 = *piVar16 + (*puVar20 - uVar13) * iVar10;
                piVar16[2] = piVar16[2] + (puVar20[2] - uVar13) * iVar10;
                piVar16[4] = piVar16[4] + (puVar20[4] - uVar13) * iVar10;
                piVar16[6] = piVar16[6] + (puVar20[6] - uVar13) * iVar10;
                iVar8 = iVar8 + -1;
                uVar7 = (ulonglong)(*(int *)(param_1 + 0x41fc0) * 2 - 8);
                puVar20 = puVar20 + uVar7 + 8;
                piVar16 = piVar16 + uVar7 + 8;
              } while (iVar8 != 0);
            }
            iVar12 = iVar12 + 1;
            lVar22 = lVar22 + 2;
            iVar5 = iVar5 + -1;
          } while (iVar5 != 0);
        }
        local_res18 = local_res18 + 1;
      } while (local_res18 < *(int *)(param_1 + 0x41fc4) - 6U);
    }
    uVar19 = *(uint *)(param_1 + 0x41fc4);
    pbVar17 = *(byte **)(param_1 + 0x2a0);
    piVar16 = *(int **)(param_1 + 0x2a8);
    uVar7 = 0;
    if (uVar19 != 0) {
      uVar13 = *(uint *)(param_1 + 0x41fc0);
      do {
        uVar11 = (uint)uVar7;
        uVar15 = 4;
        if (uVar11 < 6) {
          uVar15 = (int)(uVar7 >> 1) + 1;
        }
        else if (uVar19 < uVar11 + 7) {
          uVar15 = (uVar19 - uVar11) + 1 >> 1;
        }
        uVar7 = 0;
        piVar21 = piVar16;
        if (uVar13 != 0) {
          do {
            uVar14 = (uint)uVar7;
            uVar19 = 4;
            if (uVar14 < 6) {
              uVar19 = (int)(uVar7 >> 1) + 1;
            }
            else if (uVar13 < uVar14 + 7) {
              uVar19 = (uVar13 - uVar14) + 1 >> 1;
            }
            piVar16 = piVar21 + 1;
            iVar5 = param_2 * *piVar21;
            if (uVar19 * uVar15 == 0x10) {
              iVar5 = (int)((iVar5 >> 0x1f & 0x7ffffU) + iVar5) >> 0x13;
            }
            else {
              iVar5 = iVar5 / (int)(uVar19 * uVar15 * 0x8000);
            }
            iVar5 = (uint)*pbVar17 + iVar5;
            if (iVar5 < 0x100) {
              bVar4 = (byte)iVar5;
              if (iVar5 < 0) {
                bVar4 = 0;
              }
            }
            else {
              bVar4 = 0xff;
            }
            *pbVar17 = bVar4;
            uVar13 = *(uint *)(param_1 + 0x41fc0);
            uVar7 = (ulonglong)(uVar14 + 1);
            pbVar17 = pbVar17 + 1;
            piVar21 = piVar16;
          } while (uVar14 + 1 < uVar13);
        }
        uVar19 = *(uint *)(param_1 + 0x41fc4);
        uVar7 = (ulonglong)(uVar11 + 1);
      } while (uVar11 + 1 < uVar19);
    }
  }
  return;
}


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

### ADDR 1800175a0 FUNC 1800175a0 (194 bytes) name=FUN_1800175a0

void FUN_1800175a0(longlong param_1)

{
  ushort uVar1;
  int iVar2;
  uint uVar3;
  int iVar4;
  int iVar5;
  ushort *puVar6;
  ushort *puVar7;
  
  if (*(int *)(param_1 + 0x47950) == 0) {
    uVar3 = -*(int *)(param_1 + 0x47948) >> ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
    if ((int)uVar3 < 0) {
      uVar3 = 0;
    }
  }
  else {
    iVar2 = (DAT_180099094 - DAT_180099090) * 0x9f0;
    iVar2 = ((int)(iVar2 + (iVar2 >> 0x1f & 0xfffU)) >> 0xc) + DAT_180099090;
    if (iVar2 < 0) {
      iVar2 = 0;
    }
    uVar3 = iVar2 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
  }
  iVar2 = *(int *)(param_1 + 0x47938);
  puVar7 = *(ushort **)(param_1 + 0x278);
  puVar6 = *(ushort **)(param_1 + 0x270);
  if (iVar2 != 0) {
    do {
      uVar1 = *puVar7;
      puVar7 = puVar7 + 1;
      iVar4 = ((uint)*puVar6 - (uint)uVar1) + (uVar3 & 0xffff);
      iVar5 = 0;
      if ((-1 < iVar4) && (iVar5 = iVar4, 0xfffe < iVar4)) {
        iVar5 = 0xffff;
      }
      *puVar6 = (ushort)iVar5;
      puVar6 = puVar6 + 1;
      iVar2 = iVar2 + -1;
    } while (iVar2 != 0);
  }
  return;
}


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

### ADDR 1800184f0 FUNC 1800184f0 (364 bytes) name=FUN_1800184f0

void FUN_1800184f0(longlong param_1)

{
  ushort *puVar1;
  void *_Src;
  ushort uVar2;
  ushort uVar3;
  void *_Dst;
  uint *puVar4;
  ushort *puVar5;
  ushort *puVar6;
  int iVar7;
  uint uVar8;
  uint uVar9;
  
  _Dst = *(void **)(param_1 + 0x288);
  _Src = (void *)(*(longlong *)(param_1 + 0x270) +
                 ((ulonglong)(uint)(*(int *)(param_1 + 0x41ff0) * *(int *)(param_1 + 0x41fc0)) +
                 (ulonglong)*(uint *)(param_1 + 0x41fec)) * 2);
  for (iVar7 = (*(uint *)(param_1 + 0x41fc4) >> 1) + 1; iVar7 != 0; iVar7 = iVar7 + -1) {
    memcpy(_Dst,_Src,(ulonglong)((*(uint *)(param_1 + 0x41fc0) >> 1) + 2) * 2);
    _Src = (void *)((longlong)_Src + (ulonglong)*(uint *)(param_1 + 0x41fc0) * 2);
    _Dst = (void *)((longlong)_Dst + (ulonglong)((*(uint *)(param_1 + 0x41fc0) >> 1) + 2) * 2);
  }
  puVar6 = *(ushort **)(param_1 + 0x288);
  puVar4 = *(uint **)(param_1 + 0x270);
  for (uVar8 = *(uint *)(param_1 + 0x41fc4) >> 1; uVar8 != 0; uVar8 = uVar8 - 1) {
    for (uVar9 = *(uint *)(param_1 + 0x41fc0) >> 1; uVar9 != 0; uVar9 = uVar9 - 1) {
      *puVar4 = ((int)((uint)puVar6[1] + (uint)*puVar6) >> 1) << 0x10 | (uint)*puVar6;
      puVar6 = puVar6 + 1;
      puVar4 = puVar4 + 1;
    }
    puVar5 = puVar6 + 2;
    puVar6 = puVar6 + -(ulonglong)(*(uint *)(param_1 + 0x41fc0) >> 1);
    for (uVar9 = *(uint *)(param_1 + 0x41fc0) >> 1; uVar9 != 0; uVar9 = uVar9 - 1) {
      uVar2 = *puVar6;
      uVar3 = *puVar5;
      puVar1 = puVar5 + 1;
      puVar6 = puVar6 + 1;
      puVar5 = puVar5 + 1;
      *puVar4 = ((int)((uint)*puVar1 + (uint)*puVar6 + (uint)uVar3 + (uint)uVar2) >> 2) << 0x10 |
                (int)((uint)uVar3 + (uint)uVar2) >> 1;
      puVar4 = puVar4 + 1;
    }
    puVar6 = puVar6 + 2;
  }
  return;
}


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

### ADDR 180018660 FUNC 180018660 (956 bytes) name=FUN_180018660

void FUN_180018660(longlong param_1)

{
  ushort *puVar1;
  void *_Src;
  ushort uVar2;
  ushort uVar3;
  void *_Dst;
  uint *puVar4;
  ushort *puVar5;
  int iVar6;
  ushort *puVar7;
  uint uVar8;
  uint uVar9;
  
  _Dst = *(void **)(param_1 + 0x288);
  _Src = (void *)(*(longlong *)(param_1 + 0x270) +
                 ((ulonglong)(uint)(*(int *)(param_1 + 0x41ff0) * *(int *)(param_1 + 0x41fc0)) +
                 (ulonglong)*(uint *)(param_1 + 0x41fec)) * 2);
  for (iVar6 = (*(uint *)(param_1 + 0x41fc4) >> 2) + 1; iVar6 != 0; iVar6 = iVar6 + -1) {
    memcpy(_Dst,_Src,(ulonglong)((*(uint *)(param_1 + 0x41fc0) >> 2) + 2) * 2);
    _Src = (void *)((longlong)_Src + (ulonglong)*(uint *)(param_1 + 0x41fc0) * 2);
    _Dst = (void *)((longlong)_Dst + (ulonglong)((*(uint *)(param_1 + 0x41fc0) >> 2) + 2) * 2);
  }
  puVar7 = *(ushort **)(param_1 + 0x288);
  puVar4 = *(uint **)(param_1 + 0x270);
  for (uVar9 = *(uint *)(param_1 + 0x41fc4) >> 2; uVar9 != 0; uVar9 = uVar9 - 1) {
    for (uVar8 = *(uint *)(param_1 + 0x41fc0) >> 2; uVar8 != 0; uVar8 = uVar8 - 1) {
      uVar2 = *puVar7;
      *puVar4 = ((int)((uint)uVar2 + (uint)uVar2 * 2 + (uint)puVar7[1]) >> 2) << 0x10 | (uint)uVar2;
      uVar2 = puVar7[1];
      puVar4[1] = ((int)((uint)*puVar7 + (uint)uVar2 * 2 + (uint)uVar2) >> 2) << 0x10 |
                  (int)((uint)uVar2 + (uint)*puVar7) >> 1;
      puVar7 = puVar7 + 1;
      puVar4 = puVar4 + 2;
    }
    puVar5 = puVar7 + 2;
    puVar7 = puVar7 + -(ulonglong)(*(uint *)(param_1 + 0x41fc0) >> 2);
    for (uVar8 = *(uint *)(param_1 + 0x41fc0) >> 2; uVar8 != 0; uVar8 = uVar8 - 1) {
      iVar6 = (uint)*puVar7 + (uint)*puVar7 * 2;
      *puVar4 = ((int)(((uint)puVar7[1] + (uint)*puVar5 + iVar6) * 3 + (uint)puVar5[1]) >> 4) <<
                0x10 | (int)((uint)*puVar5 + iVar6) >> 2;
      uVar2 = puVar7[1];
      uVar3 = puVar5[1];
      puVar4[1] = ((int)((uint)*puVar5 +
                        ((uint)uVar3 + (uint)uVar2 * 2 + (uint)uVar2 + (uint)*puVar7) * 3) >> 4) <<
                  0x10 | (int)((uint)uVar3 + ((uint)uVar2 + (uint)*puVar7) * 3 + (uint)*puVar5) >> 3
      ;
      puVar5 = puVar5 + 1;
      puVar7 = puVar7 + 1;
      puVar4 = puVar4 + 2;
    }
    puVar5 = puVar7 + 2;
    puVar7 = puVar7 + -(ulonglong)(*(uint *)(param_1 + 0x41fc0) >> 2);
    for (uVar8 = *(uint *)(param_1 + 0x41fc0) >> 2; uVar8 != 0; uVar8 = uVar8 - 1) {
      puVar1 = puVar7 + 1;
      *puVar4 = ((int)(((uint)*puVar7 + (uint)*puVar5) * 3 + (uint)puVar5[1] + (uint)*puVar1) >> 3)
                << 0x10 | (int)((uint)*puVar7 + (uint)*puVar5) >> 1;
      iVar6 = (uint)puVar5[1] + (uint)*puVar1;
      puVar4[1] = ((int)((uint)*puVar5 + iVar6 * 3 + (uint)*puVar7) >> 3) << 0x10 |
                  (int)(iVar6 + (uint)*puVar5 + (uint)*puVar7) >> 2;
      puVar5 = puVar5 + 1;
      puVar7 = puVar1;
      puVar4 = puVar4 + 2;
    }
    puVar5 = puVar7 + 2;
    puVar7 = puVar7 + -(ulonglong)(*(uint *)(param_1 + 0x41fc0) >> 2);
    for (uVar8 = *(uint *)(param_1 + 0x41fc0) >> 2; uVar8 != 0; uVar8 = uVar8 - 1) {
      iVar6 = (uint)*puVar5 + (uint)*puVar5 * 2;
      *puVar4 = ((int)(((uint)puVar5[1] + iVar6 + (uint)*puVar7) * 3 + (uint)puVar7[1]) >> 4) <<
                0x10 | (int)(iVar6 + (uint)*puVar7) >> 2;
      uVar2 = puVar5[1];
      uVar3 = puVar7[1];
      puVar4[1] = ((int)((uint)*puVar7 +
                        ((uint)uVar3 + (uint)uVar2 * 2 + (uint)uVar2 + (uint)*puVar5) * 3) >> 4) <<
                  0x10 | (int)((uint)uVar3 + ((uint)uVar2 + (uint)*puVar5) * 3 + (uint)*puVar7) >> 3
      ;
      puVar5 = puVar5 + 1;
      puVar7 = puVar7 + 1;
      puVar4 = puVar4 + 2;
    }
    puVar7 = puVar7 + 2;
  }
  return;
}


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

### ADDR 180015680 FUNC 180015680 (88 bytes) name=FUN_180015680

uint FUN_180015680(longlong param_1,undefined8 param_2,uint param_3)

{
  int iVar1;
  uint uVar2;
  undefined8 in_RAX;
  undefined2 uVar3;
  
  if (*(int *)(param_1 + 0x47950) != 0) {
    iVar1 = FUN_180015940(param_1,30000,param_3);
    uVar2 = iVar1 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
    if (0xffff < (int)uVar2) {
      uVar2 = 0xffff;
    }
    return uVar2;
  }
  uVar2 = param_3 >> ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
  uVar3 = (undefined2)uVar2;
  if (0xffff < uVar2) {
    uVar3 = 0xffff;
  }
  return (uint)CONCAT62((int6)((ulonglong)in_RAX >> 0x10),uVar3);
}


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

### ADDR 18000d2a0 FUNC 18000d2a0 (839 bytes) name=FUN_18000d2a0

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

void FUN_18000d2a0(longlong param_1)

{
  int iVar1;
  int iVar2;
  uint uVar3;
  float fVar4;
  float fVar5;
  
  memcpy((void *)(param_1 + 0x44c98),(void *)(param_1 + 0x41ff8),0x2ca0);
  iVar1 = FUN_180016290(param_1,(uint)*(ushort *)(param_1 + 0x42018),
                        (*(uint *)(param_1 + 0x47938) >> 1) + (*(uint *)(param_1 + 0x41fc0) >> 1),0)
  ;
  *(int *)(param_1 + 0x44cb8) = iVar1;
  iVar1 = FUN_180016290(param_1,(uint)*(ushort *)(param_1 + 0x4202c),
                        (*(uint *)(param_1 + 0x47938) >> 1) + (*(uint *)(param_1 + 0x41fc0) >> 1),0)
  ;
  *(int *)(param_1 + 0x44ccc) = iVar1;
  iVar1 = FUN_180016290(param_1,(uint)*(ushort *)(param_1 + 0x42010),*(uint *)(param_1 + 0x44cc0),1)
  ;
  *(int *)(param_1 + 0x44cb0) = iVar1;
  iVar1 = FUN_180016290(param_1,(uint)*(ushort *)(param_1 + 0x42030),
                        (*(uint *)(param_1 + 0x47938) >> 1) + (*(uint *)(param_1 + 0x41fc0) >> 1),0)
  ;
  *(int *)(param_1 + 0x44cd0) = iVar1;
  iVar1 = FUN_180016290(param_1,(uint)*(ushort *)(param_1 + 0x42014),*(uint *)(param_1 + 0x44cc4),1)
  ;
  *(int *)(param_1 + 0x44cb4) = iVar1;
  if (*(int *)(param_1 + 0xcc) == 2) {
    iVar1 = *(int *)(param_1 + 0x44cb8);
  }
  else {
    if (*(int *)(param_1 + 0xcc) != 3) goto LAB_18000d3c5;
    iVar1 = *(int *)(param_1 + 0x60);
  }
  *(float *)(param_1 + 0xd8) = (float)iVar1 * _DAT_18005e9f0;
LAB_18000d3c5:
  iVar1 = *(int *)(param_1 + 0x47950);
  if (iVar1 == 0) {
    iVar2 = (uint)*(ushort *)(param_1 + 0x4201c) <<
            ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
  }
  else {
    iVar2 = FUN_180015a40(param_1,*(int *)(param_1 + 0x44cb8),
                          (uint)*(ushort *)(param_1 + 0x4201c) <<
                          (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f));
  }
  *(int *)(param_1 + 0x44cbc) = iVar2;
  uVar3 = (uint)(longlong)(*(float *)(param_1 + 0x42034) * _DAT_18005e9ec);
  if (iVar1 == 0) {
    uVar3 = (uVar3 & 0xffff) << ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
  }
  else {
    uVar3 = FUN_180015a40(param_1,*(int *)(param_1 + 0x44cb8),
                          (uVar3 & 0xffff) << (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f)
                         );
  }
  fVar5 = DAT_18005e9e8;
  fVar4 = *(float *)(param_1 + 0x44c8c) * DAT_18005e9e8;
  *(float *)(param_1 + 0x44cd4) = (float)uVar3 * DAT_18005e9e4;
  uVar3 = (uint)(longlong)fVar4;
  if (iVar1 == 0) {
    uVar3 = (uVar3 & 0xffff) << ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
  }
  else {
    uVar3 = FUN_180015a40(param_1,*(int *)(param_1 + 0x44cb8),
                          (uVar3 & 0xffff) << (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f)
                         );
  }
  fVar4 = DAT_18005e9e0;
  *(float *)(param_1 + 0x4792c) = (float)uVar3 * DAT_18005e9e0;
  uVar3 = (uint)(longlong)(*(float *)(param_1 + 0x44c90) * fVar5);
  if (iVar1 == 0) {
    uVar3 = (uVar3 & 0xffff) << ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
  }
  else {
    uVar3 = FUN_180015a40(param_1,*(int *)(param_1 + 0x44cb8),
                          (uVar3 & 0xffff) << (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f)
                         );
  }
  *(float *)(param_1 + 0x47930) = (float)uVar3 * fVar4;
  if (*(int *)(param_1 + 0x78) != 0) {
    iVar1 = FUN_180015b90(param_1,*(int *)(param_1 + 0x44cb8),*(float *)(param_1 + 0xd4));
    *(int *)(param_1 + 0x44cb8) = iVar1;
    iVar1 = FUN_180015b90(param_1,*(int *)(param_1 + 0x44cb4),*(float *)(param_1 + 0xd4));
    *(int *)(param_1 + 0x44cb4) = iVar1;
    iVar1 = FUN_180015b90(param_1,*(int *)(param_1 + 0x44cb0),*(float *)(param_1 + 0xd4));
    *(int *)(param_1 + 0x44cb0) = iVar1;
  }
  iVar1 = *(int *)(param_1 + 0x44cb4);
  if (*(int *)(param_1 + 0x44cb0) < iVar1) {
    *(int *)(param_1 + 0x44cb0) = iVar1;
  }
  if (*(int *)(param_1 + 0x44cb0) < *(int *)(param_1 + 0x44cb8)) {
    *(int *)(param_1 + 0x44cb8) = *(int *)(param_1 + 0x44cb0);
  }
  if (*(int *)(param_1 + 0x44cb8) < iVar1) {
    *(int *)(param_1 + 0x44cb8) = iVar1;
  }
  return;
}


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

### ADDR 180019740 FUNC 180019740 (1000 bytes) name=FUN_180019740

void FUN_180019740(longlong param_1)

{
  byte *pbVar1;
  byte bVar2;
  byte bVar3;
  int iVar4;
  int iVar5;
  int iVar6;
  longlong lVar7;
  longlong lVar8;
  longlong lVar9;
  longlong lVar10;
  longlong lVar11;
  longlong lVar12;
  int iVar13;
  longlong lVar14;
  int iVar15;
  int iVar16;
  int local_res10;
  int local_res18;
  
  iVar4 = *(int *)(param_1 + 0x41fc4);
  iVar5 = *(int *)(param_1 + 0x41fc0);
  lVar7 = (longlong)iVar5;
  lVar9 = *(longlong *)(param_1 + 0x2a0);
  lVar10 = *(longlong *)(param_1 + 0x220);
  if (1 < iVar4) {
    local_res18 = 1;
    iVar15 = 0;
    local_res10 = 0;
    do {
      if (2 < iVar5) {
        iVar13 = 0;
        iVar16 = iVar15;
        do {
          lVar11 = (longlong)iVar16;
          bVar2 = *(byte *)(lVar11 + 1 + lVar9);
          iVar16 = iVar16 + 2;
          lVar14 = (longlong)(iVar13 / 2 + iVar15);
          lVar8 = lVar7 + lVar11;
          *(uint *)(lVar10 + lVar14 * 4) =
               ((((int)((uint)*(byte *)(lVar11 + 2 + lVar9) + (uint)bVar2) >> 1) * 0x100 +
                (uint)bVar2) * 0x100 + ((int)((uint)*(byte *)(lVar11 + lVar9) + (uint)bVar2) >> 1))
               * 0x100 + (uint)*(byte *)(lVar11 + lVar9);
          bVar2 = *(byte *)(lVar8 + 1 + lVar9);
          bVar3 = *(byte *)(lVar11 + 1 + lVar9);
          *(int *)(lVar10 + (lVar14 + iVar5 / 2) * 4) =
               ((((int)((uint)*(byte *)(lVar11 + 2 + lVar9) +
                        (uint)*(byte *)(lVar8 + 2 + lVar9) + (uint)bVar2 + (uint)bVar3) >> 2) *
                 0x100 + ((int)((uint)bVar2 + (uint)bVar3) >> 1)) * 0x100 +
               ((int)((uint)*(byte *)(lVar8 + lVar9) + (uint)bVar2 + (uint)*(byte *)(lVar11 + lVar9)
                     + (uint)bVar3) >> 2)) * 0x100 +
               ((int)((uint)*(byte *)(lVar8 + lVar9) + (uint)*(byte *)(lVar11 + lVar9)) >> 1);
          iVar6 = iVar13 + 4;
          iVar13 = iVar13 + 2;
        } while (iVar6 < iVar5);
      }
      iVar16 = iVar15 + iVar5 + -2;
      iVar15 = iVar15 + iVar5;
      lVar8 = (longlong)iVar16;
      lVar11 = (longlong)(local_res10 + iVar5 + -2);
      *(ushort *)(lVar10 + lVar11 * 2) =
           (short)((int)((uint)*(byte *)(lVar8 + 1 + lVar9) + (uint)*(byte *)(lVar8 + lVar9)) >> 1)
           * 0x100 + (ushort)*(byte *)(lVar8 + lVar9);
      bVar2 = *(byte *)(lVar8 + lVar7 + lVar9);
      local_res10 = local_res10 + iVar5 * 2;
      *(short *)(lVar10 + (lVar11 + lVar7) * 2) =
           (short)((int)((uint)*(byte *)(lVar8 + 1 + lVar9) +
                         (uint)*(byte *)(lVar8 + lVar7 + 1 + lVar9) + (uint)bVar2 +
                        (uint)*(byte *)(lVar8 + lVar9)) >> 2) * 0x100 +
           (short)((int)((uint)bVar2 + (uint)*(byte *)(lVar8 + lVar9)) >> 1);
      local_res18 = local_res18 + 1;
    } while (local_res18 < iVar4);
  }
  lVar8 = (longlong)(iVar5 * 2);
  if (1 < iVar4) {
    iVar16 = iVar5 + -1;
    iVar15 = 0;
    do {
      lVar12 = (longlong)iVar16;
      lVar11 = lVar12 + lVar7;
      iVar16 = iVar16 + iVar5;
      lVar14 = (longlong)(iVar15 * 2 * iVar5 * 2 + iVar5 * 2 + -2);
      *(undefined1 *)(lVar14 + lVar10) = *(undefined1 *)(lVar12 + lVar9);
      *(byte *)(lVar14 + 1 + lVar10) =
           (char)((int)((uint)*(byte *)(lVar12 + lVar9) + (uint)*(byte *)(lVar12 + lVar9) * 2) >> 2)
           + (*(byte *)(lVar12 + -1 + lVar9) >> 2);
      *(char *)(lVar14 + lVar8 + lVar10) =
           (char)((int)((uint)*(byte *)(lVar11 + lVar9) + (uint)*(byte *)(lVar12 + lVar9)) >> 1);
      iVar13 = iVar15 + 2;
      *(char *)(lVar14 + lVar8 + 1 + lVar10) =
           (char)((int)(((uint)*(byte *)(lVar11 + lVar9) + (uint)*(byte *)(lVar12 + lVar9)) * 3 +
                        (uint)*(byte *)(lVar11 + -1 + lVar9) + (uint)*(byte *)(lVar12 + -1 + lVar9))
                 >> 3);
      iVar15 = iVar15 + 1;
    } while (iVar13 < iVar4);
  }
  iVar15 = 1;
  if (1 < iVar5) {
    lVar11 = lVar9 - lVar7;
    iVar13 = (iVar4 + -1) * iVar5;
    iVar16 = (iVar4 * 2 + -2) * iVar5 * 2;
    do {
      lVar12 = (longlong)iVar13;
      lVar14 = (longlong)iVar16;
      iVar15 = iVar15 + 1;
      iVar13 = iVar13 + 1;
      *(undefined1 *)(lVar14 + lVar10) = *(undefined1 *)(lVar12 + lVar9);
      iVar16 = iVar16 + 2;
      *(char *)(lVar14 + 1 + lVar10) =
           (char)((int)((uint)*(byte *)(lVar12 + 1 + lVar9) + (uint)*(byte *)(lVar12 + lVar9)) >> 1)
      ;
      *(byte *)(lVar14 + lVar8 + lVar10) =
           (char)((int)((uint)*(byte *)(lVar12 + lVar9) + (uint)*(byte *)(lVar12 + lVar9) * 2) >> 2)
           + (*(byte *)(lVar12 + lVar11) >> 2);
      *(char *)(lVar14 + lVar8 + 1 + lVar10) =
           (char)((int)(((uint)*(byte *)(lVar12 + 1 + lVar9) + (uint)*(byte *)(lVar12 + lVar9)) * 3
                        + (uint)*(byte *)(lVar12 + 1 + lVar11) + (uint)*(byte *)(lVar12 + lVar11))
                 >> 3);
    } while (iVar15 < iVar5);
  }
  lVar9 = (longlong)((iVar4 + -1) * iVar5 + iVar5 + -1);
  lVar10 = (longlong)((iVar4 * 2 + -2) * iVar5 * 2 + (iVar5 + -1) * 2);
  *(undefined1 *)(lVar10 + *(longlong *)(param_1 + 0x220)) =
       *(undefined1 *)(lVar9 + *(longlong *)(param_1 + 0x2a0));
  bVar2 = *(byte *)(lVar9 + *(longlong *)(param_1 + 0x2a0));
  *(char *)(lVar10 + 1 + *(longlong *)(param_1 + 0x220)) =
       (char)((int)((uint)bVar2 + (uint)bVar2 * 2 +
                   (uint)*(byte *)(lVar9 + -1 + *(longlong *)(param_1 + 0x2a0))) >> 2);
  bVar2 = *(byte *)(lVar9 + *(longlong *)(param_1 + 0x2a0));
  *(char *)(lVar10 + *(longlong *)(param_1 + 0x220) + lVar8) =
       (char)((int)((uint)*(byte *)((lVar9 - lVar7) + *(longlong *)(param_1 + 0x2a0)) +
                   (uint)bVar2 + (uint)bVar2 * 2) >> 2);
  pbVar1 = (byte *)(lVar10 + *(longlong *)(param_1 + 0x220));
  pbVar1[lVar8 + 1] =
       (byte)((ulonglong)
              ((longlong)
               (int)((uint)*(byte *)(lVar10 + 1 + *(longlong *)(param_1 + 0x220)) +
                     (uint)pbVar1[lVar8] + (uint)*pbVar1) * 0x55555556) >> 0x20);
  return;
}


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

### ADDR 18000ffb0 FUNC 18000ffb0 (1995 bytes) name=FUN_18000ffb0

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

void FUN_18000ffb0(longlong param_1)

{
  int iVar1;
  int iVar2;
  int iVar3;
  int iVar4;
  int iVar5;
  int iVar6;
  int iVar7;
  uint uVar8;
  int iVar9;
  longlong lVar10;
  int *piVar11;
  int *piVar12;
  int iVar13;
  longlong lVar14;
  float fVar15;
  int local_78 [12];
  int local_48 [12];
  
  if ((*(int *)(param_1 + 0x41340) != 0) && (*(int *)(param_1 + 0x41344) != 0)) {
    iVar2 = (*(int *)(param_1 + 0x41568) + *(int *)(param_1 + 0x41564)) / 2;
    if (*(float *)(param_1 + 0x9c) == _DAT_180057598) {
      *(undefined4 *)(param_1 + 0x418c4) = 1;
      *(undefined4 *)(param_1 + 0x4195c) = *(undefined4 *)(param_1 + 0x47944);
      *(int *)(param_1 + 0x41960) = (*(int *)(param_1 + 0x47948) + *(int *)(param_1 + 0x54)) - iVar2
      ;
      return;
    }
    iVar6 = *(int *)(param_1 + 0x54);
    fVar15 = ((float)(iVar6 - iVar2) * *(float *)(param_1 + 0x9c)) / _DAT_18005e820 + DAT_18005e700;
    if (fVar15 < DAT_18005e824) {
      fVar15 = DAT_18005e824;
    }
    iVar1 = *(int *)(param_1 + 0x47950);
    *(undefined4 *)(param_1 + 0x418c4) = 10;
    iVar13 = 0;
    local_48[0] = 0;
    iVar9 = iVar2 - (int)((float)iVar6 * fVar15);
    iVar3 = 0;
    if (iVar1 == 0) {
      local_78[0] = iVar9 - *(int *)(param_1 + 0x47948) >>
                    ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
      if (local_78[0] < 0) {
        local_78[0] = iVar13;
      }
    }
    else {
      iVar9 = iVar9 + 150000;
      iVar4 = (int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc;
      iVar7 = iVar3;
      if ((-1 < iVar4) && (iVar7 = iVar4, 0x285 < iVar4)) {
        iVar7 = 0x285;
      }
      iVar9 = (iVar9 + iVar7 * -0x1000) * ((&DAT_180099004)[iVar7] - (&DAT_180099000)[iVar7]);
      iVar9 = ((int)((iVar9 >> 0x1f & 0xfffU) + iVar9) >> 0xc) + (&DAT_180099000)[iVar7];
      if (iVar9 < 0) {
        iVar9 = iVar13;
      }
      local_78[0] = iVar9 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
    }
    local_48[1] = 10000;
    iVar9 = (int)((float)(10000 - iVar6) * fVar15) + iVar2;
    if (iVar1 == 0) {
      local_78[1] = iVar9 - *(int *)(param_1 + 0x47948) >>
                    ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
      if (local_78[1] < 0) {
        local_78[1] = iVar13;
      }
    }
    else {
      iVar9 = iVar9 + 150000;
      iVar4 = (int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc;
      iVar7 = iVar3;
      if ((-1 < iVar4) && (iVar7 = iVar4, 0x285 < iVar4)) {
        iVar7 = 0x285;
      }
      iVar9 = (iVar9 + iVar7 * -0x1000) * ((&DAT_180099004)[iVar7] - (&DAT_180099000)[iVar7]);
      iVar9 = ((int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc) + (&DAT_180099000)[iVar7];
      if (iVar9 < 0) {
        iVar9 = iVar13;
      }
      local_78[1] = iVar9 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
    }
    local_48[2] = 20000;
    iVar9 = (int)((float)(20000 - iVar6) * fVar15) + iVar2;
    if (iVar1 == 0) {
      local_78[2] = iVar9 - *(int *)(param_1 + 0x47948) >>
                    ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
      if (local_78[2] < 0) {
        local_78[2] = iVar13;
      }
    }
    else {
      iVar9 = iVar9 + 150000;
      iVar4 = (int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc;
      iVar7 = iVar3;
      if ((-1 < iVar4) && (iVar7 = iVar4, 0x285 < iVar4)) {
        iVar7 = 0x285;
      }
      iVar9 = (iVar9 + iVar7 * -0x1000) * ((&DAT_180099004)[iVar7] - (&DAT_180099000)[iVar7]);
      iVar9 = ((int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc) + (&DAT_180099000)[iVar7];
      if (iVar9 < 0) {
        iVar9 = iVar13;
      }
      local_78[2] = iVar9 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
    }
    local_48[3] = 30000;
    iVar9 = (int)((float)(30000 - iVar6) * fVar15) + iVar2;
    if (iVar1 == 0) {
      local_78[3] = iVar9 - *(int *)(param_1 + 0x47948) >>
                    ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
      if (local_78[3] < 0) {
        local_78[3] = iVar13;
      }
    }
    else {
      iVar9 = iVar9 + 150000;
      iVar4 = (int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc;
      iVar7 = iVar3;
      if ((-1 < iVar4) && (iVar7 = iVar4, 0x285 < iVar4)) {
        iVar7 = 0x285;
      }
      iVar9 = (iVar9 + iVar7 * -0x1000) * ((&DAT_180099004)[iVar7] - (&DAT_180099000)[iVar7]);
      iVar9 = ((int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc) + (&DAT_180099000)[iVar7];
      if (iVar9 < 0) {
        iVar9 = iVar13;
      }
      local_78[3] = iVar9 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
    }
    local_48[4] = 40000;
    iVar9 = (int)((float)(40000 - iVar6) * fVar15) + iVar2;
    iVar7 = 0;
    if (iVar1 == 0) {
      local_78[4] = iVar9 - *(int *)(param_1 + 0x47948) >>
                    ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
      if (local_78[4] < 0) {
        local_78[4] = iVar13;
      }
    }
    else {
      iVar9 = iVar9 + 150000;
      iVar5 = (int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc;
      iVar4 = iVar7;
      if ((-1 < iVar5) && (iVar4 = iVar5, 0x285 < iVar5)) {
        iVar4 = 0x285;
      }
      iVar9 = (iVar9 + iVar4 * -0x1000) * ((&DAT_180099004)[iVar4] - (&DAT_180099000)[iVar4]);
      iVar9 = ((int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc) + (&DAT_180099000)[iVar4];
      if (iVar9 < 0) {
        iVar9 = iVar13;
      }
      local_78[4] = iVar9 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
    }
    local_48[5] = 50000;
    iVar9 = (int)((float)(50000 - iVar6) * fVar15) + iVar2;
    if (iVar1 == 0) {
      local_78[5] = iVar9 - *(int *)(param_1 + 0x47948) >>
                    ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
      if (local_78[5] < 0) {
        local_78[5] = iVar13;
      }
    }
    else {
      iVar9 = iVar9 + 150000;
      iVar5 = (int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc;
      iVar4 = iVar7;
      if ((-1 < iVar5) && (iVar4 = iVar5, 0x285 < iVar5)) {
        iVar4 = 0x285;
      }
      iVar9 = (iVar9 + iVar4 * -0x1000) * ((&DAT_180099004)[iVar4] - (&DAT_180099000)[iVar4]);
      iVar9 = ((int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc) + (&DAT_180099000)[iVar4];
      if (iVar9 < 0) {
        iVar9 = iVar13;
      }
      local_78[5] = iVar9 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
    }
    local_48[6] = 60000;
    iVar9 = (int)((float)(60000 - iVar6) * fVar15) + iVar2;
    if (iVar1 == 0) {
      local_78[6] = iVar9 - *(int *)(param_1 + 0x47948) >>
                    ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
      if (local_78[6] < 0) {
        local_78[6] = iVar13;
      }
    }
    else {
      iVar9 = iVar9 + 150000;
      iVar5 = (int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc;
      iVar4 = iVar7;
      if ((-1 < iVar5) && (iVar4 = iVar5, 0x285 < iVar5)) {
        iVar4 = 0x285;
      }
      iVar9 = (iVar9 + iVar4 * -0x1000) * ((&DAT_180099004)[iVar4] - (&DAT_180099000)[iVar4]);
      iVar9 = ((int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc) + (&DAT_180099000)[iVar4];
      if (iVar9 < 0) {
        iVar9 = iVar13;
      }
      local_78[6] = iVar9 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
    }
    local_48[7] = 70000;
    iVar6 = (int)((float)(70000 - iVar6) * fVar15) + iVar2;
    if (iVar1 == 0) {
      local_78[7] = iVar6 - *(int *)(param_1 + 0x47948) >>
                    ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
      if (local_78[7] < 0) {
        local_78[7] = iVar13;
      }
    }
    else {
      iVar6 = iVar6 + 150000;
      iVar9 = (int)(iVar6 + (iVar6 >> 0x1f & 0xfffU)) >> 0xc;
      if ((-1 < iVar9) && (iVar7 = iVar9, 0x285 < iVar9)) {
        iVar7 = 0x285;
      }
      iVar6 = (iVar6 + iVar7 * -0x1000) * ((&DAT_180099004)[iVar7] - (&DAT_180099000)[iVar7]);
      iVar6 = ((int)(iVar6 + (iVar6 >> 0x1f & 0xfffU)) >> 0xc) + (&DAT_180099000)[iVar7];
      if (iVar6 < 0) {
        iVar6 = iVar13;
      }
      local_78[7] = iVar6 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
    }
    iVar9 = 80000;
    lVar10 = 0x20;
    iVar6 = 80000 - *(int *)(param_1 + 0x54);
    do {
      *(int *)((longlong)local_48 + lVar10) = iVar9;
      iVar7 = (int)((float)iVar6 * fVar15) + iVar2;
      if (iVar1 == 0) {
        iVar7 = iVar7 - *(int *)(param_1 + 0x47948) >>
                ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
        if (iVar7 < 0) {
          iVar7 = iVar13;
        }
      }
      else {
        iVar7 = iVar7 + 150000;
        iVar5 = (int)(iVar7 + (iVar7 >> 0x1f & 0xfffU)) >> 0xc;
        iVar4 = iVar3;
        if ((-1 < iVar5) && (iVar4 = iVar5, 0x285 < iVar5)) {
          iVar4 = 0x285;
        }
        iVar7 = (iVar7 + iVar4 * -0x1000) * ((&DAT_180099004)[iVar4] - (&DAT_180099000)[iVar4]);
        iVar7 = ((int)(iVar7 + (iVar7 >> 0x1f & 0xfffU)) >> 0xc) + (&DAT_180099000)[iVar4];
        if (iVar7 < 0) {
          iVar7 = iVar13;
        }
        iVar7 = iVar7 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
      }
      iVar9 = iVar9 + 10000;
      *(int *)((longlong)local_78 + lVar10) = iVar7;
      lVar10 = lVar10 + 4;
      iVar6 = iVar6 + 10000;
    } while (iVar9 < 110000);
    piVar11 = (int *)(param_1 + 0x418cc);
    piVar12 = (int *)(param_1 + 0x41960);
    lVar10 = 0;
    do {
      iVar2 = *(int *)((longlong)local_78 + lVar10 + 4);
      iVar6 = *(int *)((longlong)local_48 + lVar10 + 4);
      iVar9 = *(int *)((longlong)local_78 + lVar10);
      iVar1 = *(int *)((longlong)local_48 + lVar10);
      iVar3 = *(int *)((longlong)local_78 + lVar10 + 0xc);
      piVar11[-1] = iVar2;
      lVar14 = lVar10 + 0x14;
      uVar8 = iVar2 - iVar9;
      uVar8 = (((uVar8 >> 1) - iVar1) + iVar6) / uVar8;
      piVar12[-1] = uVar8;
      iVar13 = *(int *)((longlong)local_78 + lVar10 + 8);
      *piVar12 = iVar1 - iVar9 * uVar8;
      iVar9 = *(int *)((longlong)local_48 + lVar10 + 8);
      *piVar11 = iVar13;
      uVar8 = ((((uint)(iVar13 - iVar2) >> 1) - iVar6) + iVar9) / (uint)(iVar13 - iVar2);
      piVar12[1] = uVar8;
      iVar1 = *(int *)((longlong)local_78 + lVar10 + 0x10);
      piVar12[2] = iVar6 - iVar2 * uVar8;
      iVar2 = *(int *)((longlong)local_48 + lVar10 + 0xc);
      piVar11[1] = iVar3;
      uVar8 = ((((uint)(iVar3 - iVar13) >> 1) - iVar9) + iVar2) / (uint)(iVar3 - iVar13);
      piVar12[3] = uVar8;
      iVar6 = *(int *)((longlong)local_48 + lVar10 + 0x10);
      piVar12[4] = iVar9 - iVar13 * uVar8;
      iVar9 = *(int *)((longlong)local_78 + lVar10 + 0x14);
      piVar11[2] = iVar1;
      uVar8 = ((((uint)(iVar1 - iVar3) >> 1) - iVar2) + iVar6) / (uint)(iVar1 - iVar3);
      piVar12[5] = uVar8;
      iVar13 = *(int *)((longlong)local_48 + lVar10 + 0x14);
      piVar12[6] = iVar2 - iVar3 * uVar8;
      piVar11[3] = iVar9;
      uVar8 = iVar9 - iVar1;
      uVar8 = ((iVar13 + (uVar8 >> 1)) - iVar6) / uVar8;
      piVar12[7] = uVar8;
      piVar12[8] = iVar6 - iVar1 * uVar8;
      piVar11 = piVar11 + 5;
      piVar12 = piVar12 + 10;
      lVar10 = lVar14;
    } while (lVar14 < 0x28);
  }
  return;
}


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

### ADDR 1800108a0 FUNC 1800108a0 (284 bytes) name=FUN_1800108a0

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

int FUN_1800108a0(longlong param_1)

{
  ushort uVar1;
  uint uVar2;
  int iVar3;
  int iVar4;
  
  iVar4 = *(int *)(param_1 + 0x4c);
  uVar2 = *(int *)(param_1 + 0x24) * 1000;
  if (*(int *)(param_1 + 0x47950) == 0) {
    uVar2 = uVar2 >> ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
    uVar1 = (ushort)uVar2;
    if (0xffff < uVar2) {
      uVar1 = 0xffff;
    }
  }
  else {
    iVar3 = FUN_180015940(param_1,30000,uVar2);
    iVar3 = iVar3 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
    if (0xffff < iVar3) {
      iVar3 = 0xffff;
    }
    uVar1 = (ushort)iVar3;
  }
  if (iVar4 < 0) {
    if (iVar4 < -100) {
      iVar4 = -100;
    }
    iVar3 = -0x51eb851f;
  }
  else {
    if (100 < iVar4) {
      iVar4 = 100;
    }
    iVar3 = -0x1b4e81b5;
  }
  iVar4 = (int)((ulonglong)((longlong)iVar3 * (longlong)(int)((uint)uVar1 * iVar4)) >> 0x20);
  iVar4 = (uint)uVar1 + ((iVar4 >> 4) - (iVar4 >> 0x1f));
  if (((*(int *)(param_1 + 0x41340) != 0) && (_DAT_180057598 < *(float *)(param_1 + 0x9c))) &&
     ((*(int *)(param_1 + 0x41558) == 1 ||
      ((*(int *)(param_1 + 0x41558) == 2 &&
       (*(int *)(param_1 + 0x41568) - *(int *)(param_1 + 0x41564) == 50000)))))) {
    iVar4 = iVar4 + (int)(((float)((*(int *)(param_1 + 0x54) -
                                   (*(int *)(param_1 + 0x41568) + *(int *)(param_1 + 0x41564)) / 2)
                                  * iVar4) * *(float *)(param_1 + 0x9c)) / _DAT_18005e820);
  }
  iVar3 = 0x80;
  if (0x80 < iVar4) {
    iVar3 = iVar4;
  }
  return iVar3;
}


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

### ADDR 180011ee0 FUNC 180011ee0 (3137 bytes) name=FUN_180011ee0

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

void FUN_180011ee0(longlong param_1,ushort *param_2)

{
  ulonglong *puVar1;
  uint *puVar2;
  bool bVar3;
  int iVar4;
  uint uVar5;
  int iVar6;
  int iVar7;
  DWORD DVar8;
  int iVar9;
  int iVar10;
  ulonglong uVar11;
  uint uVar12;
  uint *puVar14;
  ulonglong uVar15;
  ushort uVar16;
  uint uVar17;
  int iVar18;
  ulonglong uVar19;
  longlong lVar20;
  uint uVar21;
  int iVar22;
  int iVar23;
  longlong lVar24;
  longlong lVar25;
  int iVar26;
  uint local_res8;
  uint local_1038 [1024];
  ulonglong uVar13;
  
  local_1038[0x3fe] = 0x80011efa;
  local_1038[0x3ff] = 1;
  puVar1 = (ulonglong *)(param_1 + 0x42c4c);
  puVar2 = (uint *)(param_1 + 0x43c4c);
  uVar5 = FUN_180011950(param_1,param_2,puVar1);
  bVar3 = true;
  lVar24 = 0x155;
  uVar21 = uVar5 >> 0xc;
  puVar14 = (uint *)(param_1 + 0x42c50);
  if (uVar21 == 0) {
    uVar21 = 1;
  }
  do {
    puVar14[-1] = *puVar14 + puVar14[-1] >> 1;
    *puVar14 = puVar14[1] + *puVar14 >> 1;
    lVar24 = lVar24 + -1;
    puVar14[1] = puVar14[2] + puVar14[1] >> 1;
    puVar14 = puVar14 + 3;
  } while (lVar24 != 0);
  *(undefined4 *)(param_1 + 0x43c48) = *(undefined4 *)(param_1 + 0x43c44);
  if (*(int *)(param_1 + 0x88) == 0) {
    iVar18 = *(int *)(param_1 + 0x42018);
  }
  else {
    iVar18 = *(int *)(param_1 + 0x44c64);
  }
  uVar15 = 0;
  local_res8 = (uint)((iVar18 - *(int *)(param_1 + 0x42030)) * 0x3ff) /
               (uint)(*(int *)(param_1 + 0x4202c) - *(int *)(param_1 + 0x42030));
  iVar18 = 0;
  if (*(int *)(param_1 + 0x8c) != 0) {
    uVar11 = uVar15;
    uVar13 = uVar15;
    uVar19 = uVar15;
    do {
      uVar12 = (int)uVar13 + *(int *)((longlong)puVar1 + uVar11 * 4);
      uVar13 = (ulonglong)uVar12;
      uVar17 = (uint)uVar19;
      if (uVar5 * 3 >> 2 <= uVar12) {
        if ((int)local_res8 < (int)uVar17) {
          local_res8 = uVar17;
        }
        break;
      }
      uVar11 = uVar11 + 1;
      uVar19 = (ulonglong)(uVar17 + 1);
    } while ((longlong)uVar11 < 0x400);
  }
  lVar24 = (longlong)(int)local_res8;
  if (-1 < (int)local_res8) {
    uVar11 = uVar15;
    puVar14 = puVar2 + lVar24;
    lVar20 = lVar24;
    uVar13 = uVar15;
    do {
      uVar5 = (int)uVar11 + *(int *)((longlong)puVar14 + ((longlong)puVar1 - (longlong)puVar2));
      uVar11 = (ulonglong)uVar5;
      if (uVar21 <= uVar5) {
        uVar13 = (ulonglong)((int)uVar13 + 0x100);
        uVar11 = uVar15;
      }
      lVar20 = lVar20 + -1;
      *puVar14 = ((0x10000 / uVar21) * (int)uVar11 >> 8) + (int)uVar13;
      puVar14 = puVar14 + -1;
    } while (-1 < lVar20);
  }
  lVar20 = (longlong)(int)(local_res8 + 1);
  if (lVar20 < 0x400) {
    lVar25 = 0x400 - lVar20;
    uVar11 = uVar15;
    uVar13 = uVar15;
    puVar14 = puVar2 + lVar20;
    do {
      uVar5 = (int)uVar11 + *(int *)((longlong)puVar14 + ((longlong)puVar1 - (longlong)puVar2));
      uVar11 = (ulonglong)uVar5;
      if (uVar5 < uVar21 * 8) {
        if (uVar21 <= uVar5) {
          uVar5 = (int)uVar13 + 0x100;
          goto LAB_18001209a;
        }
      }
      else {
        uVar5 = (int)uVar13 + 0x200;
LAB_18001209a:
        uVar13 = (ulonglong)uVar5;
        uVar11 = uVar15;
      }
      lVar25 = lVar25 + -1;
      *puVar14 = ((0x10000 / uVar21) * (int)uVar11 >> 8) + (int)uVar13;
      puVar14 = puVar14 + 1;
    } while (lVar25 != 0);
  }
  iVar23 = *(int *)(param_1 + 0x4c);
  uVar5 = *(int *)(param_1 + 0x24) * 1000;
  if (*(int *)(param_1 + 0x47950) == 0) {
    uVar5 = uVar5 >> ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
    uVar16 = (ushort)uVar5;
    if (0xffff < uVar5) {
      uVar16 = 0xffff;
    }
    uVar5 = (uint)uVar16;
    goto LAB_1800121bd;
  }
  iVar7 = uVar5 + 180000;
  iVar6 = (int)(iVar7 + (iVar7 >> 0x1f & 0xfffU)) >> 0xc;
  iVar10 = iVar18;
  if (iVar6 < 0) {
LAB_1800120f5:
    iVar6 = (iVar7 + iVar10 * -0x1000) * ((&DAT_180099004)[iVar10] - (&DAT_180099000)[iVar10]);
    iVar7 = (DAT_1800990ac - DAT_1800990b0) * 0xf20;
    iVar7 = ((((int)((iVar6 >> 0x1f & 0xfffU) + iVar6) >> 0xc) +
             ((int)(iVar7 + (iVar7 >> 0x1f & 0xfffU)) >> 0xc)) - DAT_1800990ac) +
            (&DAT_180099000)[iVar10];
  }
  else {
    if (0x285 < iVar6) {
      iVar10 = 0x285;
      goto LAB_1800120f5;
    }
    iVar10 = iVar6;
    if (iVar6 != 0x2b) goto LAB_1800120f5;
    iVar7 = (DAT_1800990b0 - DAT_1800990ac) * uVar5;
    iVar7 = (int)((iVar7 >> 0x1f & 0xfffU) + iVar7) >> 0xc;
  }
  uVar5 = iVar7 >> (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
  if (0xffff < (int)uVar5) {
    uVar5 = 0xffff;
  }
LAB_1800121bd:
  if (iVar23 < 0) {
    iVar7 = -0x51eb851f;
    if (iVar23 < -100) {
      iVar23 = -100;
    }
  }
  else {
    iVar7 = -0x1b4e81b5;
    if (100 < iVar23) {
      iVar23 = 100;
    }
  }
  iVar23 = (int)((ulonglong)((longlong)iVar7 * (longlong)(int)((uVar5 & 0xffff) * iVar23)) >> 0x20);
  uVar5 = (uVar5 & 0xffff) + ((iVar23 >> 4) - (iVar23 >> 0x1f));
  if (((*(int *)(param_1 + 0x41340) != 0) && (_DAT_180057598 < *(float *)(param_1 + 0x9c))) &&
     ((*(int *)(param_1 + 0x41558) == 1 ||
      ((*(int *)(param_1 + 0x41558) == 2 &&
       (*(int *)(param_1 + 0x41568) - *(int *)(param_1 + 0x41564) == 50000)))))) {
    uVar5 = uVar5 + (int)(((float)(int)((*(int *)(param_1 + 0x54) -
                                        (*(int *)(param_1 + 0x41568) + *(int *)(param_1 + 0x41564))
                                        / 2) * uVar5) * *(float *)(param_1 + 0x9c)) / _DAT_18005e820
                         );
  }
  iVar23 = *(int *)(param_1 + 0x42030);
  uVar12 = *(int *)(param_1 + 0x4202c) - iVar23;
  uVar21 = 0x80;
  if (0x80 < (int)uVar5) {
    uVar21 = uVar5;
  }
  uVar21 = (uVar12 * 0x10) / uVar21;
  if (uVar21 == 0) {
    uVar21 = 1;
  }
  else if (0x200 < uVar21) {
    uVar21 = 0x200;
  }
  uVar5 = uVar21 * 0x1800;
  uVar11 = uVar15;
  do {
    uVar17 = 1;
    if (uVar5 >> 0xd != 0) {
      uVar17 = uVar5 >> 0xd;
    }
    uVar5 = uVar5 + uVar21 * 4;
    local_1038[uVar11] = uVar17;
    uVar11 = uVar11 + 1;
  } while ((longlong)uVar11 < 0x400);
  iVar10 = 0x332;
  iVar7 = 100;
  if (*(int *)(param_1 + 0x48) < 100) {
    iVar7 = *(int *)(param_1 + 0x48);
  }
  iVar6 = -100;
  if (-100 < iVar7) {
    iVar6 = iVar7;
  }
  iVar6 = (iVar6 * 0x155) / 200;
  iVar7 = iVar6 + 0x155;
  iVar26 = iVar7;
  if (0x331 < iVar6 + 0x156) {
    iVar26 = 0x330;
  }
  iVar6 = *(int *)(param_1 + 0x42014);
  iVar22 = (int)(0xffc00000 / (ulonglong)uVar12);
  iVar9 = *(int *)(param_1 + 0x42010);
  if (iVar26 + 1 < 0x332) {
    do {
      iVar7 = (iVar10 + iVar26) / 2;
      if (bVar3) {
        bVar3 = false;
        iVar7 = iVar26;
      }
      uVar5 = *puVar2;
      if (uVar5 != 0) {
        uVar21 = iVar7 * 0x10 + 0x10;
        for (lVar20 = lVar24; -1 < lVar20; lVar20 = lVar20 + -1) {
          uVar12 = (iVar7 * 0x10 + 0x10) -
                   (puVar2[lVar20] * ((iVar7 * 0x40000 + 0x40000U) / uVar5) >> 0xe);
          if (local_1038[lVar20] < uVar21 - uVar12) {
            uVar12 = uVar21 - local_1038[lVar20];
          }
          *(char *)(lVar20 + 0x4284c + param_1) = (char)(uVar12 >> 6);
          uVar21 = uVar12;
        }
      }
      uVar5 = *(uint *)(param_1 + 0x44c48);
      if (uVar5 != 0) {
        uVar21 = iVar7 * 0x10;
        lVar20 = lVar24;
        while (lVar25 = lVar20 + 1, lVar25 < 0x400) {
          uVar12 = (puVar2[lVar25] * ((iVar7 * -0x40000 + 0xffc0000U) / uVar5) >> 0xe) +
                   iVar7 * 0x10;
          if (local_1038[lVar25] < uVar12 - uVar21) {
            uVar12 = local_1038[lVar25] + uVar21;
          }
          *(char *)(lVar20 + 0x4284d + param_1) = (char)(uVar12 >> 6);
          uVar21 = uVar12;
          lVar20 = lVar25;
        }
      }
      iVar4 = iVar7;
      if ((*(char *)((ulonglong)((uint)((iVar6 - iVar23) * iVar22) >> 0x16) + 0x4284c + param_1) ==
           '\0') &&
         (*(char *)((ulonglong)((uint)((iVar9 - iVar23) * iVar22) >> 0x16) + 0x4284c + param_1) !=
          -1)) {
        iVar4 = iVar10;
        iVar26 = iVar7;
      }
      iVar10 = iVar4;
    } while (iVar26 + 1 < iVar10);
  }
  DVar8 = GetTickCount();
  if ((((DVar8 - *(int *)(param_1 + 0x44c6c) < 0x78) &&
       (*(int *)(param_1 + 0x44c70) == *(int *)(param_1 + 0x4c))) &&
      (*(int *)(param_1 + 0x44c74) == *(int *)(param_1 + 0x48))) &&
     ((uVar5 = *(int *)(param_1 + 0x44c78) - local_res8, uVar21 = (int)uVar5 >> 0x1f,
      (int)((uVar5 ^ uVar21) - uVar21) < 0xb &&
      (uVar5 = *(int *)(param_1 + 0x44c7c) - iVar7, uVar21 = (int)uVar5 >> 0x1f,
      1 < (int)((uVar5 ^ uVar21) - uVar21))))) {
    iVar23 = *(int *)(param_1 + 0x47928);
    uVar5 = *(int *)(param_1 + 0x42018) - *(int *)(param_1 + 0x44c88);
    uVar21 = (int)uVar5 >> 0x1f;
    uVar21 = (uVar5 ^ uVar21) - uVar21;
    if (*(int *)(param_1 + 0x47950) == 0) {
      iVar23 = (uVar21 & 0xffff) << ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
    }
    else {
      iVar10 = iVar23 + 150000;
      uVar5 = (uVar21 & 0xffff) << (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
      iVar6 = (int)(iVar10 + (iVar10 >> 0x1f & 0xfffU)) >> 0xc;
      if ((-1 < iVar6) && (iVar18 = iVar6, 0x285 < iVar6)) {
        iVar18 = 0x285;
      }
      iVar6 = (&DAT_180099000)[iVar18];
      iVar26 = (&DAT_180099004)[iVar18] - iVar6;
      if ((iVar26 < (int)(((uVar5 ^ (int)uVar5 >> 0x1f) - ((int)uVar5 >> 0x1f)) * 2)) &&
         ((iVar26 = (iVar10 + iVar18 * -0x1000) * iVar26,
          iVar10 = iVar6 + ((int)(iVar26 + (iVar26 >> 0x1f & 0xfffU)) >> 0xc) + uVar5,
          iVar10 < iVar6 || ((int)(&DAT_180099004)[iVar18] < iVar10)))) {
        uVar5 = 0x286;
        uVar11 = uVar15;
        do {
          uVar21 = (int)(uVar5 + (int)uVar11) >> 1;
          if ((int)(&DAT_180099000)[(int)uVar21] <= iVar10) {
            uVar11 = (ulonglong)uVar21;
            uVar21 = uVar5;
          }
          uVar5 = uVar21;
          iVar18 = (int)uVar11;
        } while (iVar18 + 1U < uVar5);
        iVar10 = iVar10 - (&DAT_180099000)[iVar18];
        if (DAT_180073748 < iVar10) {
          iVar23 = ((int)((longlong)(int)(&DAT_180099a20)[iVar18] * (longlong)iVar10 >> 0xc) +
                    -150000 + iVar18 * 0x1000) - iVar23;
        }
        else {
          iVar23 = (((&DAT_180099a20)[iVar18] * iVar10 >> 0xc) + -150000 + iVar18 * 0x1000) - iVar23
          ;
        }
      }
      else {
        iVar23 = (int)((&DAT_180099a20)[iVar18] * uVar5) >> 0xc;
      }
    }
    iVar18 = *(int *)(param_1 + 0x47920);
    uVar5 = *(int *)(param_1 + 0x42010) - *(int *)(param_1 + 0x44c80);
    uVar21 = (int)uVar5 >> 0x1f;
    uVar21 = (uVar5 ^ uVar21) - uVar21;
    iVar10 = 0;
    if (*(int *)(param_1 + 0x47950) == 0) {
      iVar18 = (uVar21 & 0xffff) << ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
    }
    else {
      iVar6 = iVar18 + 150000;
      uVar5 = (uVar21 & 0xffff) << (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
      iVar9 = (int)(iVar6 + (iVar6 >> 0x1f & 0xfffU)) >> 0xc;
      iVar26 = iVar10;
      if ((-1 < iVar9) && (iVar26 = iVar9, 0x285 < iVar9)) {
        iVar26 = 0x285;
      }
      iVar9 = (&DAT_180099000)[iVar26];
      iVar22 = (&DAT_180099004)[iVar26] - iVar9;
      if ((iVar22 < (int)(((uVar5 ^ (int)uVar5 >> 0x1f) - ((int)uVar5 >> 0x1f)) * 2)) &&
         ((iVar22 = (iVar6 + iVar26 * -0x1000) * iVar22,
          iVar6 = iVar9 + ((int)(iVar22 + (iVar22 >> 0x1f & 0xfffU)) >> 0xc) + uVar5, iVar6 < iVar9
          || ((int)(&DAT_180099004)[iVar26] < iVar6)))) {
        uVar5 = 0x286;
        uVar11 = uVar15;
        do {
          uVar21 = (int)(uVar5 + (int)uVar11) >> 1;
          if ((int)(&DAT_180099000)[(int)uVar21] <= iVar6) {
            uVar11 = (ulonglong)uVar21;
            uVar21 = uVar5;
          }
          uVar5 = uVar21;
          iVar26 = (int)uVar11;
        } while (iVar26 + 1U < uVar5);
        iVar6 = iVar6 - (&DAT_180099000)[iVar26];
        if (DAT_180073748 < iVar6) {
          iVar18 = ((int)((longlong)(int)(&DAT_180099a20)[iVar26] * (longlong)iVar6 >> 0xc) +
                    -150000 + iVar26 * 0x1000) - iVar18;
        }
        else {
          iVar18 = (((&DAT_180099a20)[iVar26] * iVar6 >> 0xc) + -150000 + iVar26 * 0x1000) - iVar18;
        }
      }
      else {
        iVar18 = (int)((&DAT_180099a20)[iVar26] * uVar5) >> 0xc;
      }
    }
    uVar5 = *(int *)(param_1 + 0x42014) - *(int *)(param_1 + 0x44c84);
    uVar21 = (int)uVar5 >> 0x1f;
    uVar21 = (uVar5 ^ uVar21) - uVar21;
    if (*(int *)(param_1 + 0x47950) == 0) {
      iVar10 = (uVar21 & 0xffff) << ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
    }
    else {
      iVar6 = *(int *)(param_1 + 0x47924) + 150000;
      uVar5 = (uVar21 & 0xffff) << (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f);
      iVar26 = (int)(iVar6 + (iVar6 >> 0x1f & 0xfffU)) >> 0xc;
      if ((-1 < iVar26) && (iVar10 = iVar26, 0x285 < iVar26)) {
        iVar10 = 0x285;
      }
      iVar26 = (&DAT_180099000)[iVar10];
      iVar9 = (&DAT_180099004)[iVar10] - iVar26;
      if ((iVar9 < (int)(((uVar5 ^ (int)uVar5 >> 0x1f) - ((int)uVar5 >> 0x1f)) * 2)) &&
         ((iVar9 = (iVar6 + iVar10 * -0x1000) * iVar9,
          iVar6 = iVar26 + ((int)(iVar9 + (iVar9 >> 0x1f & 0xfffU)) >> 0xc) + uVar5, iVar6 < iVar26
          || ((int)(&DAT_180099004)[iVar10] < iVar6)))) {
        uVar5 = 0x286;
        do {
          uVar21 = (int)(uVar5 + (int)uVar15) >> 1;
          if ((int)(&DAT_180099000)[(int)uVar21] <= iVar6) {
            uVar15 = (ulonglong)uVar21;
            uVar21 = uVar5;
          }
          uVar5 = uVar21;
          iVar10 = (int)uVar15;
        } while (iVar10 + 1U < uVar5);
        iVar6 = iVar6 - (&DAT_180099000)[iVar10];
        if (DAT_180073748 < iVar6) {
          iVar10 = ((int)((longlong)(int)(&DAT_180099a20)[iVar10] * (longlong)iVar6 >> 0xc) +
                    -150000 + iVar10 * 0x1000) - *(int *)(param_1 + 0x47924);
        }
        else {
          iVar10 = (((&DAT_180099a20)[iVar10] * iVar6 >> 0xc) + -150000 + iVar10 * 0x1000) -
                   *(int *)(param_1 + 0x47924);
        }
      }
      else {
        iVar10 = (int)((&DAT_180099a20)[iVar10] * uVar5) >> 0xc;
      }
    }
    iVar18 = iVar10 + iVar23 * 2 + iVar18;
    if (iVar18 < 0x9c4) {
      if (iVar18 < 100) {
        iVar18 = 100;
      }
      puVar2 = (uint *)(param_1 + 0x43c4c);
      iVar7 = (iVar18 * iVar7 + *(int *)(param_1 + 0x44c7c) * 500) / (iVar18 + 500);
      uVar5 = *puVar2;
      if (uVar5 != 0) {
        uVar21 = iVar7 * 0x10 + 0x10;
        lVar24 = (longlong)(int)local_res8;
        if (-1 < (int)local_res8) {
          do {
            uVar12 = (iVar7 * 0x10 + 0x10) -
                     (puVar2[lVar24] * ((iVar7 * 0x40000 + 0x40000U) / uVar5) >> 0xe);
            if (local_1038[lVar24] < uVar21 - uVar12) {
              uVar12 = uVar21 - local_1038[lVar24];
            }
            lVar20 = lVar24 + -1;
            *(char *)(lVar24 + 0x4284c + param_1) = (char)(uVar12 >> 6);
            lVar24 = lVar20;
            uVar21 = uVar12;
          } while (-1 < lVar20);
        }
      }
      uVar5 = *(uint *)(param_1 + 0x44c48);
      if (uVar5 != 0) {
        uVar21 = iVar7 * 0x10;
        for (lVar24 = (longlong)(int)(local_res8 + 1); lVar24 < 0x400; lVar24 = lVar24 + 1) {
          uVar12 = (puVar2[lVar24] * ((iVar7 * -0x40000 + 0xffc0000U) / uVar5) >> 0xe) +
                   iVar7 * 0x10;
          if (local_1038[lVar24] < uVar12 - uVar21) {
            uVar12 = local_1038[lVar24] + uVar21;
          }
          *(char *)(lVar24 + 0x4284c + param_1) = (char)(uVar12 >> 6);
          uVar21 = uVar12;
        }
      }
    }
  }
  *(int *)(param_1 + 0x44c7c) = iVar7;
  *(DWORD *)(param_1 + 0x44c6c) = DVar8;
  *(undefined4 *)(param_1 + 0x44c70) = *(undefined4 *)(param_1 + 0x4c);
  *(undefined4 *)(param_1 + 0x44c74) = *(undefined4 *)(param_1 + 0x48);
  *(uint *)(param_1 + 0x44c78) = local_res8;
  *(undefined4 *)(param_1 + 0x44c80) = *(undefined4 *)(param_1 + 0x42010);
  *(undefined4 *)(param_1 + 0x44c84) = *(undefined4 *)(param_1 + 0x42014);
  *(undefined4 *)(param_1 + 0x44c88) = *(undefined4 *)(param_1 + 0x42018);
  return;
}


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

### ADDR 180011cc0 FUNC 180011cc0 (537 bytes) name=FUN_180011cc0

void FUN_180011cc0(longlong param_1)

{
  ulonglong *puVar1;
  uint uVar2;
  uint uVar3;
  int iVar4;
  uint uVar5;
  int iVar6;
  int iVar7;
  longlong lVar8;
  longlong lVar9;
  ulonglong uVar10;
  uint uVar11;
  int iVar12;
  int iVar13;
  longlong lVar14;
  int iVar15;
  int *piVar16;
  
  uVar3 = FUN_180011950(param_1,*(ushort **)(param_1 + 0x270),(ulonglong *)(param_1 + 0x42c4c));
  if (*(int *)(param_1 + 0x88) == 0) {
    iVar13 = *(int *)(param_1 + 0x42018);
  }
  else {
    iVar13 = *(int *)(param_1 + 0x44c64);
  }
  iVar6 = 100;
  if (*(int *)(param_1 + 0x48) < 100) {
    iVar6 = *(int *)(param_1 + 0x48);
  }
  iVar4 = FUN_1800108a0(param_1);
  iVar7 = *(int *)(param_1 + 0x4202c);
  puVar1 = (ulonglong *)(param_1 + 0x4284c);
  iVar12 = 0x3ff;
  uVar5 = (uint)((iVar13 - *(int *)(param_1 + 0x42030)) * 0x3ff) /
          (uint)(iVar7 - *(int *)(param_1 + 0x42030));
  iVar15 = -100;
  if (-100 < iVar6) {
    iVar15 = iVar6;
  }
  iVar6 = (iVar7 - iVar13) * 0xff;
  uVar11 = (iVar15 * 0xff) / 200 + 0xffU >> 2;
  uVar10 = (longlong)iVar6 % (longlong)iVar4 & 0xffffffff;
  piVar16 = (int *)(param_1 + 0x43c48);
  iVar15 = *piVar16;
  iVar6 = iVar6 / iVar4 + uVar11;
  if (0xff < iVar6) {
    iVar6 = 0xff;
  }
  if (iVar6 == 0xff) {
    for (; ((iVar15 < (int)(uVar3 >> 8) && ((int)(uVar5 + 1) < iVar12)) &&
           (uVar2 = (int)((0xff - uVar11) * iVar4) / 0xff, uVar10 = (ulonglong)uVar2,
           (int)uVar2 < iVar7 - iVar13)); iVar7 = iVar7 / 0x3ff + *(int *)(param_1 + 0x42030)) {
      iVar15 = iVar15 + piVar16[-1];
      iVar12 = iVar12 + -1;
      piVar16 = piVar16 + -1;
      iVar7 = (*(int *)(param_1 + 0x4202c) - *(int *)(param_1 + 0x42030)) * iVar12;
      uVar10 = (ulonglong)((longlong)iVar7 * -0x7fdff7fd) >> 0x20;
    }
  }
  lVar14 = (longlong)iVar12;
  if ((int)uVar5 < lVar14) {
    lVar8 = (longlong)(int)uVar5;
    iVar13 = 0;
    do {
      lVar9 = lVar8 + 1;
      uVar10 = (longlong)iVar13 % (longlong)(int)(iVar12 - uVar5) & 0xffffffff;
      *(char *)(lVar8 + (longlong)puVar1) = (char)(iVar13 / (int)(iVar12 - uVar5)) + (char)uVar11;
      lVar8 = lVar9;
      iVar13 = iVar13 + (iVar6 - uVar11);
    } while (lVar9 < lVar14);
  }
  if (lVar14 < 0x400) {
    FUN_1800357d0((ulonglong *)(lVar14 + (longlong)puVar1),CONCAT71((int7)(uVar10 >> 8),0xff),
                  0x400 - lVar14);
  }
  iVar13 = iVar12 + -1;
  lVar14 = (longlong)iVar13;
  if (-1 < iVar13) {
    iVar7 = (iVar6 - uVar11) * (iVar13 - uVar5);
    do {
      iVar15 = iVar7 / (int)(iVar12 - uVar5) + uVar11;
      if (iVar15 < 1) {
        FUN_1800357d0(puVar1,0,(longlong)(iVar13 + 1));
        return;
      }
      *(char *)(lVar14 + (longlong)puVar1) = (char)iVar15;
      iVar13 = iVar13 + -1;
      iVar7 = iVar7 + (uVar11 - iVar6);
      lVar14 = lVar14 + -1;
    } while (-1 < lVar14);
  }
  return;
}


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

### ADDR 180011380 FUNC 180011380 (1476 bytes) name=FUN_180011380

/* WARNING: Function: __chkstk replaced with injection: alloca_probe */

void FUN_180011380(longlong param_1)

{
  uint *puVar1;
  longlong lVar2;
  float *pfVar3;
  ulonglong uVar4;
  ulonglong uVar5;
  uint uVar6;
  int iVar7;
  ulonglong uVar8;
  ulonglong uVar9;
  uint uVar10;
  uint uVar11;
  ulonglong uVar12;
  uint uVar13;
  uint uVar14;
  ushort *puVar15;
  uint uVar16;
  uint uVar17;
  uint uVar18;
  uint uVar19;
  int iVar20;
  float fVar21;
  float fVar22;
  float fVar23;
  uint local_2828 [1279];
  float afStack_142c [1281];
  
  uVar17 = *(uint *)(param_1 + 0x41fc4);
  puVar15 = *(ushort **)(param_1 + 0x270);
  uVar4 = 0;
  uVar10 = 0;
  if (uVar17 != 0) {
    uVar18 = *(uint *)(param_1 + 0x41fc0);
    uVar12 = (ulonglong)*(uint *)(param_1 + 0x41fc4);
    puVar1 = local_2828;
    do {
      uVar9 = uVar4;
      for (uVar6 = uVar18 >> 2; uVar6 != 0; uVar6 = uVar6 - 1) {
        uVar9 = (ulonglong)
                ((int)uVar9 + (uint)*puVar15 + (uint)puVar15[1] + (uint)puVar15[2] +
                (uint)puVar15[3]);
        puVar15 = puVar15 + 4;
      }
      uVar12 = uVar12 - 1;
      *puVar1 = (int)(uVar9 / uVar18);
      puVar1 = puVar1 + 1;
    } while (uVar12 != 0);
  }
  uVar11 = uVar17 >> 2;
  uVar18 = 0;
  uVar13 = uVar17 * 7 >> 3;
  uVar12 = uVar4;
  uVar6 = uVar18;
  uVar16 = uVar10;
  if (1 < uVar11) {
    uVar6 = (uVar11 - 2 >> 1) + 1;
    uVar8 = (ulonglong)uVar6;
    uVar6 = uVar6 * 2;
    uVar9 = uVar4;
    uVar5 = uVar4;
    do {
      uVar16 = (int)uVar5 + local_2828[uVar12];
      uVar5 = (ulonglong)uVar16;
      uVar10 = (int)uVar9 + local_2828[uVar12 + 1];
      uVar9 = (ulonglong)uVar10;
      uVar12 = uVar12 + 2;
      uVar8 = uVar8 - 1;
    } while (uVar8 != 0);
  }
  if (uVar6 < uVar11) {
    uVar18 = local_2828[uVar12];
  }
  uVar12 = (ulonglong)uVar11;
  uVar18 = uVar18 + uVar10 + uVar16;
  if (uVar11 < uVar17) {
    puVar1 = local_2828 + uVar11;
    uVar9 = (ulonglong)(*(int *)(param_1 + 0x41fc4) - uVar11);
    do {
      uVar4 = (ulonglong)((int)uVar4 + *puVar1);
      puVar1 = puVar1 + 1;
      uVar9 = uVar9 - 1;
    } while (uVar9 != 0);
  }
  iVar20 = (uVar13 - uVar11) + 1;
  uVar9 = uVar12;
  uVar10 = uVar11;
  if (3 < iVar20) {
    fVar23 = (float)uVar17;
    uVar6 = uVar11 + 2;
    do {
      uVar18 = uVar18 + local_2828[uVar9];
      uVar16 = (int)uVar4 - local_2828[uVar9];
      iVar7 = uVar17 - uVar10;
      fVar22 = (float)(uVar6 - 1) / fVar23;
      fVar21 = (float)uVar18 / (float)(uVar6 - 1) - (float)uVar16 / (float)(iVar7 - 1);
      uVar18 = uVar18 + local_2828[uVar9 + 1];
      uVar16 = uVar16 - local_2828[uVar9 + 1];
      afStack_142c[uVar9 + 1] = (DAT_18005e700 - fVar22) * fVar22 * fVar21 * fVar21;
      fVar22 = (float)uVar6 / fVar23;
      uVar19 = uVar18 + local_2828[uVar9 + 2];
      uVar14 = uVar16 - local_2828[uVar9 + 2];
      fVar21 = (float)uVar18 / (float)uVar6 - (float)uVar16 / (float)(iVar7 - 2);
      afStack_142c[uVar9 + 2] = (DAT_18005e700 - fVar22) * fVar22 * fVar21 * fVar21;
      uVar18 = uVar19 + local_2828[uVar9 + 3];
      uVar4 = (ulonglong)(uVar14 - local_2828[uVar9 + 3]);
      fVar22 = (float)(uVar6 + 1) / fVar23;
      uVar16 = uVar6 + 2;
      fVar21 = (float)uVar19 / (float)(uVar6 + 1) - (float)uVar14 / (float)(iVar7 - 3);
      afStack_142c[uVar9 + 3] = (DAT_18005e700 - fVar22) * fVar22 * fVar21 * fVar21;
      fVar22 = (float)uVar16 / fVar23;
      uVar10 = uVar10 + 4;
      uVar9 = uVar9 + 4;
      uVar6 = uVar6 + 4;
      fVar21 = (float)uVar18 / (float)uVar16 - (float)uVar4 / (float)(iVar7 - 4);
      afStack_142c[uVar9] = (DAT_18005e700 - fVar22) * fVar22 * fVar21 * fVar21;
    } while (uVar10 <= uVar13 - 3);
  }
  uVar5 = 0;
  if (uVar10 <= uVar13) {
    uVar6 = *(uint *)(param_1 + 0x41fc4);
    lVar2 = uVar9 * 4;
    uVar16 = uVar10;
    do {
      uVar16 = uVar16 + 1;
      uVar18 = uVar18 + *(int *)((longlong)local_2828 + lVar2);
      uVar4 = (ulonglong)(uint)((int)uVar4 - *(int *)((longlong)local_2828 + lVar2));
      fVar21 = (float)uVar16 / (float)uVar6;
      iVar7 = uVar6 - uVar10;
      uVar10 = uVar10 + 1;
      fVar23 = (float)uVar18 / (float)uVar16 - (float)uVar4 / (float)(iVar7 - 1);
      *(float *)((longlong)afStack_142c + lVar2 + 4) =
           (DAT_18005e700 - fVar21) * fVar21 * fVar23 * fVar23;
      lVar2 = lVar2 + 4;
    } while (uVar10 <= uVar13);
  }
  fVar23 = afStack_142c[(ulonglong)uVar11 + 1];
  uVar10 = uVar11;
  uVar18 = uVar11;
  if (3 < iVar20) {
    uVar6 = uVar11 + 2;
    do {
      if (fVar23 <= afStack_142c[uVar12 + 1]) {
        fVar23 = afStack_142c[uVar12 + 1];
        uVar10 = uVar18;
      }
      if (fVar23 <= afStack_142c[uVar12 + 2]) {
        uVar10 = uVar6 - 1;
        fVar23 = afStack_142c[uVar12 + 2];
      }
      if (fVar23 <= afStack_142c[uVar12 + 3]) {
        fVar23 = afStack_142c[uVar12 + 3];
        uVar10 = uVar6;
      }
      if (fVar23 <= afStack_142c[uVar12 + 4]) {
        uVar10 = uVar6 + 1;
        fVar23 = afStack_142c[uVar12 + 4];
      }
      uVar18 = uVar18 + 4;
      uVar12 = uVar12 + 4;
      uVar6 = uVar6 + 4;
    } while (uVar18 <= uVar13 - 3);
  }
  if (uVar18 <= uVar13) {
    pfVar3 = afStack_142c + uVar12 + 1;
    do {
      if (fVar23 <= *pfVar3) {
        fVar23 = *pfVar3;
        uVar10 = uVar18;
      }
      uVar18 = uVar18 + 1;
      pfVar3 = pfVar3 + 1;
    } while (uVar18 <= uVar13);
  }
  uVar18 = 0;
  if ((uVar10 != uVar11) && (uVar10 != uVar13)) {
    uVar6 = uVar10 + 1;
    uVar4 = uVar5;
    uVar12 = uVar5;
    uVar9 = uVar5;
    if ((int)uVar6 < 2) {
LAB_1800117f6:
      uVar14 = (uint)uVar9;
      uVar13 = (uint)uVar12;
      uVar19 = local_2828[uVar4];
    }
    else {
      uVar16 = uVar10 + 1 >> 1;
      uVar8 = (ulonglong)uVar16;
      do {
        uVar14 = (int)uVar9 + local_2828[uVar4];
        uVar9 = (ulonglong)uVar14;
        uVar13 = (int)uVar12 + local_2828[uVar4 + 1];
        uVar12 = (ulonglong)uVar13;
        uVar4 = uVar4 + 2;
        uVar8 = uVar8 - 1;
      } while (uVar8 != 0);
      uVar19 = uVar18;
      if (uVar16 * 2 <= uVar10) goto LAB_1800117f6;
    }
    uVar4 = uVar5;
    if (uVar6 < uVar17) {
      puVar1 = local_2828 + (int)uVar6;
      uVar12 = (ulonglong)(uVar17 - uVar6);
      do {
        uVar4 = (ulonglong)((int)uVar4 + *puVar1);
        puVar1 = puVar1 + 1;
        uVar12 = uVar12 - 1;
      } while (uVar12 != 0);
    }
    uVar6 = (uVar19 + uVar13 + uVar14) / uVar6;
    iVar20 = (int)(uVar4 / ((uVar17 - uVar10) - 1));
    uVar16 = (int)(uVar6 - iVar20) >> 0x1f;
    if (((int)(iVar20 + uVar6) <= (int)(((uVar6 - iVar20 ^ uVar16) - uVar16) * 0x80)) &&
       (iVar20 <= (int)uVar6)) {
      uVar6 = *(uint *)(param_1 + 0x44c60);
      *(uint *)(param_1 + 0x44c68) = local_2828[uVar10];
      if ((uVar11 < uVar6) && (uVar6 <= uVar17 - 1)) {
        uVar17 = uVar17 >> 7;
        uVar16 = uVar17;
        if (uVar17 == 0) {
          uVar16 = 1;
        }
        if (uVar16 + uVar6 <= uVar10) {
          uVar10 = uVar17;
          if (uVar17 == 0) {
            uVar10 = 1;
          }
          uVar10 = uVar10 + uVar6;
        }
        uVar16 = uVar17;
        if (uVar17 == 0) {
          uVar16 = 1;
        }
        if (uVar10 <= uVar6 - uVar16) {
          if (uVar17 == 0) {
            uVar17 = 1;
          }
          uVar10 = uVar6 - uVar17;
        }
      }
      uVar4 = uVar5;
      uVar12 = uVar5;
      if ((int)(uVar10 + 1) < 2) {
LAB_1800118f9:
        uVar16 = (uint)uVar12;
        uVar6 = (uint)uVar4;
        uVar18 = local_2828[uVar5];
      }
      else {
        uVar17 = uVar10 + 1 >> 1;
        uVar9 = (ulonglong)uVar17;
        do {
          uVar16 = (int)uVar12 + local_2828[uVar5];
          uVar12 = (ulonglong)uVar16;
          uVar6 = (int)uVar4 + local_2828[uVar5 + 1];
          uVar4 = (ulonglong)uVar6;
          uVar5 = uVar5 + 2;
          uVar9 = uVar9 - 1;
        } while (uVar9 != 0);
        if (uVar17 * 2 <= uVar10) goto LAB_1800118f9;
      }
      *(uint *)(param_1 + 0x44c60) = uVar10;
      uVar17 = (uVar6 + uVar16 + uVar18) / (uVar10 + 1);
      goto LAB_180011928;
    }
  }
  *(undefined4 *)(param_1 + 0x44c68) = 0;
  *(uint *)(param_1 + 0x44c60) = uVar17 - 1;
  uVar17 = *(uint *)(param_1 + 0x42018);
LAB_180011928:
  *(uint *)(param_1 + 0x44c64) = uVar17;
  return;
}


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

### ADDR 180010c40 FUNC 180010c40 (574 bytes) name=FUN_180010c40

void FUN_180010c40(longlong param_1)

{
  uint uVar1;
  uint uVar2;
  int iVar3;
  uint uVar4;
  uint uVar5;
  int iVar6;
  uint uVar7;
  uint uVar8;
  undefined4 *puVar9;
  uint uVar10;
  uint uVar11;
  ulonglong uVar12;
  uint uVar13;
  
  uVar1 = *(uint *)(param_1 + 0x4202c);
  uVar10 = *(uint *)(param_1 + 0x47938);
  uVar2 = *(uint *)(param_1 + 0x42030);
  iVar3 = *(int *)(param_1 + 0x18);
  uVar5 = 0;
  uVar8 = *(uint *)(param_1 + 0x41fc0);
  uVar13 = 0xffff;
  uVar7 = 0xffff;
  *(undefined4 *)(param_1 + 0x74) = 1;
  do {
    uVar11 = uVar7 + uVar5 >> 1;
    iVar6 = FUN_180016290(param_1,uVar11,(uVar10 >> 1) + (uVar8 >> 1),0);
    if ((*(int *)(param_1 + 0x74) != 0) || (*(int *)(param_1 + 0x78) != 0)) {
      iVar6 = FUN_180015b90(param_1,iVar6,*(float *)(param_1 + 0xd4));
    }
    uVar4 = uVar11;
    if (iVar6 <= iVar3) {
      uVar4 = uVar7;
      uVar5 = uVar11;
    }
    uVar7 = uVar4;
  } while (uVar5 + 1 < uVar7);
  iVar3 = *(int *)(param_1 + 0x14);
  uVar10 = *(uint *)(param_1 + 0x47938);
  uVar7 = uVar7 + uVar5 >> 1;
  uVar5 = 0;
  uVar8 = *(uint *)(param_1 + 0x41fc0);
  *(undefined4 *)(param_1 + 0x74) = 1;
  do {
    uVar11 = uVar13 + uVar5 >> 1;
    iVar6 = FUN_180016290(param_1,uVar11,(uVar10 >> 1) + (uVar8 >> 1),0);
    if ((*(int *)(param_1 + 0x74) != 0) || (*(int *)(param_1 + 0x78) != 0)) {
      iVar6 = FUN_180015b90(param_1,iVar6,*(float *)(param_1 + 0xd4));
    }
    uVar4 = uVar11;
    if (iVar6 <= iVar3) {
      uVar4 = uVar13;
      uVar5 = uVar11;
    }
    uVar13 = uVar4;
  } while (uVar5 + 1 < uVar13);
  uVar8 = uVar13 + uVar5 >> 1;
  uVar10 = 0x100;
  if (uVar1 < uVar7) {
    uVar5 = 0x100;
  }
  else if (uVar7 < uVar2) {
    uVar5 = 0xffffffff;
  }
  else {
    uVar5 = (uint)*(byte *)((ulonglong)((uVar7 - uVar2) * 0x3ff) / (ulonglong)(uVar1 - uVar2) +
                            0x4284c + param_1);
  }
  if (uVar8 <= uVar1) {
    if (uVar8 < uVar2) {
      uVar10 = 0xffffffff;
    }
    else {
      uVar10 = (uint)*(byte *)((ulonglong)((uVar8 - uVar2) * 0x3ff) / (ulonglong)(uVar1 - uVar2) +
                               0x4284c + param_1);
    }
  }
  memcpy((void *)(param_1 + 0x6f0),(void *)(param_1 + 0x2c8),0x400);
  if ((int)uVar10 < 0) {
    uVar10 = 0;
  }
  if (0xff < (int)uVar5) {
    uVar5 = 0xff;
  }
  if ((int)uVar10 <= (int)uVar5) {
    uVar12 = (ulonglong)((uVar5 - uVar10) + 1);
    puVar9 = (undefined4 *)(param_1 + 0x6f0 + (longlong)(int)uVar10 * 4);
    do {
      uVar12 = uVar12 - 1;
      *puVar9 = *(undefined4 *)(param_1 + 0x2c);
      puVar9 = puVar9 + 1;
    } while (uVar12 != 0);
  }
  memcpy((void *)(param_1 + 0xb18),(void *)(param_1 + 0x6f0),0x400);
  memcpy((void *)(param_1 + 0xf40),(void *)(param_1 + 0x6f0),0x400);
  return;
}


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

### ADDR 18001d930 FUNC 18001d930 (1392 bytes) name=FUN_18001d930

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

undefined4 FUN_18001d930(longlong param_1)

{
  int *piVar1;
  uint uVar2;
  uint *_Dst;
  undefined8 *puVar3;
  bool bVar4;
  LPCSTR pCVar5;
  undefined4 uVar6;
  uint uVar7;
  undefined **ppuVar8;
  longlong lVar9;
  undefined8 uVar10;
  int *_Src;
  ulonglong uVar11;
  uint *_Src_00;
  uint uVar12;
  size_t _Size;
  ulonglong uVar13;
  int iVar14;
  int *piVar15;
  undefined1 auStackY_2e8 [32];
  longlong local_2a8;
  LPCSTR local_2a0;
  longlong local_298 [2];
  undefined4 local_288;
  uint uStack_284;
  uint local_280;
  undefined4 uStack_27c;
  undefined4 local_278;
  int iStack_274;
  undefined4 local_270;
  undefined4 uStack_26c;
  undefined4 local_268;
  undefined4 uStack_264;
  int local_260;
  int iStack_25c;
  undefined8 local_258;
  undefined8 local_250;
  undefined4 local_248;
  uint uStack_244;
  undefined4 local_240;
  undefined8 local_238;
  WCHAR local_228 [256];
  ulonglong local_28;
  
  local_238 = 0xfffffffffffffffe;
  local_28 = DAT_18006cea0 ^ (ulonglong)auStackY_2e8;
  if (param_1 == 0) {
    uVar6 = 1;
  }
  else {
    local_288 = 0;
    FUN_1800357d0((ulonglong *)&uStack_284,0,0x48);
    uStack_27c = 1;
    local_278 = 0;
    iStack_274 = *(int *)(param_1 + 0x50);
    local_270 = *(undefined4 *)(param_1 + 0x54);
    uStack_26c = 8;
    local_268 = 0xffff3cb0;
    bVar4 = false;
    piVar15 = *(int **)(param_1 + 0x2d20);
    if (*(int *)(param_1 + 0x2d08) != 0) {
      while( true ) {
        iVar14 = (int)piVar15;
        uVar7 = usb_bulk_read(*(undefined8 *)(param_1 + 0x38),0x81,piVar15,
                              (*(int *)(param_1 + 0x2d18) * 2 - iVar14) + *(int *)(param_1 + 0x2d20)
                             );
        if (*(int *)(param_1 + 0x2d08) == 0) break;
        if ((int)uVar7 < 0) {
          ppuVar8 = FUN_18001fcc0();
          if (ppuVar8 == (undefined **)0x0) {
                    /* WARNING: Subroutine does not return */
            FUN_18000b170(-0x7fffbffb);
          }
          lVar9 = (**(code **)(*ppuVar8 + 0x18))(ppuVar8);
          local_2a0 = (LPCSTR)(lVar9 + 0x18);
          uVar10 = usb_strerror();
          FUN_18001e660((longlong *)&local_2a0,(byte *)"usb error: usb_bulk_read=%d, %s",
                        (ulonglong)uVar7,uVar10);
          pCVar5 = local_2a0;
          MultiByteToWideChar(0,0,local_2a0,-1,local_228,0x100);
          Sleep(10);
          if (uVar7 == 0xfffffffb) {
            usb_clear_halt(*(undefined8 *)(param_1 + 0x38),0x81);
            LOCK();
            piVar15 = (int *)(pCVar5 + -8);
            iVar14 = *piVar15;
            *piVar15 = *piVar15 + -1;
            UNLOCK();
            if (iVar14 + -1 < 1) {
              (**(code **)(**(longlong **)(pCVar5 + -0x18) + 8))();
            }
            break;
          }
          piVar15 = *(int **)(param_1 + 0x2d20);
          LOCK();
          piVar1 = (int *)(pCVar5 + -8);
          iVar14 = *piVar1;
          *piVar1 = *piVar1 + -1;
          UNLOCK();
          if (iVar14 + -1 < 1) {
            (**(code **)(**(longlong **)(pCVar5 + -0x18) + 8))();
          }
        }
        else {
          uVar12 = (iVar14 - *(int *)(param_1 + 0x2d20)) + uVar7;
          if (!bVar4) {
            piVar1 = (int *)((longlong)piVar15 + (longlong)(int)uVar7);
            piVar15 = *(int **)(param_1 + 0x2d20);
            for (_Src = piVar15; _Src < piVar1; _Src = _Src + 1) {
              if (*_Src == 0x1bb1b11b) goto LAB_18001db0e;
            }
            if (*_Src != 0x1bb1b11b) goto LAB_18001de17;
LAB_18001db0e:
            uVar12 = (iVar14 - (int)_Src) + uVar7;
            if (_Src != piVar15) {
              memcpy(piVar15,_Src,(longlong)(int)uVar12);
            }
            bVar4 = true;
          }
          uVar7 = *(uint *)(param_1 + 0x2d18);
          uVar13 = (ulonglong)uVar7;
          uVar11 = (ulonglong)(int)uVar12;
          if (uVar11 < uVar13 + 0x38) {
            piVar15 = (int *)(uVar11 + *(longlong *)(param_1 + 0x2d20));
          }
          else {
            _Dst = *(uint **)(param_1 + 0x2d20);
            if (*_Dst == 0x1bb1b11b) {
              uVar2 = _Dst[2];
              if (((uVar2 == uVar7) && (*(int *)(uVar13 + 0x1c + (longlong)_Dst) == 0x1bb1b11c)) &&
                 ((iVar14 = *(int *)(uVar13 + 0x28 + (longlong)_Dst), iVar14 == 0 || (iVar14 == 1)))
                 ) {
                uStack_284 = _Dst[1];
                uStack_244 = _Dst[3];
                if (iStack_274 == 0xa0) {
                  iStack_25c = *(int *)(uVar13 + 0x24 + (longlong)_Dst);
                  local_260 = iStack_25c + -500;
                }
                else if (iStack_274 == 0x180) {
                  local_260 = *(int *)(uVar13 + 0x2c + (longlong)_Dst);
                  iStack_25c = local_260 + 500;
                }
                else if (iStack_274 == 0x280) {
                  local_260 = *(int *)(uVar13 + 0x2c + (longlong)_Dst);
                  iStack_25c = *(int *)(uVar13 + 0x24 + (longlong)_Dst);
                }
                local_280 = uVar2;
                FUN_180001470(param_1 + 0xb8);
                puVar3 = *(undefined8 **)(param_1 + 0x2d28);
                *puVar3 = CONCAT44(uStack_284,local_288);
                puVar3[1] = CONCAT44(uStack_27c,local_280);
                puVar3[2] = CONCAT44(iStack_274,local_278);
                puVar3[3] = CONCAT44(uStack_26c,local_270);
                puVar3[4] = CONCAT44(uStack_264,local_268);
                puVar3[5] = CONCAT44(iStack_25c,local_260);
                puVar3[6] = local_258;
                puVar3[7] = local_250;
                puVar3[8] = CONCAT44(uStack_244,local_248);
                *(undefined4 *)(puVar3 + 9) = local_240;
                memcpy((void *)(*(longlong *)(param_1 + 0x2d28) + 0x4c),
                       (void *)(*(longlong *)(param_1 + 0x2d20) + 0x1c),
                       (ulonglong)*(uint *)(param_1 + 0x2d18));
                (**(code **)(*(longlong *)(param_1 + 0xb8) + 0x28))(param_1 + 0xb8);
                SetEvent(*(HANDLE *)(param_1 + 0x2d10));
                *(int *)(param_1 + 8) = *(int *)(param_1 + 8) + 1;
              }
              else {
                if ((uVar2 != uVar7) || (*(int *)(uVar13 + 0x1c + (longlong)_Dst) == 0x1bb1b11c))
                goto LAB_18001dd96;
                for (_Src_00 = (uint *)((uVar11 & 0xfffffffffffffffc) + (longlong)_Dst);
                    _Dst < _Src_00; _Src_00 = _Src_00 + -1) {
                  if (*_Src_00 == 0x1bb1b11b) goto LAB_18001dcf0;
                }
                if (*_Src_00 == 0x1bb1b11b) {
LAB_18001dcf0:
                  if (_Dst < _Src_00) {
                    _Size = (size_t)(int)(uVar12 + ((int)_Dst - (int)_Src_00));
                    memcpy(_Dst,_Src_00,_Size);
                    piVar15 = (int *)(_Size + *(longlong *)(param_1 + 0x2d20));
                    goto LAB_18001de17;
                  }
                }
                ppuVar8 = FUN_18001fcc0();
                if (ppuVar8 == (undefined **)0x0) {
                    /* WARNING: Subroutine does not return */
                  FUN_18000b170(-0x7fffbffb);
                }
                local_298[0] = (**(code **)(*ppuVar8 + 0x18))(ppuVar8);
                local_298[0] = local_298[0] + 0x18;
                FUN_18001ad00(local_298,
                              L"drop1, lentgh=%d, startcode=%X, sendbyte=%d, endcode=%X, intDrop=%d"
                              ,(ulonglong)uVar12,(ulonglong)*_Dst);
                LOCK();
                piVar15 = (int *)(local_298[0] + -8);
                iVar14 = *piVar15;
                *piVar15 = *piVar15 + -1;
                UNLOCK();
                if (iVar14 + -1 < 1) {
                  (**(code **)(**(longlong **)(local_298[0] + -0x18) + 8))();
                }
              }
            }
            else {
LAB_18001dd96:
              ppuVar8 = FUN_18001fcc0();
              if (ppuVar8 == (undefined **)0x0) {
                    /* WARNING: Subroutine does not return */
                FUN_18000b170(-0x7fffbffb);
              }
              local_2a8 = (**(code **)(*ppuVar8 + 0x18))(ppuVar8);
              local_2a8 = local_2a8 + 0x18;
              FUN_18001ad00(&local_2a8,
                            L"drop2, lentgh=%d, startcode=%X, sendbyte=%d, endcode=%X, intDrop=%d",
                            (ulonglong)uVar12,(ulonglong)*_Dst);
              LOCK();
              piVar15 = (int *)(local_2a8 + -8);
              iVar14 = *piVar15;
              *piVar15 = *piVar15 + -1;
              UNLOCK();
              if (iVar14 + -1 < 1) {
                (**(code **)(**(longlong **)(local_2a8 + -0x18) + 8))();
              }
            }
            bVar4 = false;
            piVar15 = *(int **)(param_1 + 0x2d20);
          }
        }
LAB_18001de17:
        if (*(int *)(param_1 + 0x2d08) == 0) break;
      }
    }
    uVar6 = 0;
  }
  return uVar6;
}


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

### ADDR 180008bd0 FUNC 180008bd0 (3886 bytes) name=FUN_180008bd0

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

undefined8 FUN_180008bd0(uint param_1)

{
  int *piVar1;
  ulonglong *puVar2;
  char cVar3;
  longlong *plVar4;
  undefined8 uVar5;
  undefined **ppuVar6;
  undefined8 *puVar7;
  int iVar8;
  uint uVar9;
  longlong lVar10;
  ulonglong *_Source;
  ulonglong uVar11;
  longlong lVar12;
  uint uVar13;
  char *pcVar14;
  ulonglong uVar15;
  longlong lVar16;
  undefined1 auStack_d8 [32];
  ulonglong *local_b8;
  uint local_b0;
  uint local_ac;
  uint local_a0;
  uint local_9c;
  undefined4 local_98;
  undefined8 local_78;
  undefined8 local_70 [5];
  undefined4 local_48;
  float local_44;
  char local_40;
  char local_3f;
  char local_3e;
  char local_3d;
  char local_3c;
  char local_3b;
  char local_3a;
  char local_39;
  ulonglong local_38;
  
  local_78 = 0xfffffffffffffffe;
  local_38 = DAT_18006cea0 ^ (ulonglong)auStack_d8;
  lVar16 = (longlong)(int)param_1;
  uVar11 = (ulonglong)param_1;
  lVar12 = uVar11 * 0x4a8;
  if (*(int *)((&DAT_180073758)[uVar11 * 0x95] + 0x14) == 0) {
    SetLastError(0xe4ae0005);
LAB_180008c52:
    if (*(int *)((&DAT_180073758)[uVar11 * 0x95] + 0x14) == 0) {
      SetLastError(0xe4ae0005);
    }
    else {
      uVar5 = FUN_18001d6e0((&DAT_180073758)[uVar11 * 0x95],(undefined8 *)&local_b0,local_70,1000);
      if ((int)uVar5 != 0) goto LAB_180008c98;
    }
    SetLastError(0xe4ae0008);
    uVar5 = 0;
  }
  else {
    uVar5 = FUN_18001d6e0((&DAT_180073758)[uVar11 * 0x95],(undefined8 *)&local_b0,local_70,500);
    if ((int)uVar5 == 0) goto LAB_180008c52;
LAB_180008c98:
    uVar9 = local_b0;
    uVar13 = local_ac >> 0x18;
    if ((((((uVar13 == 0) || (uVar13 == 1)) && (local_b0 != 0x9898f19)) &&
         ((local_b0 != 0x9898f1a && (local_b0 != 0x9898f1c)))) &&
        ((local_b0 != 0x9898f1f && ((local_b0 != 0x9898f20 && (local_b0 != 0x9898f21)))))) &&
       (local_b0 != 0x9898f2b)) {
      SetLastError(0xe4ae000b);
      uVar5 = 0;
    }
    else {
      FUN_1800357d0((ulonglong *)(&DAT_1800737b8 + uVar11 * 0x12a),0,0x48);
      *(undefined4 *)(&DAT_180073bac + lVar12) = 0;
      *(undefined4 *)(&DAT_180073bb0 + lVar12) = 0;
      FUN_1800357d0((ulonglong *)(&DAT_180073bb4 + lVar12),0,0x38);
      FUN_1800357d0((ulonglong *)((&DAT_180073750)[uVar11 * 0x95] + 8),0,200);
      (&DAT_1800737b0)[uVar11 * 0x12a] = uVar9;
      *(undefined4 *)(&DAT_1800737b4 + lVar12) = 0;
      *(undefined4 *)(&DAT_1800737c0 + lVar12) = 0;
      *(undefined4 *)(&DAT_1800737c4 + lVar12) = 0;
      ppuVar6 = FUN_18001fcc0();
      if (ppuVar6 == (undefined **)0x0) {
                    /* WARNING: Subroutine does not return */
        FUN_18000b170(-0x7fffbffb);
      }
      puVar7 = (undefined8 *)(**(code **)(*ppuVar6 + 0x18))(ppuVar6);
      _Source = puVar7 + 3;
      local_b8 = _Source;
      switch(uVar13) {
      case 0:
        lVar10 = -1;
        pcVar14 = "C1";
        do {
          if (lVar10 == 0) break;
          lVar10 = lVar10 + -1;
          cVar3 = *pcVar14;
          pcVar14 = pcVar14 + 1;
        } while (cVar3 != '\0');
        iVar8 = ~(uint)lVar10 - 1;
        if (iVar8 == 0) {
          plVar4 = (longlong *)*puVar7;
          if (*(int *)(puVar7 + 1) != 0) {
            if (*(int *)(puVar7 + 2) < 0) {
              if (*(int *)((longlong)puVar7 + 0xc) < 0) {
                    /* WARNING: Subroutine does not return */
                FUN_18000b170(-0x7ff8ffa9);
              }
              *(undefined4 *)(puVar7 + 1) = 0;
              *(char *)_Source = '\0';
            }
            else {
              LOCK();
              piVar1 = (int *)(puVar7 + 2);
              iVar8 = *piVar1;
              *piVar1 = *piVar1 + -1;
              UNLOCK();
              if (iVar8 + -1 < 1) {
                (**(code **)(*(longlong *)*puVar7 + 8))();
              }
              lVar10 = (**(code **)(*plVar4 + 0x18))(plVar4);
              _Source = (ulonglong *)(lVar10 + 0x18);
              uVar9 = local_b0;
              local_b8 = _Source;
            }
          }
        }
        else {
          uVar13 = *(uint *)(puVar7 + 1);
          uVar15 = (longlong)&DAT_1800590e0 - (longlong)_Source;
          if ((int)(*(int *)((longlong)puVar7 + 0xc) - iVar8 | 1U - *(int *)(puVar7 + 2)) < 0) {
            FUN_18000ab60((longlong *)&local_b8,iVar8);
          }
          _Source = local_b8;
          if (uVar13 < uVar15) {
            FUN_180032c60(local_b8,(longlong)iVar8,&DAT_1800590e0,(longlong)iVar8);
          }
          else {
            memmove_s(local_b8,(longlong)iVar8,(void *)(uVar15 + (longlong)local_b8),(longlong)iVar8
                     );
          }
          if ((iVar8 < 0) || (*(int *)((longlong)_Source + -0xc) < iVar8)) {
                    /* WARNING: Subroutine does not return */
            FUN_18000b170(-0x7ff8ffa9);
          }
          *(int *)(_Source + -2) = iVar8;
          *(undefined1 *)((longlong)iVar8 + (longlong)_Source) = 0;
        }
        break;
      case 1:
        lVar10 = -1;
        pcVar14 = "M3";
        do {
          if (lVar10 == 0) break;
          lVar10 = lVar10 + -1;
          cVar3 = *pcVar14;
          pcVar14 = pcVar14 + 1;
        } while (cVar3 != '\0');
        iVar8 = ~(uint)lVar10 - 1;
        if (iVar8 == 0) {
          plVar4 = (longlong *)*puVar7;
          if (*(int *)(puVar7 + 1) != 0) {
            if (*(int *)(puVar7 + 2) < 0) {
              if (*(int *)((longlong)puVar7 + 0xc) < 0) {
                    /* WARNING: Subroutine does not return */
                FUN_18000b170(-0x7ff8ffa9);
              }
              *(undefined4 *)(puVar7 + 1) = 0;
              *(char *)_Source = '\0';
            }
            else {
              LOCK();
              piVar1 = (int *)(puVar7 + 2);
              iVar8 = *piVar1;
              *piVar1 = *piVar1 + -1;
              UNLOCK();
              if (iVar8 + -1 < 1) {
                (**(code **)(*(longlong *)*puVar7 + 8))();
              }
              lVar10 = (**(code **)(*plVar4 + 0x18))(plVar4);
              _Source = (ulonglong *)(lVar10 + 0x18);
              uVar9 = local_b0;
              local_b8 = _Source;
            }
          }
        }
        else {
          uVar13 = *(uint *)(puVar7 + 1);
          uVar15 = (longlong)&DAT_180059100 - (longlong)_Source;
          if ((int)(*(int *)((longlong)puVar7 + 0xc) - iVar8 | 1U - *(int *)(puVar7 + 2)) < 0) {
            FUN_18000ab60((longlong *)&local_b8,iVar8);
          }
          _Source = local_b8;
          if (uVar13 < uVar15) {
            FUN_180032c60(local_b8,(longlong)iVar8,&DAT_180059100,(longlong)iVar8);
          }
          else {
            memmove_s(local_b8,(longlong)iVar8,(void *)(uVar15 + (longlong)local_b8),(longlong)iVar8
                     );
          }
          if ((iVar8 < 0) || (*(int *)((longlong)_Source + -0xc) < iVar8)) {
                    /* WARNING: Subroutine does not return */
            FUN_18000b170(-0x7ff8ffa9);
          }
          *(int *)(_Source + -2) = iVar8;
          *(undefined1 *)((longlong)iVar8 + (longlong)_Source) = 0;
        }
        break;
      case 2:
        lVar10 = -1;
        pcVar14 = "M3Pro";
        do {
          if (lVar10 == 0) break;
          lVar10 = lVar10 + -1;
          cVar3 = *pcVar14;
          pcVar14 = pcVar14 + 1;
        } while (cVar3 != '\0');
        iVar8 = ~(uint)lVar10 - 1;
        if (iVar8 == 0) {
          plVar4 = (longlong *)*puVar7;
          if (*(int *)(puVar7 + 1) != 0) {
            if (*(int *)(puVar7 + 2) < 0) {
              if (*(int *)((longlong)puVar7 + 0xc) < 0) {
                    /* WARNING: Subroutine does not return */
                FUN_18000b170(-0x7ff8ffa9);
              }
              *(undefined4 *)(puVar7 + 1) = 0;
              *(char *)_Source = '\0';
            }
            else {
              LOCK();
              piVar1 = (int *)(puVar7 + 2);
              iVar8 = *piVar1;
              *piVar1 = *piVar1 + -1;
              UNLOCK();
              if (iVar8 + -1 < 1) {
                (**(code **)(*(longlong *)*puVar7 + 8))();
              }
              lVar10 = (**(code **)(*plVar4 + 0x18))(plVar4);
              _Source = (ulonglong *)(lVar10 + 0x18);
              uVar9 = local_b0;
              local_b8 = _Source;
            }
          }
        }
        else {
          uVar13 = *(uint *)(puVar7 + 1);
          uVar15 = (longlong)&DAT_180059104 - (longlong)_Source;
          if ((int)(*(int *)((longlong)puVar7 + 0xc) - iVar8 | 1U - *(int *)(puVar7 + 2)) < 0) {
            FUN_18000ab60((longlong *)&local_b8,iVar8);
          }
          _Source = local_b8;
          if (uVar13 < uVar15) {
            FUN_180032c60(local_b8,(longlong)iVar8,&DAT_180059104,(longlong)iVar8);
          }
          else {
            memmove_s(local_b8,(longlong)iVar8,(void *)(uVar15 + (longlong)local_b8),(longlong)iVar8
                     );
          }
          if ((iVar8 < 0) || (*(int *)((longlong)_Source + -0xc) < iVar8)) {
                    /* WARNING: Subroutine does not return */
            FUN_18000b170(-0x7ff8ffa9);
          }
          *(int *)(_Source + -2) = iVar8;
          *(undefined1 *)((longlong)iVar8 + (longlong)_Source) = 0;
        }
        break;
      case 3:
        lVar10 = -1;
        pcVar14 = "160Core";
        do {
          if (lVar10 == 0) break;
          lVar10 = lVar10 + -1;
          cVar3 = *pcVar14;
          pcVar14 = pcVar14 + 1;
        } while (cVar3 != '\0');
        iVar8 = ~(uint)lVar10 - 1;
        if (iVar8 == 0) {
          plVar4 = (longlong *)*puVar7;
          if (*(int *)(puVar7 + 1) != 0) {
            if (*(int *)(puVar7 + 2) < 0) {
              if (*(int *)((longlong)puVar7 + 0xc) < 0) {
                    /* WARNING: Subroutine does not return */
                FUN_18000b170(-0x7ff8ffa9);
              }
              *(undefined4 *)(puVar7 + 1) = 0;
              *(char *)_Source = '\0';
            }
            else {
              LOCK();
              piVar1 = (int *)(puVar7 + 2);
              iVar8 = *piVar1;
              *piVar1 = *piVar1 + -1;
              UNLOCK();
              if (iVar8 + -1 < 1) {
                (**(code **)(*(longlong *)*puVar7 + 8))();
              }
              lVar10 = (**(code **)(*plVar4 + 0x18))(plVar4);
              _Source = (ulonglong *)(lVar10 + 0x18);
              uVar9 = local_b0;
              local_b8 = _Source;
            }
          }
        }
        else {
          uVar13 = *(uint *)(puVar7 + 1);
          uVar15 = (longlong)&DAT_1800590f8 - (longlong)_Source;
          if ((int)(*(int *)((longlong)puVar7 + 0xc) - iVar8 | 1U - *(int *)(puVar7 + 2)) < 0) {
            FUN_18000ab60((longlong *)&local_b8,iVar8);
          }
          _Source = local_b8;
          if (uVar13 < uVar15) {
            FUN_180032c60(local_b8,(longlong)iVar8,&DAT_1800590f8,(longlong)iVar8);
          }
          else {
            memmove_s(local_b8,(longlong)iVar8,(void *)(uVar15 + (longlong)local_b8),(longlong)iVar8
                     );
          }
          if ((iVar8 < 0) || (*(int *)((longlong)_Source + -0xc) < iVar8)) {
                    /* WARNING: Subroutine does not return */
            FUN_18000b170(-0x7ff8ffa9);
          }
          *(int *)(_Source + -2) = iVar8;
          *(undefined1 *)((longlong)iVar8 + (longlong)_Source) = 0;
        }
        break;
      case 4:
        lVar10 = -1;
        pcVar14 = "M6";
        do {
          if (lVar10 == 0) break;
          lVar10 = lVar10 + -1;
          cVar3 = *pcVar14;
          pcVar14 = pcVar14 + 1;
        } while (cVar3 != '\0');
        iVar8 = ~(uint)lVar10 - 1;
        if (iVar8 == 0) {
          plVar4 = (longlong *)*puVar7;
          if (*(int *)(puVar7 + 1) != 0) {
            if (*(int *)(puVar7 + 2) < 0) {
              if (*(int *)((longlong)puVar7 + 0xc) < 0) {
                    /* WARNING: Subroutine does not return */
                FUN_18000b170(-0x7ff8ffa9);
              }
              *(undefined4 *)(puVar7 + 1) = 0;
              *(char *)_Source = '\0';
            }
            else {
              LOCK();
              piVar1 = (int *)(puVar7 + 2);
              iVar8 = *piVar1;
              *piVar1 = *piVar1 + -1;
              UNLOCK();
              if (iVar8 + -1 < 1) {
                (**(code **)(*(longlong *)*puVar7 + 8))();
              }
              lVar10 = (**(code **)(*plVar4 + 0x18))(plVar4);
              _Source = (ulonglong *)(lVar10 + 0x18);
              uVar9 = local_b0;
              local_b8 = _Source;
            }
          }
        }
        else {
          uVar13 = *(uint *)(puVar7 + 1);
          uVar15 = (longlong)&DAT_18005910c - (longlong)_Source;
          if ((int)(*(int *)((longlong)puVar7 + 0xc) - iVar8 | 1U - *(int *)(puVar7 + 2)) < 0) {
            FUN_18000ab60((longlong *)&local_b8,iVar8);
          }
          _Source = local_b8;
          if (uVar13 < uVar15) {
            FUN_180032c60(local_b8,(longlong)iVar8,&DAT_18005910c,(longlong)iVar8);
          }
          else {
            memmove_s(local_b8,(longlong)iVar8,(void *)(uVar15 + (longlong)local_b8),(longlong)iVar8
                     );
          }
          if ((iVar8 < 0) || (*(int *)((longlong)_Source + -0xc) < iVar8)) {
                    /* WARNING: Subroutine does not return */
            FUN_18000b170(-0x7ff8ffa9);
          }
          *(int *)(_Source + -2) = iVar8;
          *(undefined1 *)((longlong)iVar8 + (longlong)_Source) = 0;
        }
        break;
      case 5:
        lVar10 = -1;
        pcVar14 = "C1Pro";
        do {
          if (lVar10 == 0) break;
          lVar10 = lVar10 + -1;
          cVar3 = *pcVar14;
          pcVar14 = pcVar14 + 1;
        } while (cVar3 != '\0');
        iVar8 = ~(uint)lVar10 - 1;
        if (iVar8 == 0) {
          plVar4 = (longlong *)*puVar7;
          if (*(int *)(puVar7 + 1) != 0) {
            if (*(int *)(puVar7 + 2) < 0) {
              if (*(int *)((longlong)puVar7 + 0xc) < 0) {
                    /* WARNING: Subroutine does not return */
                FUN_18000b170(-0x7ff8ffa9);
              }
              *(undefined4 *)(puVar7 + 1) = 0;
              *(char *)_Source = '\0';
            }
            else {
              LOCK();
              piVar1 = (int *)(puVar7 + 2);
              iVar8 = *piVar1;
              *piVar1 = *piVar1 + -1;
              UNLOCK();
              if (iVar8 + -1 < 1) {
                (**(code **)(*(longlong *)*puVar7 + 8))();
              }
              lVar10 = (**(code **)(*plVar4 + 0x18))(plVar4);
              _Source = (ulonglong *)(lVar10 + 0x18);
              uVar9 = local_b0;
              local_b8 = _Source;
            }
          }
        }
        else {
          uVar13 = *(uint *)(puVar7 + 1);
          uVar15 = (longlong)&DAT_1800590e4 - (longlong)_Source;
          if ((int)(*(int *)((longlong)puVar7 + 0xc) - iVar8 | 1U - *(int *)(puVar7 + 2)) < 0) {
            FUN_18000ab60((longlong *)&local_b8,iVar8);
          }
          _Source = local_b8;
          if (uVar13 < uVar15) {
            FUN_180032c60(local_b8,(longlong)iVar8,&DAT_1800590e4,(longlong)iVar8);
          }
          else {
            memmove_s(local_b8,(longlong)iVar8,(void *)(uVar15 + (longlong)local_b8),(longlong)iVar8
                     );
          }
          if ((iVar8 < 0) || (*(int *)((longlong)_Source + -0xc) < iVar8)) {
                    /* WARNING: Subroutine does not return */
            FUN_18000b170(-0x7ff8ffa9);
          }
          *(int *)(_Source + -2) = iVar8;
          *(undefined1 *)((longlong)iVar8 + (longlong)_Source) = 0;
        }
        break;
      case 6:
        lVar10 = -1;
        pcVar14 = "C1ProLt";
        do {
          if (lVar10 == 0) break;
          lVar10 = lVar10 + -1;
          cVar3 = *pcVar14;
          pcVar14 = pcVar14 + 1;
        } while (cVar3 != '\0');
        iVar8 = ~(uint)lVar10 - 1;
        if (iVar8 == 0) {
          plVar4 = (longlong *)*puVar7;
          if (*(int *)(puVar7 + 1) != 0) {
            if (*(int *)(puVar7 + 2) < 0) {
              if (*(int *)((longlong)puVar7 + 0xc) < 0) {
                    /* WARNING: Subroutine does not return */
                FUN_18000b170(-0x7ff8ffa9);
              }
              *(undefined4 *)(puVar7 + 1) = 0;
              *(char *)_Source = '\0';
            }
            else {
              LOCK();
              piVar1 = (int *)(puVar7 + 2);
              iVar8 = *piVar1;
              *piVar1 = *piVar1 + -1;
              UNLOCK();
              if (iVar8 + -1 < 1) {
                (**(code **)(*(longlong *)*puVar7 + 8))();
              }
              lVar10 = (**(code **)(*plVar4 + 0x18))(plVar4);
              _Source = (ulonglong *)(lVar10 + 0x18);
              uVar9 = local_b0;
              local_b8 = _Source;
            }
          }
        }
        else {
          uVar13 = *(uint *)(puVar7 + 1);
          uVar15 = (longlong)&DAT_1800590f0 - (longlong)_Source;
          if ((int)(*(int *)((longlong)puVar7 + 0xc) - iVar8 | 1U - *(int *)(puVar7 + 2)) < 0) {
            FUN_18000ab60((longlong *)&local_b8,iVar8);
          }
          _Source = local_b8;
          if (uVar13 < uVar15) {
            FUN_180032c60(local_b8,(longlong)iVar8,&DAT_1800590f0,(longlong)iVar8);
          }
          else {
            memmove_s(local_b8,(longlong)iVar8,(void *)(uVar15 + (longlong)local_b8),(longlong)iVar8
                     );
          }
          if ((iVar8 < 0) || (*(int *)((longlong)_Source + -0xc) < iVar8)) {
                    /* WARNING: Subroutine does not return */
            FUN_18000b170(-0x7ff8ffa9);
          }
          *(int *)(_Source + -2) = iVar8;
          *(undefined1 *)((longlong)iVar8 + (longlong)_Source) = 0;
        }
        break;
      default:
        lVar10 = -1;
        pcVar14 = "Mx";
        do {
          if (lVar10 == 0) break;
          lVar10 = lVar10 + -1;
          cVar3 = *pcVar14;
          pcVar14 = pcVar14 + 1;
        } while (cVar3 != '\0');
        iVar8 = ~(uint)lVar10 - 1;
        if (iVar8 == 0) {
          plVar4 = (longlong *)*puVar7;
          if (*(int *)(puVar7 + 1) != 0) {
            if (*(int *)(puVar7 + 2) < 0) {
              if (*(int *)((longlong)puVar7 + 0xc) < 0) {
                    /* WARNING: Subroutine does not return */
                FUN_18000b170(-0x7ff8ffa9);
              }
              *(undefined4 *)(puVar7 + 1) = 0;
              *(char *)_Source = '\0';
            }
            else {
              LOCK();
              piVar1 = (int *)(puVar7 + 2);
              iVar8 = *piVar1;
              *piVar1 = *piVar1 + -1;
              UNLOCK();
              if (iVar8 + -1 < 1) {
                (**(code **)(*(longlong *)*puVar7 + 8))();
              }
              lVar10 = (**(code **)(*plVar4 + 0x18))(plVar4);
              _Source = (ulonglong *)(lVar10 + 0x18);
              uVar9 = local_b0;
              local_b8 = _Source;
            }
          }
        }
        else {
          uVar13 = *(uint *)(puVar7 + 1);
          uVar15 = (longlong)&DAT_180059110 - (longlong)_Source;
          if ((int)(*(int *)((longlong)puVar7 + 0xc) - iVar8 | 1U - *(int *)(puVar7 + 2)) < 0) {
            FUN_18000ab60((longlong *)&local_b8,iVar8);
          }
          _Source = local_b8;
          if (uVar13 < uVar15) {
            FUN_180032c60(local_b8,(longlong)iVar8,&DAT_180059110,(longlong)iVar8);
          }
          else {
            memmove_s(local_b8,(longlong)iVar8,(void *)(uVar15 + (longlong)local_b8),(longlong)iVar8
                     );
          }
          if ((iVar8 < 0) || (*(int *)((longlong)_Source + -0xc) < iVar8)) {
                    /* WARNING: Subroutine does not return */
            FUN_18000b170(-0x7ff8ffa9);
          }
          *(int *)(_Source + -2) = iVar8;
          *(undefined1 *)((longlong)iVar8 + (longlong)_Source) = 0;
        }
      }
      strncpy(&DAT_1800737e8 + lVar12,(char *)_Source,8);
      (&DAT_1800737ef)[lVar12] = 0;
      FUN_180032bb0(&DAT_1800737c8 + lVar12,(byte *)"%s-%u",_Source,(ulonglong)uVar9);
      (&DAT_1800737e7)[lVar12] = 0;
      (&DAT_1800737b8)[uVar11 * 0x12a] = local_a0;
      *(uint *)(&DAT_1800737bc + lVar12) = local_9c;
      *(uint *)(&DAT_1800737f8 + lVar12) = local_a0;
      *(uint *)(&DAT_1800737fc + lVar12) = local_9c;
      if ((local_a0 < 0x51) && (local_9c < 0x51)) {
        *(uint *)(&DAT_1800737f8 + lVar12) = local_a0 * 4;
        *(uint *)(&DAT_1800737fc + lVar12) = local_9c * 4;
      }
      if ((local_a0 < 0xa1) && (local_9c < 0xa1)) {
        *(int *)(&DAT_1800737f8 + lVar12) = *(int *)(&DAT_1800737f8 + lVar12) * 2;
        *(int *)(&DAT_1800737fc + lVar12) = *(int *)(&DAT_1800737fc + lVar12) * 2;
      }
      *(undefined4 *)(&DAT_1800737f0 + lVar12) = local_98;
      *(undefined4 *)(&DAT_1800737f4 + lVar12) = local_98;
      *(undefined4 *)(&DAT_180073780 + lVar12) = 2;
      FUN_18000d5f0((&DAT_180073750)[uVar11 * 0x95],2);
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 100) = 1;
      lVar12 = (&DAT_180073750)[uVar11 * 0x95];
      EnterCriticalSection((LPCRITICAL_SECTION)(lVar12 + 0x238));
      memcpy(&DAT_180099000,&DAT_18005cde0,0xa1c);
      lVar10 = 0;
      do {
        uVar9 = *(int *)((longlong)&DAT_180099004 + lVar10) -
                *(int *)((longlong)&DAT_180099000 + lVar10);
        *(uint *)((longlong)&DAT_180099a20 + lVar10) = ((uVar9 >> 1) + 0x1000000) / uVar9;
        uVar9 = *(int *)((longlong)&DAT_180099008 + lVar10) -
                *(int *)((longlong)&DAT_180099004 + lVar10);
        *(uint *)((longlong)&DAT_180099a24 + lVar10) = ((uVar9 >> 1) + 0x1000000) / uVar9;
        lVar10 = lVar10 + 8;
      } while (lVar10 < 0xa18);
      DAT_180073748 = (undefined4)(0x7fffffff / (longlong)DAT_18009a434);
      *(undefined4 *)(lVar12 + 0x68) = 7;
      LeaveCriticalSection((LPCRITICAL_SECTION)(lVar12 + 0x238));
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0x50) = 200;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 8) = 0;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0x10) = 0;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0x14) = 20000;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0x18) = 100000;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0x1c) = 0;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0x20) = 0xff;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0x24) = 5;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0x70) = 1;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0x8c) = 1;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0x6c) = 1;
      if (local_44 == _DAT_180057598) {
        *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xa4) = 0;
        *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xa8) = 0;
        *(int *)((&DAT_180073750)[lVar16 * 0x95] + 0xac) = local_40 * 0x32;
        *(int *)((&DAT_180073750)[lVar16 * 0x95] + 0xb0) = local_3f * 0x32;
        *(int *)((&DAT_180073750)[lVar16 * 0x95] + 0xb4) = local_3e * 0x32;
        *(int *)((&DAT_180073750)[lVar16 * 0x95] + 0xb8) = local_3d * 0x32;
        *(int *)((&DAT_180073750)[lVar16 * 0x95] + 0xbc) = local_3c * 0x32;
        *(int *)((&DAT_180073750)[lVar16 * 0x95] + 0xc0) = local_3b * 0x32;
        *(int *)((&DAT_180073750)[lVar16 * 0x95] + 0xc4) = local_3a * 0x32;
        *(int *)((&DAT_180073750)[lVar16 * 0x95] + 200) = local_39 * 0x32;
      }
      else {
        *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xa4) = local_48;
        *(float *)((&DAT_180073750)[uVar11 * 0x95] + 0xa8) = local_44;
        lVar12 = (&DAT_180073750)[uVar11 * 0x95];
        *(undefined4 *)(lVar12 + 0xac) = 0;
        *(undefined4 *)(lVar12 + 0xb0) = 0;
        *(undefined4 *)(lVar12 + 0xb4) = 0;
        *(undefined4 *)(lVar12 + 0xb8) = 0;
        *(undefined4 *)(lVar12 + 0xbc) = 0;
        *(undefined4 *)(lVar12 + 0xc0) = 0;
        *(undefined4 *)(lVar12 + 0xc4) = 0;
        *(undefined4 *)(lVar12 + 200) = 0;
      }
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xcc) = 2;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xd0) = 0x41200000;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xd4) = 0x3f800000;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xd8) = 0x41a00000;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xdc) = 0x3ecccccd;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xe0) = 0x41a00000;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xe4) = 0;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xe8) = 0;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xec) = 0;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xf0) = 0;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xf4) = 0x3f7fa57f;
      *(undefined4 *)((&DAT_180073750)[uVar11 * 0x95] + 0xf8) = 0x3f800000;
      LOCK();
      puVar2 = _Source + -1;
      uVar11 = *puVar2;
      *(int *)puVar2 = (int)*puVar2 + -1;
      UNLOCK();
      if ((int)uVar11 + -1 < 1) {
        (**(code **)(*(longlong *)_Source[-3] + 8))();
      }
      uVar5 = 1;
    }
  }
  return uVar5;
}


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

### ADDR 180009b50 FUNC 180009b50 (875 bytes) name=FUN_180009b50

undefined8 FUN_180009b50(uint param_1,uint *param_2,longlong param_3,int param_4)

{
  LPCWSTR pWVar1;
  uint uVar2;
  uint uVar3;
  int iVar4;
  LPVOID pvVar5;
  ulonglong uVar6;
  undefined8 uVar7;
  longlong lVar8;
  ulonglong uVar9;
  LPCWSTR local_res10;
  uint local_50;
  uint local_4c;
  uint local_48;
  uint local_44;
  uint local_40;
  uint local_3c;
  undefined4 local_38;
  undefined4 local_34;
  undefined4 local_30;
  undefined4 local_2c;
  
  uVar9 = (ulonglong)param_1;
  if (((param_2 != (uint *)0x0) && (param_3 != 0)) && (param_4 == 2)) {
    lVar8 = uVar9 * 0x4a8;
    uVar2 = *param_2;
    if ((((uVar2 == (&DAT_1800737b8)[uVar9 * 0x12a]) &&
         (uVar3 = param_2[1], uVar3 == *(uint *)(&DAT_1800737bc + lVar8))) &&
        (((uVar2 & 3) == 0 && (((param_2[2] & 3) == 0 && ((param_2[4] & 3) == 0)))))) &&
       ((uVar2 <= param_2[2] &&
        ((((uVar3 <= param_2[3] && (uVar3 != 0)) && (param_2[3] != 0)) && (param_2[5] != 0)))))) {
      if (*(int *)(&DAT_180073778 + lVar8) != 0) {
        SetLastError(0xe4ae000a);
        return 0;
      }
      if (*(int *)((&DAT_180073758)[uVar9 * 0x95] + 0x14) == 0) {
        SetLastError(0xe4ae0005);
        return 0;
      }
      *(undefined4 *)(&DAT_18007377c + lVar8) = 2;
      *(undefined4 *)(&DAT_180073bf4 + lVar8) = 0;
      *(undefined4 *)(&DAT_180073bf0 + lVar8) = 0;
      *(uint *)(&DAT_180073798 + lVar8) = *param_2;
      *(uint *)(&DAT_18007379c + lVar8) = param_2[1];
      *(uint *)(&DAT_1800737a0 + lVar8) = param_2[2];
      *(uint *)(&DAT_1800737a4 + lVar8) = param_2[3];
      *(uint *)(&DAT_1800737a8 + lVar8) = param_2[4];
      *(uint *)(&DAT_1800737ac + lVar8) = param_2[5];
      uVar2 = *param_2 * param_2[1] * 2;
      if (*(LPVOID *)(&DAT_180073788 + lVar8) != (LPVOID)0x0) {
        thunk_FUN_180034a70(*(LPVOID *)(&DAT_180073788 + lVar8));
        *(undefined8 *)(&DAT_180073788 + lVar8) = 0;
      }
      pvVar5 = thunk_FUN_18001eb74((ulonglong)uVar2 + 0x98);
      *(LPVOID *)(&DAT_180073788 + lVar8) = pvVar5;
      if (pvVar5 == (LPVOID)0x0) {
        SetLastError(0xe4ae0002);
        return 0;
      }
      local_50 = *param_2;
      local_4c = param_2[1];
      local_48 = param_2[2];
      local_44 = param_2[3];
      local_40 = param_2[4];
      local_3c = param_2[5];
      local_38 = 4;
      local_34 = 1;
      local_30 = 1;
      local_2c = 5;
      uVar6 = FUN_18001e4c0((&DAT_180073758)[uVar9 * 0x95]);
      if ((int)uVar6 == 0) {
        SetLastError(0xe4ae0008);
        return 0;
      }
      iVar4 = FUN_18000bce0((&DAT_180073750)[uVar9 * 0x95],&local_50);
      if (iVar4 == 0) {
        if (*(LPVOID *)(&DAT_180073788 + lVar8) != (LPVOID)0x0) {
          thunk_FUN_180034a70(*(LPVOID *)(&DAT_180073788 + lVar8));
          *(undefined8 *)(&DAT_180073788 + lVar8) = 0;
        }
        SetLastError(0xe4ae0003);
        return 0;
      }
      FUN_18001e3c0((&DAT_180073758)[uVar9 * 0x95],(longlong *)&local_res10);
      iVar4 = FUN_18000f130((&DAT_180073750)[uVar9 * 0x95],local_res10);
      if (iVar4 == 0) {
        SetLastError(0xe4ae0009);
        LOCK();
        pWVar1 = local_res10 + -4;
        iVar4 = *(int *)pWVar1;
        *(int *)pWVar1 = *(int *)pWVar1 + -1;
        UNLOCK();
        if (iVar4 + -1 < 1) {
          (**(code **)(**(longlong **)(local_res10 + -0xc) + 8))();
        }
        return 0;
      }
      FUN_180002f50(param_1);
      if (*(int *)((longlong)(&DAT_180073758)[uVar9 * 0x95] + 0x14) == 0) {
        SetLastError(0xe4ae0005);
      }
      else {
        uVar7 = FUN_18001d2d0((void *)(&DAT_180073758)[uVar9 * 0x95],uVar2,
                              *(longlong *)(&DAT_180073788 + lVar8));
        if ((int)uVar7 != 0) {
          *(longlong *)(&DAT_180073790 + lVar8) = param_3;
          *(undefined4 *)(&DAT_180073bec + lVar8) = 0xffffffff;
          *(undefined4 *)(&DAT_180073778 + lVar8) = 1;
          LOCK();
          pWVar1 = local_res10 + -4;
          iVar4 = *(int *)pWVar1;
          *(int *)pWVar1 = *(int *)pWVar1 + -1;
          UNLOCK();
          if (iVar4 + -1 < 1) {
            (**(code **)(**(longlong **)(local_res10 + -0xc) + 8))();
          }
          return 1;
        }
      }
      if (*(LPVOID *)(&DAT_180073788 + lVar8) != (LPVOID)0x0) {
        thunk_FUN_180034a70(*(LPVOID *)(&DAT_180073788 + lVar8));
        *(undefined8 *)(&DAT_180073788 + lVar8) = 0;
      }
      SetLastError(0xe4ae0008);
      LOCK();
      pWVar1 = local_res10 + -4;
      iVar4 = *(int *)pWVar1;
      *(int *)pWVar1 = *(int *)pWVar1 + -1;
      UNLOCK();
      if (iVar4 + -1 < 1) {
        (**(code **)(**(longlong **)(local_res10 + -0xc) + 8))();
      }
      return 0;
    }
  }
  SetLastError(0xe4ae0001);
  return 0;
}


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

### ADDR 18000a410 FUNC 18000a410 (496 bytes) name=FUN_18000a410

void FUN_18000a410(uint param_1,undefined8 param_2,longlong param_3)

{
  undefined4 uVar1;
  longlong lVar2;
  bool bVar3;
  int iVar4;
  undefined8 uVar5;
  undefined7 extraout_var;
  uint uVar6;
  ulonglong uVar7;
  longlong lVar8;
  byte *pbVar9;
  
  uVar1 = *(undefined4 *)(param_3 + 8);
  uVar7 = (ulonglong)param_1;
  lVar8 = uVar7 * 0x4a8;
  *(undefined4 *)(&DAT_180073800 + lVar8) = uVar1;
  *(undefined4 *)(&DAT_180073804 + lVar8) = *(undefined4 *)(param_3 + 0xc);
  *(undefined4 *)(&DAT_180073808 + lVar8) = *(undefined4 *)(param_3 + 0x10);
  *(undefined4 *)(&DAT_18007380c + lVar8) = *(undefined4 *)(param_3 + 0x14);
  *(undefined8 *)(&DAT_180073810 + lVar8) = *(undefined8 *)(param_3 + 0x18);
  *(undefined8 *)(&DAT_180073818 + lVar8) = *(undefined8 *)(param_3 + 0x28);
  *(undefined8 *)(&DAT_180073820 + lVar8) = *(undefined8 *)(param_3 + 0x30);
  *(undefined4 *)(&DAT_180073828 + lVar8) = *(undefined4 *)(param_3 + 0x38);
  *(undefined4 *)((&DAT_180073750)[uVar7 * 0x95] + 0x60) = uVar1;
  *(undefined4 *)((&DAT_180073750)[uVar7 * 0x95] + 0x5c) = *(undefined4 *)(&DAT_180073804 + lVar8);
  if (*(int *)(&DAT_180073ba0 + lVar8) < *(int *)(param_3 + 0x24)) {
    EnterCriticalSection((LPCRITICAL_SECTION)((&DAT_180073750)[uVar7 * 0x95] + 0x238));
    *(undefined4 *)((&DAT_180073750)[uVar7 * 0x95] + 0x58) =
         *(undefined4 *)((&DAT_180073750)[uVar7 * 0x95] + 0x60);
    *(undefined4 *)((&DAT_180073750)[uVar7 * 0x95] + 0x54) =
         *(undefined4 *)((&DAT_180073750)[uVar7 * 0x95] + 0x5c);
    LeaveCriticalSection((LPCRITICAL_SECTION)((&DAT_180073750)[uVar7 * 0x95] + 0x238));
  }
  lVar2 = (&DAT_180073750)[uVar7 * 0x95];
  pbVar9 = (byte *)0x0;
  *(undefined4 *)(&DAT_180073ba0 + lVar8) = *(undefined4 *)(param_3 + 0x24);
  uVar5 = FUN_18000ca30(lVar2,param_2,1,1,0);
  if ((int)uVar5 != 0) {
    if (*(int *)((&DAT_180073760)[uVar7 * 0x95] + 0x44) != 0) {
      lVar2 = (&DAT_180073750)[uVar7 * 0x95];
      if ((*(int *)(lVar2 + 0x228) != 0) && (*(int *)(lVar2 + 0x234) != 0)) {
        if (*(int *)(lVar2 + 0x4203c) == 0) {
          FUN_180010e80(lVar2);
        }
        pbVar9 = *(byte **)(lVar2 + 0x2a0);
      }
      lVar2 = (&DAT_180073750)[uVar7 * 0x95];
      if ((pbVar9 != (byte *)0x0) && (lVar2 + 0x6c8 != 0)) {
        iVar4 = (uint)*(ushort *)(lVar2 + 0x6d6) * *(int *)(lVar2 + 0x6d0) * *(int *)(lVar2 + 0x6cc)
        ;
        iVar4 = iVar4 + (iVar4 >> 0x1f & 7U);
        uVar6 = iVar4 >> 0x1f;
        bVar3 = FUN_180001cd0((&DAT_180073760)[uVar7 * 0x95],pbVar9,(iVar4 >> 3 ^ uVar6) - uVar6,
                              lVar2 + 0x6c8);
        if ((int)CONCAT71(extraout_var,bVar3) == 0) {
          FUN_180001c50((&DAT_180073760)[uVar7 * 0x95]);
        }
      }
    }
    if (*(code **)(&DAT_180073790 + lVar8) != (code *)0x0) {
      (**(code **)(&DAT_180073790 + lVar8))
                (param_1,*(undefined4 *)(param_3 + 8),*(undefined4 *)(param_3 + 0x24),0,2,
                 *(undefined8 *)(&DAT_180073770 + lVar8));
    }
  }
  return;
}


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

### ADDR 1800110a0 FUNC 1800110a0 (64 bytes) name=FUN_1800110a0

undefined8 FUN_1800110a0(longlong param_1)

{
  if ((*(int *)(param_1 + 0x228) != 0) && (*(int *)(param_1 + 0x234) != 0)) {
    if (*(int *)(param_1 + 0x4203c) == 0) {
      FUN_180010e80(param_1);
    }
    return *(undefined8 *)(param_1 + 0x2a0);
  }
  return 0;
}


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

### ADDR 18001b1b0 FUNC 18001b1b0 (190 bytes) name=FUN_18001b1b0

undefined8
FUN_18001b1b0(longlong param_1,longlong param_2,undefined8 param_3,longlong param_4,int param_5)

{
  undefined8 uVar1;
  undefined8 local_18 [2];
  
  FUN_180001470(param_1 + 8);
  if (*(int *)(param_1 + 0x44) == 0) {
    (**(code **)(*(longlong *)(param_1 + 8) + 0x28))(param_1 + 8);
    uVar1 = 0;
  }
  else {
    FUN_18001ef2c(local_18);
    if (param_2 != 0) {
      (**(code **)(*(longlong *)(param_1 + 0x50) + 0x70))((longlong *)(param_1 + 0x50),param_2,0x40)
      ;
    }
    if ((param_4 != 0) && (param_5 != 0)) {
      (**(code **)(*(longlong *)(param_1 + 0x50) + 0x70))((longlong *)(param_1 + 0x50),param_4);
    }
    FUN_18001ef94();
    *(int *)(param_1 + 0x40) = *(int *)(param_1 + 0x40) + 1;
    (**(code **)(*(longlong *)(param_1 + 8) + 0x28))(param_1 + 8);
    uVar1 = 1;
  }
  return uVar1;
}


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

### ADDR 18000d2a0 FUNC 18000d2a0 (839 bytes) name=FUN_18000d2a0

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

void FUN_18000d2a0(longlong param_1)

{
  int iVar1;
  int iVar2;
  uint uVar3;
  float fVar4;
  float fVar5;
  
  memcpy((void *)(param_1 + 0x44c98),(void *)(param_1 + 0x41ff8),0x2ca0);
  iVar1 = FUN_180016290(param_1,(uint)*(ushort *)(param_1 + 0x42018),
                        (*(uint *)(param_1 + 0x47938) >> 1) + (*(uint *)(param_1 + 0x41fc0) >> 1),0)
  ;
  *(int *)(param_1 + 0x44cb8) = iVar1;
  iVar1 = FUN_180016290(param_1,(uint)*(ushort *)(param_1 + 0x4202c),
                        (*(uint *)(param_1 + 0x47938) >> 1) + (*(uint *)(param_1 + 0x41fc0) >> 1),0)
  ;
  *(int *)(param_1 + 0x44ccc) = iVar1;
  iVar1 = FUN_180016290(param_1,(uint)*(ushort *)(param_1 + 0x42010),*(uint *)(param_1 + 0x44cc0),1)
  ;
  *(int *)(param_1 + 0x44cb0) = iVar1;
  iVar1 = FUN_180016290(param_1,(uint)*(ushort *)(param_1 + 0x42030),
                        (*(uint *)(param_1 + 0x47938) >> 1) + (*(uint *)(param_1 + 0x41fc0) >> 1),0)
  ;
  *(int *)(param_1 + 0x44cd0) = iVar1;
  iVar1 = FUN_180016290(param_1,(uint)*(ushort *)(param_1 + 0x42014),*(uint *)(param_1 + 0x44cc4),1)
  ;
  *(int *)(param_1 + 0x44cb4) = iVar1;
  if (*(int *)(param_1 + 0xcc) == 2) {
    iVar1 = *(int *)(param_1 + 0x44cb8);
  }
  else {
    if (*(int *)(param_1 + 0xcc) != 3) goto LAB_18000d3c5;
    iVar1 = *(int *)(param_1 + 0x60);
  }
  *(float *)(param_1 + 0xd8) = (float)iVar1 * _DAT_18005e9f0;
LAB_18000d3c5:
  iVar1 = *(int *)(param_1 + 0x47950);
  if (iVar1 == 0) {
    iVar2 = (uint)*(ushort *)(param_1 + 0x4201c) <<
            ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
  }
  else {
    iVar2 = FUN_180015a40(param_1,*(int *)(param_1 + 0x44cb8),
                          (uint)*(ushort *)(param_1 + 0x4201c) <<
                          (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f));
  }
  *(int *)(param_1 + 0x44cbc) = iVar2;
  uVar3 = (uint)(longlong)(*(float *)(param_1 + 0x42034) * _DAT_18005e9ec);
  if (iVar1 == 0) {
    uVar3 = (uVar3 & 0xffff) << ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
  }
  else {
    uVar3 = FUN_180015a40(param_1,*(int *)(param_1 + 0x44cb8),
                          (uVar3 & 0xffff) << (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f)
                         );
  }
  fVar5 = DAT_18005e9e8;
  fVar4 = *(float *)(param_1 + 0x44c8c) * DAT_18005e9e8;
  *(float *)(param_1 + 0x44cd4) = (float)uVar3 * DAT_18005e9e4;
  uVar3 = (uint)(longlong)fVar4;
  if (iVar1 == 0) {
    uVar3 = (uVar3 & 0xffff) << ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
  }
  else {
    uVar3 = FUN_180015a40(param_1,*(int *)(param_1 + 0x44cb8),
                          (uVar3 & 0xffff) << (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f)
                         );
  }
  fVar4 = DAT_18005e9e0;
  *(float *)(param_1 + 0x4792c) = (float)uVar3 * DAT_18005e9e0;
  uVar3 = (uint)(longlong)(*(float *)(param_1 + 0x44c90) * fVar5);
  if (iVar1 == 0) {
    uVar3 = (uVar3 & 0xffff) << ((byte)*(undefined4 *)(param_1 + 0x4794c) & 0x1f);
  }
  else {
    uVar3 = FUN_180015a40(param_1,*(int *)(param_1 + 0x44cb8),
                          (uVar3 & 0xffff) << (7U - (char)*(undefined4 *)(param_1 + 0x47954) & 0x1f)
                         );
  }
  *(float *)(param_1 + 0x47930) = (float)uVar3 * fVar4;
  if (*(int *)(param_1 + 0x78) != 0) {
    iVar1 = FUN_180015b90(param_1,*(int *)(param_1 + 0x44cb8),*(float *)(param_1 + 0xd4));
    *(int *)(param_1 + 0x44cb8) = iVar1;
    iVar1 = FUN_180015b90(param_1,*(int *)(param_1 + 0x44cb4),*(float *)(param_1 + 0xd4));
    *(int *)(param_1 + 0x44cb4) = iVar1;
    iVar1 = FUN_180015b90(param_1,*(int *)(param_1 + 0x44cb0),*(float *)(param_1 + 0xd4));
    *(int *)(param_1 + 0x44cb0) = iVar1;
  }
  iVar1 = *(int *)(param_1 + 0x44cb4);
  if (*(int *)(param_1 + 0x44cb0) < iVar1) {
    *(int *)(param_1 + 0x44cb0) = iVar1;
  }
  if (*(int *)(param_1 + 0x44cb0) < *(int *)(param_1 + 0x44cb8)) {
    *(int *)(param_1 + 0x44cb8) = *(int *)(param_1 + 0x44cb0);
  }
  if (*(int *)(param_1 + 0x44cb8) < iVar1) {
    *(int *)(param_1 + 0x44cb8) = iVar1;
  }
  return;
}


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

### ADDR 180001cd0 FUNC 180001cd0 (329 bytes) name=FUN_180001cd0

bool FUN_180001cd0(longlong param_1,byte *param_2,int param_3,longlong param_4)

{
  byte *pbVar1;
  uint uVar2;
  byte *pbVar3;
  ulonglong uVar4;
  uint uVar5;
  int iVar6;
  byte *pbVar7;
  bool bVar8;
  
  *(int *)(param_1 + 100) = *(int *)(param_1 + 100) + 1;
  if (*(uint *)(param_1 + 100) < *(uint *)(param_1 + 0x60)) {
    return true;
  }
  *(undefined4 *)(param_1 + 100) = 0;
  FUN_180001470(param_1 + 8);
  if (*(int *)(param_1 + 0x44) == 0) {
    (**(code **)(*(longlong *)(param_1 + 8) + 0x28))(param_1 + 8);
    bVar8 = false;
  }
  else {
    pbVar3 = param_2;
    pbVar7 = (byte *)0x0;
    if (*(short *)(param_4 + 0xe) == 8) {
      param_3 = param_3 * 3;
      pbVar3 = thunk_FUN_18001eb74((longlong)param_3);
      uVar2 = *(int *)(param_4 + 8) * *(int *)(param_4 + 4);
      uVar5 = (int)uVar2 >> 0x1f;
      pbVar1 = pbVar3;
      for (iVar6 = (uVar2 ^ uVar5) - uVar5; pbVar7 = pbVar3, iVar6 != 0; iVar6 = iVar6 + -1) {
        uVar4 = (ulonglong)*param_2;
        param_2 = param_2 + 1;
        *pbVar1 = *(byte *)(param_4 + 0x28 + uVar4 * 4);
        pbVar1[1] = *(byte *)(param_4 + 0x29 + uVar4 * 4);
        pbVar1[2] = *(byte *)(param_4 + 0x2a + uVar4 * 4);
        pbVar1 = pbVar1 + 3;
      }
    }
    iVar6 = 1;
    if (*(longlong *)(param_1 + 0x50) != 0) {
      iVar6 = AVIStreamWrite(*(longlong *)(param_1 + 0x50),*(undefined4 *)(param_1 + 0x40),1,pbVar3,
                             param_3,0x10,0,0);
      *(int *)(param_1 + 0x40) = *(int *)(param_1 + 0x40) + 1;
    }
    if (pbVar7 != (byte *)0x0) {
      thunk_FUN_180034a70(pbVar7);
    }
    (**(code **)(*(longlong *)(param_1 + 8) + 0x28))(param_1 + 8);
    bVar8 = iVar6 == 0;
  }
  return bVar8;
}


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

### ADDR 180001c50 FUNC 180001c50 (121 bytes) name=FUN_180001c50

void FUN_180001c50(longlong param_1)

{
  FUN_180001470(param_1 + 8);
  *(undefined4 *)(param_1 + 0x40) = 0;
  *(undefined4 *)(param_1 + 0x44) = 0;
  if (*(longlong *)(param_1 + 0x50) != 0) {
    AVIStreamRelease();
    *(undefined8 *)(param_1 + 0x50) = 0;
  }
  if (*(longlong *)(param_1 + 0x48) != 0) {
    AVIStreamRelease();
    *(undefined8 *)(param_1 + 0x48) = 0;
  }
  if (*(longlong *)(param_1 + 0x58) != 0) {
    AVIFileRelease();
    *(undefined8 *)(param_1 + 0x58) = 0;
  }
  AVIFileExit();
                    /* WARNING: Could not recover jumptable at 0x000180001cc5. Too many branches */
                    /* WARNING: Treating indirect jump as call */
  (**(code **)(*(longlong *)(param_1 + 8) + 0x28))(param_1 + 8);
  return;
}


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

### ADDR 18001c670 FUNC 18001c670 (398 bytes) name=FUN_18001c670

undefined8 FUN_18001c670(longlong param_1,uint *param_2,uint param_3)

{
  int *piVar1;
  uint uVar2;
  int iVar3;
  undefined **ppuVar4;
  undefined4 uVar5;
  ulonglong uVar6;
  undefined8 uVar7;
  longlong local_res8;
  longlong local_res20;
  uint local_118;
  undefined8 local_114 [31];
  
  uVar5 = 2000;
  uVar6 = (ulonglong)param_3;
  uVar2 = usb_bulk_write(*(undefined8 *)(param_1 + 0x38),3,param_2,uVar6,2000);
  if (uVar2 == param_3) {
    if (*param_2 == 0x6bb6b671) {
      uVar5 = 120000;
    }
    uVar7 = 0x100;
    iVar3 = usb_bulk_read(*(undefined8 *)(param_1 + 0x38),0x82,&local_118,0x100,uVar5);
    if (iVar3 < 4) {
      ppuVar4 = FUN_18001fcc0();
      if (ppuVar4 == (undefined **)0x0) {
                    /* WARNING: Subroutine does not return */
        FUN_18000b170(-0x7fffbffb);
      }
      local_res20 = (**(code **)(*ppuVar4 + 0x18))(ppuVar4);
      local_res20 = local_res20 + 0x18;
      FUN_18001ad00(&local_res20,L"cmd=0X%X, ack time out.",(ulonglong)*param_2,uVar7);
      LOCK();
      piVar1 = (int *)(local_res20 + -8);
      iVar3 = *piVar1;
      *piVar1 = *piVar1 + -1;
      UNLOCK();
      if (iVar3 + -1 < 1) {
        (**(code **)(**(longlong **)(local_res20 + -0x18) + 8))();
      }
      uVar7 = 0;
    }
    else {
      FUN_18001cf20(param_1,local_118,local_114,(ulonglong)(iVar3 - 4));
      uVar7 = 1;
    }
  }
  else {
    ppuVar4 = FUN_18001fcc0();
    if (ppuVar4 == (undefined **)0x0) {
                    /* WARNING: Subroutine does not return */
      FUN_18000b170(-0x7fffbffb);
    }
    local_res8 = (**(code **)(*ppuVar4 + 0x18))(ppuVar4);
    local_res8 = local_res8 + 0x18;
    FUN_18001ad00(&local_res8,L"usb_bulk_write() fail, cmd=0X%X.",(ulonglong)*param_2,uVar6);
    LOCK();
    piVar1 = (int *)(local_res8 + -8);
    iVar3 = *piVar1;
    *piVar1 = *piVar1 + -1;
    UNLOCK();
    if (iVar3 + -1 < 1) {
      (**(code **)(**(longlong **)(local_res8 + -0x18) + 8))();
    }
    uVar7 = 0;
  }
  return uVar7;
}


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

### ADDR 180019b30 FUNC 180019b30 (816 bytes) name=FUN_180019b30

void FUN_180019b30(longlong param_1)

{
  byte bVar1;
  byte bVar2;
  int iVar3;
  ulonglong uVar4;
  undefined1 uVar5;
  int iVar6;
  uint uVar7;
  undefined1 *puVar8;
  undefined1 *_Dst;
  uint uVar9;
  uint uVar10;
  uint uVar11;
  void *_Src;
  byte *pbVar12;
  byte *pbVar13;
  byte *pbVar14;
  uint uVar15;
  byte *pbVar16;
  uint local_res8;
  
  _Src = *(void **)(param_1 + 0x2a0);
  local_res8 = 0;
  uVar9 = 0;
  puVar8 = (undefined1 *)
           (((ulonglong)(uint)((*(int *)(param_1 + 0x41fcc) + 3) * *(int *)(param_1 + 0x41fc8)) -
            (ulonglong)(uint)((*(int *)(param_1 + 0x41fc0) + 8) * (*(int *)(param_1 + 0x41fc4) + 1))
            ) + *(longlong *)(param_1 + 0x220));
  _Dst = puVar8;
  if (*(int *)(param_1 + 0x41fc4) != 0) {
    do {
      memcpy(_Dst,_Src,(ulonglong)*(uint *)(param_1 + 0x41fc0));
      iVar6 = (uint)*(byte *)((ulonglong)(*(int *)(param_1 + 0x41fc0) - 1) + (longlong)_Src) * 2 -
              (uint)*(byte *)((ulonglong)(*(int *)(param_1 + 0x41fc0) - 2) + (longlong)_Src);
      if (iVar6 < 0x100) {
        uVar5 = (undefined1)iVar6;
        if (iVar6 < 0) {
          uVar5 = 0;
        }
      }
      else {
        uVar5 = 0xff;
      }
      uVar9 = uVar9 + 1;
      _Dst[*(uint *)(param_1 + 0x41fc0)] = uVar5;
      _Src = (void *)((longlong)_Src + (ulonglong)*(uint *)(param_1 + 0x41fc0));
      _Dst = _Dst + (*(uint *)(param_1 + 0x41fc0) + 8);
    } while (uVar9 < *(uint *)(param_1 + 0x41fc4));
  }
  uVar4 = (ulonglong)(*(int *)(param_1 + 0x41fc0) + 8);
  pbVar12 = _Dst + -uVar4;
  pbVar13 = pbVar12 + -uVar4;
  for (iVar6 = *(int *)(param_1 + 0x41fc0) + 1; iVar6 != 0; iVar6 = iVar6 + -1) {
    bVar1 = *pbVar12;
    bVar2 = *pbVar13;
    pbVar13 = pbVar13 + 1;
    pbVar12 = pbVar12 + 1;
    iVar3 = (uint)bVar1 * 2 - (uint)bVar2;
    if (iVar3 < 0x100) {
      uVar5 = (undefined1)iVar3;
      if (iVar3 < 0) {
        uVar5 = 0;
      }
    }
    else {
      uVar5 = 0xff;
    }
    *_Dst = uVar5;
    _Dst = _Dst + 1;
  }
  if (*(int *)(param_1 + 0x41fc4) != 0) {
    do {
      iVar6 = *(int *)(param_1 + 0x41fc0);
      pbVar13 = (byte *)((ulonglong)(*(int *)(param_1 + 0x41fc8) * local_res8 * 4) +
                        *(longlong *)(param_1 + 0x220));
      pbVar12 = puVar8 + (iVar6 + 8) * local_res8;
      if (iVar6 != 0) {
        pbVar16 = pbVar13 + 2;
        do {
          bVar1 = *pbVar12;
          uVar10 = (uint)bVar1;
          uVar7 = (uint)pbVar12[1];
          uVar15 = (uint)pbVar12[(ulonglong)*(uint *)(param_1 + 0x41fc0) + 8];
          uVar11 = (uint)pbVar12[(ulonglong)*(uint *)(param_1 + 0x41fc0) + 9];
          pbVar12 = pbVar12 + 1;
          *pbVar13 = bVar1;
          uVar9 = uVar10 * 3 + uVar15;
          pbVar16[-1] = (byte)(uVar10 * 3 + uVar7 >> 2);
          *pbVar16 = (byte)(uVar7 + uVar10 >> 1);
          pbVar16[1] = (byte)(uVar7 * 3 + uVar10 >> 2);
          pbVar14 = pbVar13 + *(uint *)(param_1 + 0x41fc8);
          *pbVar14 = (byte)(uVar9 >> 2);
          pbVar14[1] = (byte)(uVar11 + (uVar9 + uVar7) * 3 >> 4);
          pbVar14[2] = (byte)(uVar11 + (uVar7 + uVar10) * 3 + uVar15 >> 3);
          pbVar14[3] = (byte)(uVar15 + (uVar7 * 3 + uVar11 + uVar10) * 3 >> 4);
          pbVar14 = pbVar13 + (uint)(*(int *)(param_1 + 0x41fc8) * 2);
          *pbVar14 = (byte)(uVar15 + uVar10 >> 1);
          pbVar14[1] = (byte)(uVar11 + (uVar15 + uVar10) * 3 + uVar7 >> 3);
          pbVar14[2] = (byte)(uVar11 + uVar15 + uVar7 + uVar10 >> 2);
          pbVar14[3] = (byte)(uVar15 + (uVar11 + uVar7) * 3 + uVar10 >> 3);
          pbVar14 = pbVar13 + (uint)(*(int *)(param_1 + 0x41fc8) * 3);
          *pbVar14 = (byte)(uVar15 * 3 + uVar10 >> 2);
          pbVar13 = pbVar13 + 4;
          pbVar16 = pbVar16 + 4;
          pbVar14[1] = (byte)(uVar7 + (uVar15 * 3 + uVar11 + uVar10) * 3 >> 4);
          pbVar14[2] = (byte)(uVar7 + (uVar11 + uVar15) * 3 + uVar10 >> 3);
          iVar6 = iVar6 + -1;
          pbVar14[3] = (byte)(uVar10 + (uVar15 + uVar11 * 3 + uVar7) * 3 >> 4);
        } while (iVar6 != 0);
      }
      local_res8 = local_res8 + 1;
    } while (local_res8 < *(uint *)(param_1 + 0x41fc4));
  }
  return;
}


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

### ADDR 180019e60 FUNC 180019e60 (2276 bytes) name=FUN_180019e60

void FUN_180019e60(longlong param_1)

{
  uint uVar1;
  uint uVar2;
  int iVar3;
  uint uVar4;
  uint uVar5;
  byte bVar6;
  byte bVar7;
  int iVar8;
  ulonglong uVar9;
  undefined1 uVar10;
  int iVar11;
  int iVar12;
  int iVar13;
  uint uVar14;
  undefined1 *puVar15;
  undefined1 *_Dst;
  void *_Src;
  uint uVar16;
  uint uVar17;
  uint uVar18;
  uint uVar19;
  byte *pbVar20;
  byte *pbVar21;
  int iVar22;
  byte *pbVar23;
  byte *pbVar24;
  int iVar25;
  int iVar26;
  uint uVar27;
  int iVar28;
  uint uVar29;
  int iVar30;
  int local_90;
  uint local_8c;
  
  _Src = *(void **)(param_1 + 0x2a0);
  local_8c = 0;
  uVar16 = 0;
  puVar15 = (undefined1 *)
            (((ulonglong)(uint)((*(int *)(param_1 + 0x41fcc) + 3) * *(int *)(param_1 + 0x41fc8)) -
             (ulonglong)
             (uint)((*(int *)(param_1 + 0x41fc0) + 8) * (*(int *)(param_1 + 0x41fc4) + 1))) +
            *(longlong *)(param_1 + 0x220));
  _Dst = puVar15;
  if (*(int *)(param_1 + 0x41fc4) != 0) {
    do {
      memcpy(_Dst,_Src,(ulonglong)*(uint *)(param_1 + 0x41fc0));
      iVar11 = (uint)*(byte *)((ulonglong)(*(int *)(param_1 + 0x41fc0) - 1) + (longlong)_Src) * 2 -
               (uint)*(byte *)((ulonglong)(*(int *)(param_1 + 0x41fc0) - 2) + (longlong)_Src);
      if (iVar11 < 0x100) {
        uVar10 = (undefined1)iVar11;
        if (iVar11 < 0) {
          uVar10 = 0;
        }
      }
      else {
        uVar10 = 0xff;
      }
      uVar16 = uVar16 + 1;
      _Dst[*(uint *)(param_1 + 0x41fc0)] = uVar10;
      _Src = (void *)((longlong)_Src + (ulonglong)*(uint *)(param_1 + 0x41fc0));
      _Dst = _Dst + (*(uint *)(param_1 + 0x41fc0) + 8);
    } while (uVar16 < *(uint *)(param_1 + 0x41fc4));
  }
  uVar9 = (ulonglong)(*(int *)(param_1 + 0x41fc0) + 8);
  pbVar20 = _Dst + -uVar9;
  pbVar23 = pbVar20 + -uVar9;
  for (iVar11 = *(int *)(param_1 + 0x41fc0) + 1; iVar11 != 0; iVar11 = iVar11 + -1) {
    bVar6 = *pbVar20;
    bVar7 = *pbVar23;
    pbVar23 = pbVar23 + 1;
    pbVar20 = pbVar20 + 1;
    iVar8 = (uint)bVar6 * 2 - (uint)bVar7;
    if (iVar8 < 0x100) {
      uVar10 = (undefined1)iVar8;
      if (iVar8 < 0) {
        uVar10 = 0;
      }
    }
    else {
      uVar10 = 0xff;
    }
    *_Dst = uVar10;
    _Dst = _Dst + 1;
  }
  if (*(int *)(param_1 + 0x41fc4) != 0) {
    do {
      local_90 = *(int *)(param_1 + 0x41fc0);
      pbVar20 = (byte *)((ulonglong)(*(int *)(param_1 + 0x41fc8) * local_8c * 8) +
                        *(longlong *)(param_1 + 0x220));
      if (local_90 != 0) {
        pbVar23 = pbVar20 + 6;
        pbVar24 = puVar15 + (local_90 + 8) * local_8c;
        do {
          uVar14 = (uint)pbVar24[1];
          uVar18 = (uint)*pbVar24;
          uVar27 = (uint)pbVar24[(ulonglong)*(uint *)(param_1 + 0x41fc0) + 8];
          uVar29 = (uint)pbVar24[(ulonglong)*(uint *)(param_1 + 0x41fc0) + 9];
          uVar16 = uVar18 * 7 + uVar14;
          iVar8 = uVar18 * 3;
          uVar19 = uVar14 + uVar18;
          uVar4 = iVar8 + uVar14;
          *pbVar20 = *pbVar24;
          pbVar23[-5] = (byte)(uVar16 >> 3);
          pbVar23[-4] = (byte)(uVar4 >> 2);
          pbVar23[-3] = (byte)(uVar18 * 0x28 + uVar14 * 0x18 >> 6);
          pbVar23[-2] = (byte)(uVar19 >> 1);
          pbVar23[-1] = (byte)(uVar18 * 0x18 + uVar14 * 0x28 >> 6);
          uVar17 = uVar14 * 3 + uVar18;
          *pbVar23 = (byte)(uVar17 >> 2);
          uVar1 = uVar14 * 7 + uVar18;
          pbVar23[1] = (byte)(uVar1 >> 3);
          uVar2 = uVar18 * 7 + uVar27;
          pbVar21 = pbVar20 + *(uint *)(param_1 + 0x41fc8);
          iVar3 = uVar27 * 3;
          *pbVar21 = (byte)(uVar2 >> 3);
          pbVar21[1] = (byte)((uVar2 + uVar14) * 7 + uVar29 >> 6);
          iVar11 = uVar14 * 7 + uVar29;
          pbVar21[2] = (byte)(uVar4 * 7 + iVar3 + uVar29 >> 5);
          iVar13 = uVar29 * 3;
          pbVar21[3] = (byte)(iVar11 * 3 + uVar2 * 5 >> 6);
          pbVar21[4] = (byte)(uVar19 * 7 + uVar29 + uVar27 >> 4);
          uVar5 = iVar8 + uVar27;
          pbVar21[5] = (byte)(iVar11 * 5 + uVar2 * 3 >> 6);
          pbVar21[6] = (byte)(uVar17 * 7 + iVar13 + uVar27 >> 5);
          pbVar21[7] = (byte)((uVar18 + iVar11) * 7 + uVar27 >> 6);
          pbVar21 = pbVar20 + (uint)(*(int *)(param_1 + 0x41fc8) * 2);
          *pbVar21 = (byte)(uVar5 >> 2);
          iVar11 = uVar14 * 3 + uVar29;
          pbVar21[1] = (byte)(uVar5 * 7 + uVar14 * 3 + uVar29 >> 5);
          pbVar21[2] = (byte)(uVar29 + (uVar14 + uVar5) * 3 >> 4);
          pbVar21[3] = (byte)(uVar5 * 10 + iVar11 * 6 >> 6);
          pbVar21[4] = (byte)(uVar29 + uVar19 * 3 + uVar27 >> 3);
          pbVar21[5] = (byte)(uVar5 * 6 + iVar11 * 10 >> 6);
          pbVar21[6] = (byte)(uVar27 + (iVar11 + uVar18) * 3 >> 4);
          pbVar21[7] = (byte)(iVar11 * 7 + iVar8 + uVar27 >> 5);
          pbVar21 = pbVar20 + (uint)(*(int *)(param_1 + 0x41fc8) * 3);
          iVar11 = uVar27 * 7 + uVar29;
          *pbVar21 = (byte)(uVar18 * 0x28 + uVar27 * 0x18 >> 6);
          iVar22 = (uVar29 + uVar18) * 0xf;
          iVar30 = uVar29 + iVar3;
          pbVar21[1] = (byte)(iVar11 * 3 + uVar16 * 5 >> 6);
          iVar28 = uVar27 + uVar29;
          iVar25 = (uVar27 + uVar14) * 0xf;
          pbVar21[2] = (byte)(uVar4 * 10 + iVar30 * 6 >> 6);
          iVar26 = iVar13 + uVar27;
          pbVar21[3] = (byte)(uVar18 * 0x19 + iVar25 + uVar29 * 9 >> 6);
          pbVar21[4] = (byte)(uVar19 * 0x14 + iVar28 * 0xc >> 6);
          iVar8 = uVar29 * 7 + uVar27;
          pbVar21[5] = (byte)(uVar27 * 9 + uVar14 * 0x19 + iVar22 >> 6);
          pbVar21[6] = (byte)((uVar14 * 3 + uVar18) * 10 + iVar26 * 6 >> 6);
          pbVar21[7] = (byte)(iVar8 * 3 + uVar1 * 5 >> 6);
          pbVar21 = pbVar20 + (uint)(*(int *)(param_1 + 0x41fc8) << 2);
          uVar19 = uVar27 + uVar18;
          *pbVar21 = (byte)(uVar19 >> 1);
          pbVar21[1] = (byte)(uVar19 * 7 + uVar29 + uVar14 >> 4);
          iVar12 = uVar29 + uVar14;
          pbVar21[2] = (byte)(uVar29 + uVar19 * 3 + uVar14 >> 3);
          pbVar21[3] = (byte)(uVar19 * 0x14 + iVar12 * 0xc >> 6);
          pbVar21[4] = (byte)(iVar28 + uVar14 + uVar18 >> 2);
          pbVar21[5] = (byte)(uVar19 * 0xc + iVar12 * 0x14 >> 6);
          pbVar21[6] = (byte)(uVar27 + iVar12 * 3 + uVar18 >> 3);
          pbVar21[7] = (byte)(iVar12 * 7 + uVar27 + uVar18 >> 4);
          pbVar21 = pbVar20 + (uint)(*(int *)(param_1 + 0x41fc8) * 5);
          *pbVar21 = (byte)(uVar18 * 0x18 + uVar27 * 0x28 >> 6);
          pbVar21[1] = (byte)(iVar11 * 5 + uVar16 * 3 >> 6);
          pbVar21[2] = (byte)((uVar18 * 3 + uVar14) * 6 + iVar30 * 10 >> 6);
          uVar16 = uVar18 + iVar3;
          pbVar21[3] = (byte)(uVar14 * 9 + iVar22 + uVar27 * 0x19 >> 6);
          pbVar21[4] = (byte)((uVar14 + uVar18) * 0xc + iVar28 * 0x14 >> 6);
          pbVar21[5] = (byte)(uVar18 * 9 + uVar29 * 0x19 + iVar25 >> 6);
          pbVar21[6] = (byte)((uVar14 * 3 + uVar18) * 6 + iVar26 * 10 >> 6);
          pbVar21[7] = (byte)(iVar8 * 5 + uVar1 * 3 >> 6);
          pbVar21 = pbVar20 + (uint)(*(int *)(param_1 + 0x41fc8) * 6);
          *pbVar21 = (byte)(uVar16 >> 2);
          pbVar21[1] = (byte)(uVar16 * 7 + iVar13 + uVar14 >> 5);
          iVar13 = iVar13 + uVar14;
          pbVar21[2] = (byte)(uVar14 + (iVar30 + uVar18) * 3 >> 4);
          pbVar21[3] = (byte)(uVar16 * 10 + iVar13 * 6 >> 6);
          pbVar21[4] = (byte)(uVar14 + iVar28 * 3 + uVar18 >> 3);
          pbVar21[5] = (byte)(uVar16 * 6 + iVar13 * 10 >> 6);
          pbVar21[6] = (byte)(uVar18 + (iVar26 + uVar14) * 3 >> 4);
          pbVar21[7] = (byte)(iVar13 * 7 + iVar3 + uVar18 >> 5);
          iVar3 = uVar29 * 7 + uVar14;
          pbVar21 = pbVar20 + (uint)(*(int *)(param_1 + 0x41fc8) * 7);
          uVar16 = uVar18 + uVar27 * 7;
          *pbVar21 = (byte)(uVar16 >> 3);
          pbVar21[1] = (byte)((iVar11 + uVar18) * 7 + uVar14 >> 6);
          pbVar21[2] = (byte)(iVar30 * 7 + uVar18 * 3 + uVar14 >> 5);
          pbVar21[3] = (byte)(iVar3 * 3 + uVar16 * 5 >> 6);
          pbVar21[4] = (byte)(iVar28 * 7 + uVar14 + uVar18 >> 4);
          pbVar21[5] = (byte)(iVar3 * 5 + uVar16 * 3 >> 6);
          pbVar20 = pbVar20 + 8;
          pbVar23 = pbVar23 + 8;
          local_90 = local_90 + -1;
          pbVar21[6] = (byte)(iVar26 * 7 + uVar14 * 3 + uVar18 >> 5);
          pbVar21[7] = (byte)((iVar8 + uVar14) * 7 + uVar18 >> 6);
          pbVar24 = pbVar24 + 1;
        } while (local_90 != 0);
      }
      local_8c = local_8c + 1;
    } while (local_8c < *(uint *)(param_1 + 0x41fc4));
  }
  return;
}


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

### ADDR 1800191b0 FUNC 1800191b0 (1423 bytes) name=FUN_1800191b0

/* WARNING: Type propagation algorithm not settling */

byte * FUN_1800191b0(longlong param_1)

{
  int iVar1;
  byte bVar2;
  byte bVar3;
  byte bVar4;
  byte bVar5;
  byte bVar6;
  byte bVar7;
  uint uVar8;
  byte *pbVar9;
  ulonglong uVar10;
  undefined1 uVar11;
  int iVar12;
  int iVar13;
  undefined1 *puVar14;
  undefined1 *_Dst;
  uint uVar15;
  uint uVar16;
  uint uVar17;
  byte *pbVar18;
  int iVar19;
  byte *pbVar20;
  int iVar21;
  byte *pbVar22;
  byte *pbVar23;
  uint uVar24;
  uint uVar25;
  uint uVar26;
  uint uVar27;
  uint local_res10;
  uint local_res18;
  uint local_res20;
  
  pbVar18 = *(byte **)(param_1 + 0x2a0);
  uVar8 = *(int *)(param_1 + 0x41fc0) + 8;
  pbVar9 = (byte *)(ulonglong)uVar8;
  local_res18 = 0;
  uVar15 = 0;
  puVar14 = (undefined1 *)
            (((ulonglong)(uint)((*(int *)(param_1 + 0x41fcc) + 3) * *(int *)(param_1 + 0x41fc8)) -
             (ulonglong)((*(int *)(param_1 + 0x41fc4) + 1) * uVar8)) +
            *(longlong *)(param_1 + 0x220));
  _Dst = puVar14;
  if (*(int *)(param_1 + 0x41fc4) != 0) {
    do {
      memcpy(_Dst,pbVar18,(ulonglong)*(uint *)(param_1 + 0x41fc0));
      iVar12 = (uint)pbVar18[*(int *)(param_1 + 0x41fc0) - 1] * 2 -
               (uint)pbVar18[*(int *)(param_1 + 0x41fc0) - 2];
      if (iVar12 < 0x100) {
        uVar11 = (undefined1)iVar12;
        if (iVar12 < 0) {
          uVar11 = 0;
        }
      }
      else {
        uVar11 = 0xff;
      }
      uVar15 = uVar15 + 1;
      _Dst[*(uint *)(param_1 + 0x41fc0)] = uVar11;
      pbVar9 = (byte *)(ulonglong)*(uint *)(param_1 + 0x41fc0);
      pbVar18 = pbVar18 + (longlong)pbVar9;
      _Dst = _Dst + (*(uint *)(param_1 + 0x41fc0) + 8);
    } while (uVar15 < *(uint *)(param_1 + 0x41fc4));
  }
  uVar10 = (ulonglong)(*(int *)(param_1 + 0x41fc0) + 8);
  pbVar18 = _Dst + -uVar10;
  pbVar20 = pbVar18 + -uVar10;
  for (iVar12 = *(int *)(param_1 + 0x41fc0) + 1; iVar12 != 0; iVar12 = iVar12 + -1) {
    bVar2 = *pbVar18;
    bVar3 = *pbVar20;
    pbVar20 = pbVar20 + 1;
    pbVar18 = pbVar18 + 1;
    uVar8 = (uint)bVar2 * 2 - (uint)bVar3;
    if ((int)uVar8 < 0x100) {
      pbVar9 = (byte *)(ulonglong)uVar8;
      if ((int)uVar8 < 0) {
        pbVar9 = (byte *)0x0;
      }
    }
    else {
      pbVar9 = (byte *)0xff;
    }
    *_Dst = (char)pbVar9;
    _Dst = _Dst + 1;
  }
  if (*(int *)(param_1 + 0x41fc4) != 0) {
    uVar10 = 0;
    local_res20 = 0;
    do {
      local_res10 = *(uint *)(param_1 + 0x41fc0);
      pbVar20 = puVar14 + (local_res10 + 8) * local_res18;
      pbVar9 = (byte *)((ulonglong)local_res10 * 0xaaaaaaab & 0xffffffff);
      pbVar18 = (byte *)((ulonglong)(uint)((int)(uVar10 / 3) * *(int *)(param_1 + 0x41fc8)) +
                        *(longlong *)(param_1 + 0x220));
      local_res10 = local_res10 / 3;
      if (local_res10 != 0) {
        pbVar9 = pbVar20 + 2;
        pbVar23 = pbVar18 + 3;
        do {
          bVar2 = pbVar9[-1];
          bVar3 = *pbVar9;
          bVar4 = pbVar9[1];
          bVar5 = *pbVar20;
          uVar10 = (ulonglong)*(uint *)(param_1 + 0x41fc0);
          iVar19 = (uint)bVar3 + (uint)bVar2 * 4;
          bVar6 = pbVar20[uVar10 + 10];
          bVar7 = pbVar20[uVar10 + 9];
          uVar27 = (uint)bVar7;
          uVar26 = (uint)pbVar20[uVar10 + 8];
          iVar13 = (uint)bVar5 * 0x19a;
          uVar8 = (uint)pbVar20[uVar10 + 0xb];
          iVar21 = (uint)bVar2 + (uint)bVar3 * 4;
          *pbVar18 = bVar5 / 1;
          uVar15 = (uint)bVar6;
          pbVar23[-2] = (byte)((uint)bVar2 * 0x267 + iVar13 >> 10);
          pbVar23[-1] = (byte)((uint)(iVar19 * 0xcd) >> 10);
          *pbVar23 = (byte)((uint)(iVar21 * 0xcd) >> 10);
          pbVar23[1] = (byte)((uint)bVar3 * 0x267 + (uint)bVar4 * 0x19a >> 10);
          pbVar22 = pbVar18 + *(uint *)(param_1 + 0x41fc8);
          iVar12 = (uint)bVar7 * 4;
          *pbVar22 = (byte)(uVar26 * 0x267 + iVar13 >> 10);
          iVar1 = (uint)bVar6 * 4;
          pbVar22[1] = (byte)((uVar26 + bVar2) * 0xf6 + uVar27 * 0x171 + (uint)bVar5 * 0xa4 >> 10);
          pbVar22[2] = (byte)((iVar12 + (uint)bVar6) * 0x7b + iVar19 * 0x52 >> 10);
          pbVar22[3] = (byte)((iVar1 + uVar27) * 0x7b + iVar21 * 0x52 >> 10);
          pbVar22[4] = (byte)((uVar8 + bVar3) * 0xf6 + uVar15 * 0x171 + (uint)bVar4 * 0xa4 >> 10);
          pbVar22 = pbVar20 + (*(int *)(param_1 + 0x41fc0) * 2 + 0x10);
          uVar25 = (uint)pbVar22[2];
          uVar17 = (uint)*pbVar22;
          uVar16 = (uint)pbVar22[1];
          uVar24 = (uint)pbVar22[3];
          iVar12 = iVar12 + uVar16;
          pbVar22 = pbVar18 + (uint)(*(int *)(param_1 + 0x41fc8) * 2);
          iVar13 = uVar17 + uVar26 * 4;
          *pbVar22 = (byte)((uint)(iVar13 * 0xcd) >> 10);
          iVar1 = iVar1 + uVar25;
          pbVar22[1] = (byte)((uint)(iVar12 * 0x7b + iVar13 * 0x52) >> 10);
          pbVar22[2] = (byte)((uVar25 + (iVar12 + uVar15) * 4) * 0x29 >> 10);
          iVar12 = uVar26 + uVar17 * 4;
          pbVar22[3] = (byte)((uVar16 + (iVar1 + uVar27) * 4) * 0x29 >> 10);
          pbVar22[4] = (byte)((uVar24 + uVar8 * 4) * 0x52 + iVar1 * 0x7b >> 10);
          iVar13 = uVar16 * 4 + uVar25;
          pbVar22 = pbVar18 + (uint)(*(int *)(param_1 + 0x41fc8) * 3);
          *pbVar22 = (byte)((uint)(iVar12 * 0xcd) >> 10);
          iVar1 = uVar25 * 4 + uVar16;
          pbVar22[1] = (byte)((uVar16 * 4 + uVar27) * 0x7b + iVar12 * 0x52 >> 10);
          pbVar22[2] = (byte)((uVar15 + (iVar13 + uVar27) * 4) * 0x29 >> 10);
          pbVar22[3] = (byte)((uVar27 + (iVar1 + uVar15) * 4) * 0x29 >> 10);
          pbVar22[4] = (byte)((uVar8 + uVar24 * 4) * 0x52 + (uVar25 * 4 + uVar15) * 0x7b >> 10);
          pbVar22 = pbVar20 + (*(int *)(param_1 + 0x41fc0) * 3 + 0x18);
          bVar2 = *pbVar22;
          uVar8 = (uint)pbVar22[1];
          uVar15 = (uint)pbVar22[2];
          bVar3 = pbVar22[3];
          pbVar20 = pbVar20 + 3;
          pbVar22 = pbVar18 + (uint)(*(int *)(param_1 + 0x41fc8) << 2);
          *pbVar22 = (byte)((uint)bVar2 * 0x19a + uVar17 * 0x267 >> 10);
          pbVar22[1] = (byte)((uVar8 + uVar17) * 0xf6 + uVar16 * 0x171 + (uint)bVar2 * 0xa4 >> 10);
          pbVar22[2] = (byte)((uVar15 + uVar8 * 4) * 0x52 + iVar13 * 0x7b >> 10);
          pbVar22[3] = (byte)((uVar8 + uVar15 * 4) * 0x52 + iVar1 * 0x7b >> 10);
          pbVar18 = pbVar18 + 5;
          pbVar22[4] = (byte)((uVar15 + uVar24) * 0xf6 + uVar25 * 0x171 + (uint)bVar3 * 0xa4 >> 10);
          pbVar9 = pbVar9 + 3;
          pbVar23 = pbVar23 + 5;
          local_res10 = local_res10 - 1;
        } while (local_res10 != 0);
      }
      local_res18 = local_res18 + 3;
      local_res20 = local_res20 + 0xf;
      uVar10 = (ulonglong)local_res20;
    } while (local_res18 < *(uint *)(param_1 + 0x41fc4));
  }
  return pbVar9;
}


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

### ADDR 18001a750 FUNC 18001a750 (841 bytes) name=FUN_18001a750

void FUN_18001a750(longlong param_1)

{
  uint uVar1;
  uint uVar2;
  uint uVar3;
  uint uVar4;
  int iVar5;
  float fVar6;
  float fVar7;
  undefined1 uVar8;
  uint uVar9;
  longlong lVar10;
  uint uVar11;
  uint uVar12;
  ulonglong uVar13;
  uint uVar14;
  int iVar15;
  ulonglong uVar16;
  ulonglong uVar17;
  int iVar18;
  float fVar19;
  float fVar20;
  float fVar21;
  float fVar22;
  float fVar23;
  
  fVar7 = DAT_18005e704;
  fVar6 = DAT_18005e700;
  uVar1 = *(uint *)(param_1 + 0x41fc8);
  uVar2 = *(uint *)(param_1 + 0x41fc0);
  uVar3 = *(uint *)(param_1 + 0x41fc4);
  uVar4 = *(uint *)(param_1 + 0x41fcc);
  uVar17 = 0;
  if (uVar1 != 0) {
    fVar23 = (float)uVar2 - DAT_18005e700;
    do {
      iVar18 = (int)uVar17;
      fVar22 = (float)uVar17 * ((float)uVar2 / (float)uVar1);
      if (fVar23 < fVar22) {
        fVar22 = fVar23;
      }
      uVar11 = 0;
      uVar13 = (ulonglong)fVar22;
      if (uVar4 != 0) {
        iVar5 = (int)uVar13;
        uVar12 = iVar5 + 1;
        fVar21 = (float)uVar3 - fVar6;
        do {
          fVar20 = (float)uVar11 * ((float)uVar3 / (float)uVar4);
          if (fVar21 < fVar20) {
            fVar20 = fVar21;
          }
          uVar16 = (ulonglong)fVar20;
          iVar15 = (int)uVar16;
          if ((uVar12 < uVar2) && (iVar15 + 1U < uVar3)) {
            lVar10 = *(longlong *)(param_1 + 0x2a0);
            uVar14 = iVar15 * uVar2 + iVar5;
            fVar19 = fVar22 - (float)(uVar13 & 0xffffffff);
            fVar20 = fVar20 - (float)(uVar16 & 0xffffffff);
            lVar10 = (longlong)
                     (((float)*(byte *)((ulonglong)(uVar14 + uVar2) + lVar10) * (fVar6 - fVar19) +
                      (float)*(byte *)((ulonglong)(uVar14 + 1 + uVar2) + lVar10) * fVar19) * fVar20
                      + ((float)*(byte *)((ulonglong)(uVar14 + 1) + lVar10) * fVar19 +
                        (float)*(byte *)((ulonglong)uVar14 + lVar10) * (fVar6 - fVar19)) *
                        (fVar6 - fVar20) + fVar7);
            uVar8 = (undefined1)lVar10;
            if (0xff < (uint)lVar10) {
              uVar8 = 0xff;
            }
            *(undefined1 *)(uVar17 + *(longlong *)(param_1 + 0x220)) = uVar8;
          }
          else {
            uVar14 = iVar15 + 1;
            if ((uVar14 == uVar3) && (uVar12 < uVar2)) {
              uVar14 = iVar15 * uVar2 + iVar5;
              uVar9 = (uint)*(byte *)((ulonglong)uVar14 + *(longlong *)(param_1 + 0x2a0));
              lVar10 = (longlong)
                       ((float)(int)(*(byte *)((ulonglong)(uVar14 + 1) +
                                              *(longlong *)(param_1 + 0x2a0)) - uVar9) *
                        (fVar22 - (float)(uVar13 & 0xffffffff)) + (float)uVar9 + fVar7);
              uVar8 = (undefined1)lVar10;
              if (0xff < (uint)lVar10) {
                uVar8 = 0xff;
              }
              *(undefined1 *)(uVar17 + *(longlong *)(param_1 + 0x220)) = uVar8;
            }
            else if ((uVar12 == uVar2) && (uVar14 < uVar3)) {
              uVar9 = (uint)*(byte *)((ulonglong)(iVar15 * uVar2 + iVar5) +
                                     *(longlong *)(param_1 + 0x2a0));
              lVar10 = (longlong)
                       ((float)(int)(*(byte *)((ulonglong)(uVar14 * uVar2 + iVar5) +
                                              *(longlong *)(param_1 + 0x2a0)) - uVar9) *
                        (fVar20 - (float)(uVar16 & 0xffffffff)) + (float)uVar9 + fVar7);
              uVar8 = (undefined1)lVar10;
              if (0xff < (uint)lVar10) {
                uVar8 = 0xff;
              }
              *(undefined1 *)(uVar17 + *(longlong *)(param_1 + 0x220)) = uVar8;
            }
            else {
              *(undefined1 *)(uVar17 + *(longlong *)(param_1 + 0x220)) =
                   *(undefined1 *)
                    ((ulonglong)(iVar15 * uVar2 + iVar5) + *(longlong *)(param_1 + 0x2a0));
            }
          }
          uVar11 = uVar11 + 1;
          uVar17 = (ulonglong)((int)uVar17 + uVar1);
        } while (uVar11 < uVar4);
      }
      uVar11 = iVar18 + 1;
      uVar17 = (ulonglong)uVar11;
    } while (uVar11 < uVar1);
  }
  return;
}


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

