struct GR5_TemplateItem
{
  DWORD *pVMT;
  DWORD m_ItemID;
  BYTE m_ItemType;
  CHAR *m_ItemName;
  BYTE m_DurabilityType;
  bool m_IsInInventory;
  bool m_IsSellable;
  bool m_IsLootable;
  bool m_IsRewardable;
  bool m_IsUnlockable;
  DWORD m_MaxItemInSlot;
  DWORD m_GearScore;
  float m_IGCValue;
  DWORD m_OasisName;
  DWORD m_OasisDesc;
};

struct unknownStruct1
{
  unknownStruct2 *unkownStruct2;
  _DWORD string_RDV_;
  _DWORD string_cl_T;
  GR5_TemplateItem *pStart;
  GR5_TemplateItem *pNext;
  GR5_TemplateItem *pEnd;
  _DWORD unk5;
  _DWORD unk6;
  _DWORD unk7;
  _DWORD unk8;
  _DWORD unk9;
  _DWORD unk10;
};

struct unknownStruct2
{
  unknownStruct3 **unkownStruct3;
  _DWORD pEnd;
  _DWORD unk3;
  _DWORD unk4;
  _DWORD unk5;
  _DWORD unk6;
  _DWORD unk7;
  _DWORD unk8;
  _DWORD unk9;
  _DWORD unk10;
};

struct unknownStruct3
{
  _DWORD dword0;
  _DWORD dword4;
  _DWORD dword8;
  _DWORD pMemStart;
  _DWORD pMaxCapacity;
};



GR5_TemplateItem *__thiscall AddTemplateItem_(unknownStruct1 *this, GR5_TemplateItem *item)
{
  GR5_TemplateItem *v2; // ST50_4
  GR5_TemplateItem *result; // eax
  unsigned int idxMax; // [esp+0h] [ebp-60h]
  GR5_TemplateItem *pNext; // [esp+34h] [ebp-2Ch] MAPDST
  int v7; // [esp+48h] [ebp-18h]
  unknownStruct2 *v8; // [esp+50h] [ebp-10h] MAPDST

  if ( this->pStart )
    idxMax = this->pEnd - this->pStart;
  else
    idxMax = 0;
  if ( this->pNext - this->pStart >= idxMax )
  {
    pNext = this->pNext;
    v8 = 0;
    if ( !this || this->pStart > pNext || pNext > this->pNext )
      _invalid_parameter_noinfo();
    v8 = this->unkownStruct2;
    result = AppendTemplateItem(this, &v7, v8, pNext, item);
  }
  else
  {
    v2 = this->pNext;
    result = AssignTemplateItem(this->pNext, 1, item);
    this->pNext = v2 + 1;
  }
  return result;
}

unknownStruct2 **__thiscall AppendTemplateItem_(unknownStruct1 *this, int a2, unknownStruct2 *a3, DWORD pNext, GR5_TemplateItem *item)
{
  int idxMax; // [esp+0h] [ebp-34h] MAPDST
  GR5_TemplateItem *idxFirst; // [esp+18h] [ebp-1Ch] MAPDST
  GR5_TemplateItem *v12; // [esp+1Ch] [ebp-18h] MAPDST
  unknownStruct2 *v13; // [esp+20h] [ebp-14h] MAPDST
  unknownStruct2 *v15; // [esp+28h] [ebp-Ch]

  if ( this->pNext - this->pStart )
  {
    v12 = this->pStart;
    v15 = 0;
    if ( !this || this->pStart > v12 || v12 > this->pNext )
      _invalid_parameter_noinfo();
    v15 = this->unkownStruct2;
    if ( !a3 || a3 != v15 )
      _invalid_parameter_noinfo();
    idxMax = (pNext - v12) / 44;
  }
  else
  {
    idxMax = 0;
  }
  AppendTemplateItems(this, a3, a3, pNext, 1, item);
  idxFirst = this->pStart;
  v13 = 0;
  if ( !this || this->pStart > idxFirst || idxFirst > this->pNext )
    _invalid_parameter_noinfo();
  v13 = this->unkownStruct2;
  IncreaseListSize(&v13, idxMax);
  *a2 = v13;
  *(a2 + 4) = idxFirst;
  return a2;
}

unknownStruct1 *__fastcall AppendTemplateItems_(unknownStruct1 *a1, int a2, int a3, int pNext, unsigned int count, GR5_TemplateItem *item)
{
  // [COLLAPSED LOCAL DECLARATIONS. PRESS KEYPAD CTRL-"+" TO EXPAND]

  v94 = &v8;
  result = a1;
  if ( a1->pStart )
  {
    result = (a1->pEnd - a1->pStart);
    maxCount = a1->pEnd - a1->pStart;
  }
  else
  {
    maxCount = 0;
  }
  if ( count )
  {
    v11 = 0x5D1745D;
    v11 = 0x5D1745D;
    if ( 0x5D1745D - (a1->pNext - a1->pStart) < count )
      outOfMemoryError();
    if ( maxCount >= count + a1->pNext - a1->pStart )
    {
      if ( (a1->pNext - pNext) / 44 >= count )
      {
        CopyTemplateItem(&v87, item);
        v87.pVMT = &Quazal::GR5_TemplateItem::'vftable';
        v95 = 6;
        v88 = a1->pNext;
        v26 = a1->pNext;
        v7 = sub_10008EB8(&v88[-count], v88, v26);
        a1->pNext = v7;
        v19 = &v88[-count];
        v25 = 0;
        v22 = &v88[-count];
        sub_100072C5(pNext, &v88[-count], v88);
        v14 = pNext + 44 * count;
        v17 = (pNext + 44 * count);
        for ( i = pNext; i != v17; ++i )
          CopyTemplateItem_0(i, &v87);
        v87.pVMT = &Quazal::_DDL_GR5_TemplateItem::'vftable';
        v95 = 7;
        Quazal::String::~String(&v87.m_ItemName);
        v95 = -1;
        result = Quazal::RootObject::~RootObject(&v87.m_ItemID);
      }
      else
      {
        CopyTemplateItem(&a1a, item);
        a1a.pVMT = &Quazal::GR5_TemplateItem::'vftable';
        v95 = 2;
        v37 = a1->pNext;
        v38 = pNext + 44 * count;
        v47 = 0;
        v41 = 0;
        v42 = pNext + 44 * count;
        sub_10003486(pNext, v37, pNext + 44 * count);
        LOBYTE(v95) = 3;
        a2a = count - (a1->pNext - pNext) / 44;
        v32 = a1->pNext;
        v36 = 0;
        AssignTemplateItem(v32, a2a, &a1a);
        v95 = 2;
        a1->pNext += count;
        v27 = &a1->pNext[-count];
        for ( j = pNext; j != v27; ++j )
          CopyTemplateItem_0(j, &a1a);
        a1a.pVMT = &Quazal::_DDL_GR5_TemplateItem::'vftable';
        v95 = 5;
        Quazal::String::~String(&a1a.m_ItemName);
        v95 = -1;
        result = Quazal::RootObject::~RootObject(&a1a.m_ItemID);
      }
    }
    else
    {
      v85 = 0x5D1745D;
      v10 = 0x5D1745D;
      if ( 0x5D1745D - (maxCount >> 1) >= maxCount )
        v9 = maxCount + (maxCount >> 1);
      else
        v9 = 0;
      maxCount = v9;
      if ( v9 < count + a1->pNext - a1->pStart )
        maxCount = count + a1->pNext - a1->pStart;
      v91 = Quazal::MemoryManager::Allocate(44 * maxCount, 7);
      v92 = (pNext - a1->pStart) / 44;
      v90 = 0;
      v95 = 0;
      v80 = &v91[v92];
      v81 = &v91[v92];
      v84 = 0;
      AssignTemplateItem(v81, count, item);
      ++v90;
      v69 = a1->pStart;
      v79 = 0;
      v73 = 0;
      sub_10003486(v69, pNext, v91);
      ++v90;
      v58 = a1->pNext;
      v59 = &v91[count + v92];
      v68 = 0;
      v62 = 0;
      v63 = &v91[count + v92];
      sub_10003486(pNext, v58, &v91[count + v92]);
      v95 = -1;
      counta = count + a1->pNext - a1->pStart;
      if ( a1->pStart )
      {
        v50 = a1->pNext;
        v51 = a1->pStart;
        for ( k = v51; k != v50; ++k )
          (*k->pVMT)(k, 0);
        v48 = a1->pEnd - a1->pStart;
        v49 = a1->pStart;
        Quazal::MemoryManager::Free(v49, 7);
      }
      a1->pEnd = &v91[maxCount];
      a1->pNext = &v91[counta];
      result = a1;
      a1->pStart = v91;
    }
  }
  return result;
}

GR5_TemplateItem **__thiscall IncreaseListSize_(unknownStruct2 *this, int count)
{
  unknownStruct3 *v3; // [esp+0h] [ebp-1Ch]
  unknownStruct3 *v4; // [esp+4h] [ebp-18h]

  if ( this->unkownStruct3 == 0 )
    _invalid_parameter_noinfo();
  if ( this->unkownStruct3 )
    v4 = *this->unkownStruct3;
  else
    v4 = 0;
  if ( (this->pEnd + 44 * count) > v4->pMaxCapacity
    || (!this->unkownStruct3 ? (v3 = 0) : (v3 = *this->unkownStruct3), (this->pEnd + 44 * count) < v3->pMemStart) )
  {
    _invalid_parameter_noinfo();
  }
  this->pEnd += 44 * count;
  return this;
}