public interface DLList {

   public void insertFirst (int item);
   public void insertLast (int item);
   public DLNode deleteFirst ();
   public DLNode deleteLast ();
   public int size();
   public int last ();
   public int first ();
   public boolean empty ();
   public void traverse ();

}

class DLNode {

   private int data;
   private DLNode next, prev;

   public DLNode () {
     this(0, null, null);
   }

   public DLNode (int d) {
     data = d;
     next = null;
     prev = null;
   }
  
   public DLNode (int newData, DLNode newNext, DLNode newPrev) {
     data = newData;
     next = newNext;
     prev = newPrev;
   }

   public void setData (int newData) {
     data = newData;
   }

   public void setNext (DLNode newNext) {
     next = newNext;
   } 

   public void setPrev (DLNode newPrev) {
     prev = newPrev;
   }

   public int getData () {
     return data;
   }

   public DLNode getNext () {
      return next;
   }

   public DLNode getPrev () {
      return prev;
   }

   public void displayDLNode () {
      System.out.print (data);
   }
}

class DLListADT implements DLList {

   private DLNode header;
   private DLNode trailer;
   private int size;

   /* first and last are dummy nodes that do not store
      any data */

   public DLListADT () {
     header = new DLNode();
     trailer = new DLNode();
     header.setNext(trailer);
     header.setPrev(null);
     header.setData(0);
     trailer.setPrev(header);
     trailer.setNext(null); 
     trailer.setData(0);
     size = 0;
   }

   public boolean empty () {
     return (size == 0);
   }

   public int size () {
      return size;
   }     

   public void insertFirst (int newData) {     
      DLNode oldFirst = header.getNext(); 
      DLNode newFirst = new DLNode (newData, oldFirst, header);
      oldFirst.setPrev(newFirst);
      header.setNext(newFirst);
      size++;
   }

   public void insertLast (int newData) {
      DLNode oldLast = trailer.getPrev(); 
      DLNode newLast = new DLNode (newData, trailer, oldLast);
      oldLast.setNext(newLast);
      trailer.setPrev(newLast);
      size++;
   }

   public DLNode deleteFirst () {
      DLNode oldFirst = header.getNext();
      DLNode newFirst = oldFirst.getNext();
      newFirst.setPrev(header);
      header.setNext(newFirst);
      size--;
      return oldFirst;
   }

   public DLNode deleteLast () {
      DLNode oldLast = trailer.getPrev();
      DLNode newLast = oldLast.getPrev();
      trailer.setPrev(newLast);
      newLast.setNext(trailer);
      size--;
      return oldLast;
   }

   public int last () {
      return (trailer.getPrev().getData());
   }

   public int first () {
      return (header.getNext().getData());
   }

   public boolean search (int key) {
      boolean result = false;
      DLNode current = header.getNext();
      while (current != trailer) {
         if (current.getData () == key) {
            result = true;
            return result;
         }
         else
            current = current.getNext();
      }
      return result;
   }   
      
   public void traverse () {
      System.out.print ("Current list: ");
      DLNode current = header.getNext();
      while (current != trailer) {
         current.displayDLNode ();
         System.out.print ("   ");
         current = current.getNext();
      }
      System.out.println ();
   }
}         

class DLListex1 {

   public static void main (String[] args) {

     DLListADT list1 = new DLListADT ();

     for (int i = 1; i <= 10; i++) {
        list1.insertFirst(i);
        list1.traverse();    
     }

     System.out.println ("Number of nodes on the list: " + list1.size());
     
     System.out.println ("Search for 6: " + list1.search(6));
     System.out.println ("Search for 12: " + list1.search(12));
     System.out.println ("The last datum in the list is " + list1.last());
     System.out.println ("The first datum in the list is " + list1.first());

     for (int i = 1; i <= 10; i++) {
        list1.deleteFirst();
        list1.traverse();
     } 

   }
}