element = new Set;
// Create memory space for new record
if (element != NULL) // Be sure memory can be allocated

if (element=new Set)

class List
{
  struct Item
  {
    int value_;
  } *head_;
  
  void silent_free(); // throw()
public:
  List() : head_(NULL) {}
  List( List& rhs ) : head_( rhs.head ) {}
  ~List() { silent_free(); } // no throw dtor
  void clear(); // mb throw eraser

  void push_back( int v );
  // ну и т.д.
};

// class for test algo
// not for use!!!!
class SList{
public:
    
    class SListItem{
        friend class SList; // hack for unmark tail
        SListItem* next_;
    public:
        int value;

        SListItem(int i= 0 ) : value(i), next_(NULL) {}
        SListItem(SListItem* nxt, int i= 0 ) : value(i), next_(nxt) {}

        // check marked tail
        SListItem* next() const { return next_ && next_->next_ != next_ ? next_ : NULL; }
    } *head;
    
    SList() : head(NULL) {}
    ~SList() { free(head); }

    
    //for reverse or fast add items
    SListItem* push_front( int value )
    {
        return head = new SListItem( head, value );
    }

    // very slow method, mb u can save tail, but it is danger
   
    SListItem* push_back( int value )
    {
        // find tail
        for( SListItem* cur=head; cur && cur->next(); cur = cur->next() );

        return head ? insert( cur, value ) : head = insert( head, value );
    }

    SListItem* insert( SListItem* after, int value )
    {
        if( after ){
            // insert in marked tail
            if( !after->next() && after->next_ ){
                after->next_->value = value;
                after->next_->next_ = NULL;
                return after->next_;
            }

            // simple insert after
            return after->next_ = new SListItem( after->next_, value );
        }

        // new head
        return after = new SListItem( value );
    }

    SListItem* remove( SListItem* pos )
    {
        if( !pos ) // mb replace assert
            return pos;

        if( pos->next_ ){ // copy from next
            SListItem* tmp( pos->next_->next_ );
            
            pos->value = pos->next_->value;
            delete pos->next_;

            pos->next_ = tmp;
            return pos;
        } 
        
        pos->next_ = pos; // remove last
        return NULL;
    }

    SListItem* reverse()
    {
        if(!head || !head->next())
            return head;
        
        SListItem *h(NULL);

        for( SListItem *cur = head; cur; cur = cur->next() )
            h = new SListItem( h, cur->value );

        free( head );
        return head = h;
    }

private:

    // for internal use
    void free( SListItem* item )
    {
        if( !item )
            return;

        if(item->next_)
            free( item->next_ );

        delete item;
    }


    // wrong code, save as example
    
    SListItem* remove_last( SListItem* pos )
    {
        // ACHTUNG !!!!
        // THIS WRONG FUCKING CODE!!!!!
        delete pos;
        pos = NULL;

        return pos;
    }
};