#include<memory>

template <typename T>
class List {
public:
    class ListNode {
    public:

        ListNode() {
            next = nullptr;
            prev = nullptr;
        }

        ListNode(const ListNode& rhs) {
            next = rhs.next;
            prev = rhs.prev;
            value = rhs.value;
        }

        ListNode(ListNode&& rhs) {
            next = rhs.next;
            prev = rhs.prev;
            rhs.next = nullptr;
            rhs.prev = nullptr;
            value = rhs.value;
        }

        ListNode* prev;
        ListNode* next;
        T* value;
    };

    class Iterator {
    public:

        Iterator() {
            node = std::make_shared<ListNode>(new ListNode());
        }

        Iterator& operator++() {
            node = node->next;
        }
        Iterator operator++(int) {
            node = node -> next;
        }

        Iterator& operator--() {
            node = node -> prev;
        }
        Iterator operator--(int) {
            node = node -> prev;
        }

        T& operator*() const { ///////////////////////////////////////////////////////
            return *(this->node->value);
        }
        T* operator->() const {
            return this->node->value;
        }

        bool operator==(const Iterator& rhs) const {
            return (node == rhs.node);
        }
        bool operator!=(const Iterator& rhs) const {
            return  (node != rhs.node);
        }

        std::shared_ptr<ListNode> node;
    };

    void Unlink(ListNode* node) {
        if(node->prev)
            node->prev->next = node->next;
        if(node->next)
            node->next->prev = node->prev;
    }

    void LinkAfter(ListNode* target, ListNode* after) {
        if(target->next)
            target->next->prev = after;
        target->next = after;
        after->next = target->next;
        after->prev = target;
    }

    void init() {
        begin = std::make_shared<Iterator>(new Iterator());
        end = std::make_shared<Iterator>(new Iterator());
        size = 0;
    }

    List() {
        init();
    }

    List(const List& list) {
        init();
        Iterator beg = list.Begin();
        Iterator finish = list.End();
        while(beg != finish) {
            LinkAfter(end.get()->node.get(), beg->node);
            size++;
            beg++;
        }
    }

    List(List&& list) noexcept {
        init();
        Iterator beg = list.Begin();
        Iterator finish = list.End();
        begin = beg.node;
        beg.node.reset();
        end = finish.node;
        finish.node.reset();
        size = list.Size();
        list.size = 0;
    }
    ~List();

    List& operator=(const List& list);
    List& operator=(List&& list);

    bool IsEmpty() const {
        return size == 0;
    }

    size_t Size() const {
        return size;
    }

    void PushBack(const T& elem);
    void PushBack(T&& elem);
    void PushFront(const T& elem);
    void PushFront(T&& elem);

    T& Front();
    const T& Front() const;
    T& Back();
    const T& Back() const;

    void PopBack();
    void PopFront();

    Iterator Begin() const{
        return *(begin.get());
    }
    Iterator End() const{
        return *(end.get());
    }
    size_t size;
private:
    std::shared_ptr<Iterator> begin;
    std::shared_ptr<Iterator> end;
};

template <typename T>
typename List<T>::Iterator begin(List<T>& list);

template <typename T>
typename List<T>::Iterator end(List<T>& list);

int main() {
    List<int> a;
    return 0;
}