#include <algorithm>
#include <cstdlib>
#include <iostream>
#include <memory>
#include <utility>

namespace phundrak {

using size_type = std::size_t;

template <class T, class Allocator = std::allocator<T>> class list {

public:
  class iterator;
  class reverse_iterator;
  class const_iterator;
  class const_reverse_iterator;

private:
  // data structure ///////////////////////////////////////////////////////////

  struct cell {
    cell() = default;
    explicit cell(const T &value) : x{value} {}
    explicit cell(T &&value) : x{value} {}
    cell(const cell &other) : x{other.x}, p{other.p}, n{other.n} {}
    cell(cell &&other) {
      std::swap(x, other.x);
      std::swap(p, other.p);
      std::swap(n, other.n);
    }
    cell &operator=(const cell &other) {
      x = other.x;
      p = other.p;
      n = other.n;
      return *this;
    }
    cell &operator=(cell &&other) {
      std::swap(x, other.x);
      std::swap(n, other.n);
      std::swap(p, other.p);
      return *this;
    }
    cell *p = nullptr;
    cell *n = nullptr;
    T x = T();
  };

  // members //////////////////////////////////////////////////////////////////

  cell *sentry = new cell{};
  const Allocator alloc_ = Allocator{};

public:
  /////////////////////////////////////////////////////////////////////////////
  //                             Member functions                            //
  /////////////////////////////////////////////////////////////////////////////

  // Constructors /////////////////////////////////////////////////////////////

  list() {}

  explicit list(const Allocator &alloc) : alloc_{alloc}{
    sentry->p = sentry;
    sentry->n = sentry;
  }

  list(size_type count, const T &value, const Allocator &alloc = Allocator())
      : list{alloc} {
    while (size() < count)
      push_back(value);
  }

  explicit list(size_type count, const Allocator &alloc = Allocator())
      : list{alloc} {
    while (size() < count)
      push_back(T());
  }

  template <class InputIt>
  list(InputIt first, InputIt last, const Allocator &alloc = Allocator())
      : list{alloc} {
    for (; first != last; ++first)
      push_back(*first);
  }

  list(const list &other) : list() {
    for (auto elem : other)
      push_back(elem);
  }

  list(const list &other, const Allocator &alloc) : list(alloc) {
    for (auto elem : other)
      push_back(elem);
  }

  list(list &&other) : list() {
    std::swap(other.sentry, sentry);
    std::swap(other.alloc_, alloc_);
  }

  list(list &&other, const Allocator &alloc) : list(alloc) {
    std::swap(other.sentry, sentry);
  }

  list(std::initializer_list<T> init, const Allocator &alloc = Allocator())
      : list(alloc) {
    for (const T &elem : init)
      push_back(elem);
  }

  // Destructor ///////////////////////////////////////////////////////////////

  virtual ~list() {
    clear();
    delete sentry;
  }

  // operator= ////////////////////////////////////////////////////////////////

  list &operator=(const list &other) {
    cell *it = other.sentry->n;
    while (it != other.sentry) {
      push_back(it->x);
      it = it->n;
    }
    return *this;
  }

  list &operator=(list &&other) noexcept {
    std::swap(other.sentry, sentry);
    return *this;
  }

  list &operator=(std::initializer_list<T> ilist) {
    for (const T &elem : ilist)
      push_back(elem);
    return *this;
  }

  // Assign ///////////////////////////////////////////////////////////////////

  void assign(size_type count, const T &value) {
    clear();
    for (int i = 0; i < count; ++i)
      push_front(value);
  }

  template <class InputIt> void assign(InputIt first, InputIt last) {
    clear();
    for (; first != last; ++first)
      push_back(*first);
  }

  void assign(std::initializer_list<T> ilist) {
    clear();
    for (const T &elem : ilist)
      push_back(elem);
  }

  // get_allocator ////////////////////////////////////////////////////////////

  std::allocator<T> get_allocator() { return alloc_; }

  /////////////////////////////////////////////////////////////////////////////
  //                              Element access                             //
  /////////////////////////////////////////////////////////////////////////////

  T &front() { return sentry->n->x; }
  const T &front() const { return sentry->n->x; }

  T &back() { return sentry->p->x; }
  const T &back() const { return sentry->p->x; }

  /////////////////////////////////////////////////////////////////////////////
  //                                Iterators                                //
  /////////////////////////////////////////////////////////////////////////////

  // iterators ////////////////////////////////////////////////////////////////

  iterator begin() noexcept { return iterator{sentry->n}; }
  const_iterator begin() const noexcept { return const_iterator{sentry->n}; }
  const_iterator cbegin() const noexcept { return const_iterator{sentry->n}; }

  iterator end() noexcept { return iterator{sentry}; }
  const_iterator end() const noexcept { return const_iterator{sentry}; }
  const_iterator cend() const noexcept { return const_iterator{sentry}; }

  // reverse iterators ////////////////////////////////////////////////////////

  reverse_iterator rbegin() noexcept { return reverse_iterator{sentry->p}; }
  const_reverse_iterator rbegin() const noexcept {
    return const_reverse_iterator{sentry->p};
  }
  const_reverse_iterator crbegin() const noexcept {
    return const_reverse_iterator{sentry->p};
  }

  reverse_iterator rend() noexcept { return reverse_iterator{sentry}; }
  const_reverse_iterator rend() const noexcept {
    return const_reverse_iterator{sentry};
  }
  const_reverse_iterator crend() const noexcept {
    return const_reverse_iterator{sentry};
  }

  /////////////////////////////////////////////////////////////////////////////
  //                                 Capacity                                //
  /////////////////////////////////////////////////////////////////////////////

  bool empty() const noexcept { return sentry->p == sentry; }

  size_type size() const {
    cell *it = sentry->n;
    size_type n = 0;
    while (it != sentry) {
      ++n;
      it = it->n;
    }
    return n;
  }

  /////////////////////////////////////////////////////////////////////////////
  //                                Modifiers                                //
  /////////////////////////////////////////////////////////////////////////////

  // clear ////////////////////////////////////////////////////////////////////

  void clear() {
    cell *it = sentry->n;
    while (it != sentry) {
      cell *todel = it;
      it = it->n;
      delete todel;
    }
  }

  // insert ///////////////////////////////////////////////////////////////////

  iterator insert(const_iterator pos, const T &value) {
    cell *elem = new cell{value};
    elem->n = pos;
    elem->p = pos->p;
    pos->p->n = elem;
    pos->p = elem;
    return iterator{pos};
  }

  iterator insert(const_iterator pos, T &&value) {
    cell *elem = new cell{value};
    elem->n = pos;
    elem->p = pos->p;
    pos->p->n = elem;
    pos->p = elem;
    return iterator{pos};
  }

  template <class InputIt>
  iterator insert(const_iterator pos, InputIt first, InputIt last) {
    for (; first != last; ++first)
      insert(pos, *first);
    return iterator{pos};
  }

  // emplace //////////////////////////////////////////////////////////////////

  template <class... Args>
  iterator emplace(const_iterator pos, Args &&... args) {
    return insert(pos, T{std::forward<Args>(args)...});
  }

  // erase ////////////////////////////////////////////////////////////////////

  iterator erase(const_iterator pos) {
    pos.it->p->n = pos.it->n;
    pos.it->n->p = pos.it->p;
    pos.it->n = nullptr;
    pos.it->p = nullptr;
    cell *todel = pos.it;
    ++pos;
    delete todel;
    return pos;
  }

  iterator erase(const_iterator begin, const_iterator end) {
    while (begin != end) {
      begin = erase(begin);
    }
    return begin;
  }

  // push_back ////////////////////////////////////////////////////////////////

  void push_back(const T &v) {
    cell *c = new cell;
    c->x = v;
    c->p = sentry->p;
    c->n = sentry;
    sentry->p->n = c;
    sentry->p = c;
  }

  void push_back(T &&v) {
    cell *c = new cell;
    std::swap(c->x, v);
    c->p = sentry->p;
    c->n = sentry;
    sentry->p->n = c;
    sentry->p = c;
  }

  // emplace_back /////////////////////////////////////////////////////////////

  template <class... Args> T &emplace_back(Args &&... args) {
    emplace(begin(), args...);
    return *begin();
  }

  // pop_back /////////////////////////////////////////////////////////////////

  void pop_back() {
    cell *c = sentry->p;
    sentry->p = c->p;
    c->p->n = sentry;
    delete c;
  }

  // push_front ///////////////////////////////////////////////////////////////

  void push_front(const T &v) {
    cell *c = new cell;
    c->x = v;
    c->n = sentry->n;
    c->p = sentry;
    sentry->n->p = c;
    sentry->n = c;
  }

  void push_front(T &&value) {
    cell *c = new cell;
    std::swap(c->x, value);
    c->n = sentry->n;
    c->p = sentry;
    sentry->n->p = c;
    sentry->p = c;
  }

  // emplace_front ////////////////////////////////////////////////////////////

  template <class... Args> T &emplace_front(Args &&... args) {
    emplace(end(), args...);
    return *end();
  }

  // pop_front ////////////////////////////////////////////////////////////////

  void pop_front() {
    cell *c = sentry->n;
    sentry->n = c->n;
    c->n->p = sentry;
    delete c;
  }

  // resize ///////////////////////////////////////////////////////////////////

  void resize(size_type count) {
    if (count > size())
      while (size() < count)
        push_back(T());
    else
      while (size() > count)
        pop_back();
  }

  void resize(size_type count, const T &value) {
    if (count > size())
      while (size() < count)
        push_back(value);
    else
      while (size() > count)
        pop_back();
  }

  // swap /////////////////////////////////////////////////////////////////////

  void swap(list &other) noexcept {
    try {
      if (get_allocator() != other.get_allocator())
        throw 20;
    } catch (int e) {
      std::cout << "An error has occured: " << this << " and " << *other
                << " do not have the same allocator.\nAborting...\n";
      std::terminate();
    }
    std::swap(other.sentry, sentry);
  }

  /////////////////////////////////////////////////////////////////////////////
  //                                Operations                               //
  /////////////////////////////////////////////////////////////////////////////

  // merge ////////////////////////////////////////////////////////////////////

  void merge(list &other) {
    if (this == other)
      return;
    try {
      if (get_allocator() != other.get_allocator())
        throw 20;
    } catch (int error) {
      std::cout << "Error in void List<T>::merge(list& other): " << this
                << " and " << *other << " do not share the same allocator.\n";
    }
    sentry->p->n = other.sentry->n;
    other.sentry->n->p = sentry->p;
    other.sentry->p->n = sentry;
    sentry->p = other.sentry->p;
    other.sentry->n = other.sentry;
    other.sentry->p = other.sentry;
    std::sort(*this);
  }

  void merge(list &&other) {
    if (this == other)
      return;
    try {
      if (get_allocator() != other.get_allocator())
        throw 20;
    } catch (int error) {
      std::cout << "Error in void List<T>::merge(list &&other):\n"
                << this << " and " << *other
                << " do not share the same allocator.\n";
    }
    sentry->p->n = other.sentry->n;
    other.sentry->n->p = sentry->p;
    other.sentry->p->n = sentry;
    sentry->p = other.sentry->p;
    other.sentry->n = other.sentry;
    other.sentry->p = other.sentry;
    std::sort(*this);
  }

  template <class Compare> void merge(list &other, Compare comp) {
    if (this == other)
      return;
    try {
      if (get_allocator() != other.get_allocator())
        throw 20;
    } catch (int error) {
      std::cout << "Error in template <class Compare> void List<T>::merge(list "
                   "&other, Compare comp):\n"
                << this << " and " << *other
                << " do not share the same allocator.\n";
    }
    sentry->p->n = other.sentry->n;
    other.sentry->n->p = sentry->p;
    other.sentry->p->n = sentry;
    sentry->p = other.sentry->p;
    other.sentry->n = other.sentry;
    other.sentry->p = other.sentry;
    std::sort(*this, comp);
  }

  template <class Compare> void merge(list &&other, Compare comp) {
    if (this == other)
      return;
    try {
      if (get_allocator() != other.get_allocator())
        throw 20;
    } catch (int error) {
      std::cout << "Error in template<class Compare> void "
                   "List<T>::merge(list&& other, Compare comp):\n"
                << this << " and " << *other
                << " do not share the same allocator.\n";
    }
    sentry->p->n = other.sentry->n;
    other.sentry->n->p = sentry->p;
    other.sentry->p->n = sentry;
    sentry->p = other.sentry->p;
    other.sentry->n = other.sentry;
    other.sentry->p = other.sentry;
    std::sort(*this, comp);
  }

  // splice ///////////////////////////////////////////////////////////////////

  void splice(const_iterator pos, list &other) {
    try {
      if (get_allocator() != other.get_allocator())
        throw 20;
    } catch (int error) {
      std::cout
          << "Error in void List<T>::splice(const_iterator pos, list& other):\n"
          << this << " and " << *other << " do not share the same allocator.\n";
    }
    pos->p->n = other.sentry->n;
    other.sentry->p->n = pos;
    other.sentry->n->p = pos->p;
    pos->p = other.sentry->p;
    other.sentry->p = other.sentry;
    other.sentry->n = other.sentry;
  }

  void splice(const_iterator pos, list &&other) {
    try {
      if (get_allocator() != other.get_allocator())
        throw 20;
    } catch (int error) {
      std::cout
          << "Error in void List<T>::splice(const_iterator pos, list& other):\n"
          << this << " and " << *other << " do not share the same allocator.\n";
    }
    pos->p->n = other.sentry->n;
    other.sentry->p->n = pos;
    other.sentry->n->p = pos->p;
    pos->p = other.sentry->p;
    other.sentry->p = other.sentry;
    other.sentry->n = other.sentry;
  }

  void splice(const_iterator pos, list &other, const_iterator it) {
    try {
      if (get_allocator() != other.get_allocator())
        throw 20;
    } catch (int error) {
      std::cout
          << "Error in void List<T>::splice(const_iterator pos, list& other):\n"
          << this << " and " << *other << " do not share the same allocator.\n";
    }

    it->p->n = it->n;
    it->n->p = it->p;
    it->p = it->p;
    it->n = pos;
    pos->p->n = it;
    pos->p = it;
  }

  void splice(const_iterator pos, list &&other, const_iterator it) {
    try {
      if (get_allocator() != other.get_allocator())
        throw 20;
    } catch (int error) {
      std::cout
          << "Error in void List<T>::splice(const_iterator pos, list& other):\n"
          << this << " and " << *other << " do not share the same allocator.\n";
    }

    it->p->n = it->n;
    it->n->p = it->p;
    it->p = it->p;
    it->n = pos;
    pos->p->n = it;
    pos->p = it;
  }

  void splice(const_iterator pos, list &other, const_iterator first,
              const_iterator last) {
    try {
      if (get_allocator() != other.get_allocator())
        throw 20;
    } catch (int error) {
      std::cout
          << "Error in void List<T>::splice(const_iterator pos, list& other):\n"
          << this << " and " << *other << " do not share the same allocator.\n";
    }

    first->p->n = last;
    pos->p->n = first;
    last->p->n = pos;
    auto cell = last->p;
    last->p = first->p;
    first->p = pos->n;
    pos->n = cell;
  }

  void splice(const_iterator pos, list &&other, const_iterator first,
              const_iterator last) {
    try {
      if (get_allocator() != other.get_allocator())
        throw 20;
    } catch (int error) {
      std::cout
          << "Error in void List<T>::splice(const_iterator pos, list& other):\n"
          << this << " and " << *other << " do not share the same allocator.\n";
    }

    first->p->n = last;
    pos->p->n = first;
    last->p->n = pos;
    auto cell = last->p;
    last->p = first->p;
    first->p = pos->n;
    pos->n = cell;
  }

  // remove, remove_if ////////////////////////////////////////////////////////

  void remove(const T &value) {
    for (auto itr = begin(); itr != end(); ++itr)
      if (itr->x == value) {
        auto elem = itr;
        --itr;
        elem->p->n = elem->n;
        elem->n->p = elem->p;
        elem->n = nullptr;
        elem->p = nullptr;
        delete elem;
      }
  }

  template <class UnaryPredicate> void remove(UnaryPredicate p) {
    for (auto itr = begin(); itr != end(); ++itr) {
      if (p(*itr)) {
        auto elem = itr;
        --itr;
        elem->p->n = elem->n;
        elem->n->p = elem->p;
        elem->n = nullptr;
        elem->p = nullptr;
        delete elem;
      }
    }
  }

  // reverse //////////////////////////////////////////////////////////////////

  void reverse() noexcept {
    list<T> list{};
    while (sentry->n != sentry) {
      sentry->n->p = list.sentry->p;
      list.sentry->p->n = sentry->n;
      sentry->n->n->p = sentry;
      list.sentry->p = sentry->n;
      sentry->n = sentry->n->n;
      list.sentry->p->n = list.sentry;
    }
  }

  // unique ///////////////////////////////////////////////////////////////////

  void unique() {
    for (auto elem = sentry->n; elem->n != sentry; elem = elem->n)
      while (elem->x == elem->n->x)
        erase(const_iterator{elem->n});
  }

  template <class BinaryPredicate> void unique(BinaryPredicate p) {
    for (auto elem = sentry->n; elem->n != sentry; elem = elem->n)
      while (p(elem, elem->n))
        erase(iterator{elem->n});
  }

  /////////////////////////////////////////////////////////////////////////////
  //                              Iterator class                             //
  /////////////////////////////////////////////////////////////////////////////

  class iterator {

  protected:
    cell *it = nullptr;

  public:
    iterator() {}
    explicit iterator(cell *point) : it{point} {}

    iterator(const iterator &other) : it{other.it} {}

    iterator(iterator &&other) { std::swap(it, other.it); }

    iterator &operator=(cell *point) {
      it = point;
      return *this;
    }
    iterator &operator=(const iterator &other) {
      it = other.it;
      return *this;
    }
    iterator &operator=(iterator &&other) {
      std::swap(it, other.it);
      return *this;
    }

    ~iterator() {
      // delete it;
    }

    iterator &operator++() { // ++i
      it = it->n;
      return *this;
    }
    iterator operator++(int) { // i++
      // iterator t;
      // t.it = it;
      iterator t{*this};
      it = it->n;
      return t;
    }

    iterator &operator--() { // --i
      it = it->p;
      return *this;
    }

    iterator operator--(int) { // i--
      // iterator t;
      // t.it = it;
      iterator t{it};
      it = it->n;
      return t;
    }

    bool operator==(cell *point) { return point == it; }
    bool operator==(const iterator &other) { return other.it == it; }
    bool operator==(iterator &&other) { return other.it == it; }

    bool operator!=(cell *point) { return point != it; }
    bool operator!=(const iterator &other) { return other.it != it; }
    bool operator!=(iterator &&other) { return other.it != it; }

    T &operator*() { return it->x; }

    friend class list;
  };

  class const_iterator : public iterator {
  public:
    const_iterator() : iterator() {}
    explicit const_iterator(cell *point) : iterator{point} {}
    explicit const_iterator(const iterator &other) : iterator{other} {}
    const_iterator(const const_iterator &other) : iterator{other} {}
    explicit const_iterator(iterator &&other) : iterator{std::move(other)} {}
    const_iterator(const_iterator &&other) : iterator{std::move(other)} {}

    const T &operator*() { return this->it->x; }
  };

  class reverse_iterator : public iterator {
  public:
    reverse_iterator() : iterator() {}
    explicit reverse_iterator(cell *point) : iterator(point) {}
    reverse_iterator(const reverse_iterator &other) : iterator(other) {}
    reverse_iterator(reverse_iterator &&other) : iterator(std::move(other)) {}

    reverse_iterator &operator++() {
      this->it = this->it->p;
      return *this;
    }

    reverse_iterator operator++(int) {
      reverse_iterator t{*this};
      this->it = this->it->p;
      return t;
    }

    reverse_iterator &operator--() {
      this->it = this->it->n;
      return *this;
    }

    reverse_iterator operator--(int) {
      reverse_iterator t{*this};
      this->it = this->it->p;
      return t;
    }

    ~reverse_iterator() {}
  };

  class const_reverse_iterator : public reverse_iterator {
  public:
    const_reverse_iterator() : reverse_iterator() {}
    explicit const_reverse_iterator(cell *point) : reverse_iterator{point} {}
    explicit const_reverse_iterator(const reverse_iterator &other)
        : reverse_iterator{other} {}
    const_reverse_iterator(const const_reverse_iterator &other)
        : reverse_iterator{other} {}
    explicit const_reverse_iterator(reverse_iterator &&other)
        : reverse_iterator{other} {}
    virtual ~const_reverse_iterator() { ~reverse_iterator(); }
  };
};

} // namespace phundrak