#include <iostream>
#include <vector>
#include <deque>
#include <algorithm>
#include <iomanip>
#include <math.h>
#include <set>
#include <utility>
#include <map>
#include <string>
#include <exception>
#include <stddef.h>
#include <memory>
#include <list>

using namespace std;

template <typename T>
class Value;

template<typename T>
class LIterator {
public:
    Value<T>* cur;
    LIterator<T>() {
    }
    LIterator<T>(Value<T> * new_cur) {
        cur = new_cur;
    }
    LIterator<T>& operator++() {
        cur = cur->next;
    }
    const T operator*() const {
        return *cur->field;
    }
    bool operator== (const LIterator<T>& other) {
        return cur == other.cur;
    }
    bool operator != (const LIterator<T>& other) {
        return !(*this == other);
    }
};

template <typename T>
class Value{
public:
    T* field = nullptr;
    struct Value* next = nullptr;
    struct Value* prev = nullptr;
    Value<T>() {
        cout << "default constructor\n";
    }
    ~Value() {
        cout << "here\n";
    }
};

template <typename T>
class List{
public:
    Value<T>* fir;
    Value<T>* last;
    int sz = 0;
    List<T>() {
        fir = new Value<T>;
        last = new Value<T>;
        last->prev = fir;
        fir->next = last;
        cout << "List default constructor\n";
    }
    int size() const {
        return sz;
    }
    void push_back(const T& new_val) {
        if (sz == 0) {
            last->field = new T(new_val);
            ++sz;
            return;
        }
        //sz = 0
        ++sz;
        Value<T>* cur = new Value<T>;
        cur->field = new T(new_val);
        cur->prev = &(*last);
        last->next = cur;
        last = last->next;
    }
    void pop_back() {
        //sz = 0
        --sz;
        delete last->field;
        delete last->next;
        last = last->prev;
        last->next->prev = nullptr;
        delete last->next->prev;
        last->next = nullptr;
    }
    void push_front(const T& new_val) {
        //sz = 0
        if (sz == 0) {
            fir->field = new T(new_val);
            ++sz;
            return;
        }
        ++sz;
        Value<T> cur;
        *cur.field = new_val;
        cur.next = &(*fir);
        (*fir).prev = &cur;
        fir = fir->prev;
    }
    void pop_front() {
        //sz = 0
        --sz;
        delete fir->field;
        delete fir->prev;
        fir = fir->next;
        fir->prev->next = nullptr;
        delete fir->prev->next;
        fir->prev = nullptr;
    }
    LIterator<T> begin() {
        if (fir->field == nullptr) {
            return LIterator<T>(fir->next);
        } else {
            return LIterator<T>(fir);
        }
    }
    LIterator<T> end() {
        if (last->field == nullptr) {
            return LIterator<T>(last->prev);
        } else {
            push_back(T());
            return LIterator<T>(last);
        }
    }
    ~List() {
//        delete fir;
//        delete last;
    }
};