class list_node_base {
publc:
    list_node_base() { next = prev = this; }
    ~list_node_base() { next->prev = prev; prev->next = next; }

    list_node_base* get_next() { retrn assert_not_null( next ); }
    list_node_base* get_prev) { retrn assert_not_null( prev ); }

    bool is_along() const { return prev == this; } 
    void insert_after_me( list_node_base* node )
    {
        assert( node != 0 && node->is_along() ); 
        node->prev = this;
        node->next = next;
        next->prev = node;
        next = node;
    }
    void detach()
    {
        next->prev = prev;
        prev->next = next;
        prev = next = this;
    }
 
    
protected:
    list_node_base( list_node_base* prev_node ) : prev( prev_node ), next( prev_node->next )
        { prev_node->next = next->prev = this; }
    static list_node_base* assert_not_null( list_node_base* p ) { assert( p != 0 ); return p; }
private:
    list_node_base* prev;
    list_node_base* next;    
};

template<typeneme T>
class my_list : {
public:
    class iterator {
    public:
        iterator( list_node_base* p ) : node( p ) { assert( p != 0 ); }
        T* get_ptr() { assert( node != 0 && !node->is_along() ); return static_cast<T*>( node ); }
        T& operator*() { return get_ptr(); }
        // тут сам допишешь
    private:
        list_node_base* node;
    };
    class riterator {
        // тут сам допишешь
    };
    // константные итераторы тоже сам ;)

    iterator end() { return &list_data; }    
    iterator begin() { return list_data.get_next(); }    
    
    riterator end() { return &list_data; }    
    riterator begin() { return list_data.get_prev(); }    
private:
    class node : public list_node_base {
    public:
        T data;
    
        // тут сам допишешь
    };
    list_node_base    list_data;
};