#include<iostream.h>

// Klassen Dlist
// ur kompendiet kap.17
// bearbetad av Fredrik Larsson

const int nil = 0;

typedef int Type;


class Node {
friend class Dlist;
private:
  Type val;
  Node* next;
  Node* prev;

  Node(Type value, Node* item =  (Node*)nil) 
                      {val = value; next = item; prev = nil;}
};

class Dlist {
public:
  Type first() {return list->val;}

  void rest();

  void concat(Type);

  bool is_empty() {return (list == nil);}

  Dlist() {list = nil; now = nil;}

//  ~Dlist();

  void next_node();

  void prev_node();

  Type now_val() {return now -> val;}

  void insert(Type val);

  void del();

private:
  Node* list;
  Node* now;

  void last();
};

void Dlist::concat(Type val) {
  Node* pt = new Node(val, list);
  if (!is_empty()) list -> prev = pt;
  list = pt;
}

void Dlist::rest() {
  if (now == list) now = list -> next;
  list = list -> next;
  if (list != nil) list -> prev = nil;
}

void Dlist::next_node() {
  if (now == nil) now = list;
  else now = now -> next;
  if (now == nil) now = list;
}

void Dlist::prev_node() {
  if (now == nil) last();
  else now = now -> prev;
  if (now == nil) last();
}

void Dlist::last() {
  if (list -> next != nil) {
    for (now = list; now -> next != nil; now = now -> next);
    }
  else
    now = list;
}


void Dlist::insert(Type val) {
  if (now == nil) {
    concat(val);
    return;
  }
  if ((now -> prev) == nil) {
    concat(val);
    return;
  }
  Node* pt = new Node(val, now);
  now -> prev -> next = pt;
  pt -> prev = now ->prev;
  now -> prev = pt;
}


void Dlist::del() {
  if (now -> prev == nil) {
    rest(); now = list;
  }
  else {
    if (now -> next == nil) {
      now -> prev -> next = nil;
      Node* temp = now;
      now = now -> prev;
      delete temp;
    }
    else {
      now -> prev -> next = now -> next;
      now -> next -> prev = now -> prev;
      Node* temp = now;
      now = now -> next;
      delete temp;
    }
  }
}