struct TCollection{
  int Count;//itemcunt
  int Delta;//increase buffer Delta
  int Items;//pointer to array of item pointers
  int Limit;//currently allocated size (in elements) of Items list

  TCollection( int ALimit,ADelta );
  ~TCollection( void );

  int  At( int Index );
  void AtDelete( int Index );
  void AtFree( int Index );
  void AtInsert( int Index, Item );
  void DeleteAll( void );
  void Free( int Item );
  void FreeAll( void );
  void FreeItem( int Item );
  void Insert( int Item );
  void SetLimit( int ALimit );
};

:int TCollection::At( int Index )
{
  return DSDWORD[ Index*sizeof(int)+Items ];
}

:void TCollection::AtDelete( int Index )
{
//  if(Index<0)||(Index>=Count){/*Error(coIndexError);*/return;}
  ECX = Count-Index-1;
  EDI = Index*sizeof(int)+Items; ESI = EDI+4; $cld; $rep;$movsd;
  Count --;
}

:void TCollection::AtFree( int Index )
{
  int Item = At( Index);
  AtDelete( Index );
  FreeItem( Item );
}

:void TCollection::AtInsert( int Index, Item )
{
  $pushfd
  IF( Count == Limit )
  {
    SetLimit( Count+Delta );
  }
  ECX = Count-Index;
  EDI = Count*sizeof(int)+Items;
  ESI = EDI-4; $std $rep $movsd $cld
  DSDWORD[ EDI ] = Item;
  Count ++;
  $popfd
}

:void TCollection::DeleteAll()
{
  Count=0;
}

:void TCollection::Free( int Item )
{
  Delete( Item );
  FreeItem( Item );
}

:void TCollection::FreeAll( void )
{
  int I;
  FOR( I = 0; I < Count; I ++ )FreeItem( At(I) );
  Count = 0;
}

:void TCollection::FreeItem( int Item )
{
  IF( Item )free( Item );//+++Dispose(PObject(Item), Done);
}

:void TCollection::Insert( int Item )
{
  AtInsert( Count, Item );
}

:void TCollection::SetLimit( int ALimit )
{
  int AItems;

  IF( ALimit < Count )ALimit = Count;
  IF( ALimit != Limit )
  {
    IF( !ALimit ) AItems = 0;
    ELSE
    {
      AItems = malloc(ALimit*sizeof(int) );
      IF( Count )&&( Items )
      {
        CopyMemory( AItems, Items, Limit*sizeof(int) );
      }
    }
    IF( Limit )free( Items );
    Items = AItems;
    Limit = ALimit;
  }
}

:TCollection::TCollection( int ALimit, ADelta )
{
  Items = 0;
  Count = 0;
  Limit = 0;
  Delta = ADelta;
  SetLimit( ALimit );
  return this;
}

:TCollection::~TCollection( void )
{
  FreeAll();
  SetLimit(0);
}

struct TSortedCollection:TCollection
{
  int  comparemethod;
  int  Duplicates;

  TSortedCollection( int ALimit, ADelta );

  int  Compare( int Key1, Key2 );
  void Insert( int Item );
  int  Search( int Key, Index );
};

:int TSortedCollection::Compare( int Key1, Key2 )
{
  strcmp( Key1, Key2 );
}

:TSortedCollection::TSortedCollection( int ALimit, ADelta )
:TCollection( ALimit, ADelta );
{
  comparemethod=#Compare;
  return this;
}

:void TSortedCollection::Insert( int Item )
{
  int i;
  IF( !Search(/*KeyOf(*/Item/*)*/,#i) ) || ( Duplicates )AtInsert( i, Item );
}


:int TSortedCollection::Search( int Key, Index )
{
  int L, H, I, C;
  int S;

  S = 0;
  L = 0;
  H = Count-1;
  WHILE( L <= H )
  {
    I = L+H >> 1;
    ECX = I*sizeof(int)+Items;
    comparemethod( this, /*KeyOf(*/DSDWORD[ECX]/*)*/, Key );
    C = EAX;
    IF( C < 0 ){ L = I+1; }
    ELSE
    {
      H = I-1;
      IF( !C ){
        S = 1;
        IF( !Duplicates )L = I;
      }
    }
  }
  DSDWORD[ Index ]=L;
  return S;
}