import java.util.Vector;
import java.util.Iterator;

abstract class Node {
   Node parent;
   Object data;
   public Node(Object d, Node n) {
      data = d;
      parent = n;
   }
   public void setParent(Node n) { parent = n; }
   public void setData(Object o) { data = o; }
   public Node getParent() { return parent; }
   public Object getData() { return data; }
   public abstract Iterator children();
}

abstract class Tree {
   protected Node root;
   protected int size;
   public Tree() {root = null; size = 0;}
   public Node root() {return root;}
   public Node parent(Node v) {return v.getParent();}
   public Iterator children(Node v) {return v.children();}
   public boolean isRoot(Node v) { return v == root;}
   public boolean isInternal(Node v) {
      return children(v).hasNext();
   }
   public boolean isLeaf(Node v) {
      return !isInternal(v);
   }
   public int size() {
      return size;
   }
   public boolean empty() {
      return size == 0;
   }
   public void replace(Node v, Object o){
      v.setData(o);
   }
   public int depth(Node v) {
      int d = 0;
      while (!isRoot(v)) {
         v = parent(v);
         d++;
      }
      return d;
   }
   public int height(Node v) {
      if (isLeaf(v)) return 0;
      int maxChild = 0;
      Iterator c = children(v);
      while (c.hasNext()) {
         int hc = height((Node) c.next());
         if (hc > maxChild) maxChild = hc; 
      }
      return maxChild + 1;
   }
   public int height() {
      if (root == null) return -1;
      return height(root);
   }
   public Vector preOrder() {
      Vector answer = new Vector();
      preOrder(root(), answer);
      return answer;
   }
   public void preOrder(Node n, Vector v) {
      if (n == null) return;
      v.add(n);
      Iterator x = children(n);
      while (x.hasNext()) {
         Node m = (Node) x.next();
         preOrder(m, v);
      }
   }
   public Vector postOrder() {
      Vector answer = new Vector();
      postOrder(root(), answer);
      return answer;
   }
   public void postOrder(Node n, Vector v) {
      if (n == null) return;
      Iterator x = children(n);
      while (x.hasNext()) {
         Node m = (Node) x.next();
         postOrder(m, v);
      }
      v.add(n);
   }
   public Vector levelOrder() {
      Vector waiting = new Vector();
      waiting.add("\n");
      if (root() == null) return waiting;
      waiting.add(root());
      int done = 0;
      while (done < waiting.size()) {
         Object o = waiting.get(done++);
         if (o.equals("\n")) {
            if (done < waiting.size()) waiting.add("\n");
            continue;
         }
         Node n = (Node) o;
         Iterator c = children(n);
         while (c.hasNext()) waiting.add(c.next());
      }
      return waiting;
   }
   public Vector flatOrder() {
      return preOrder();
   }
   public String treePrint() {
      return treePrint(null);
   }
   public String treePrint(Node cursor) {
      String answer = "";
      Iterator lev = levelOrder().iterator();
      Iterator flat = flatOrder().iterator();
      lev.next();  // skip first new line
      while (lev.hasNext()) {
         Object o = lev.next();
         if (o.equals("\n")) {
            answer += "\n";
            flat=flatOrder().iterator();
         }
         else while (true) {
            boolean atCursor = false;
            Node n = (Node) flat.next();
            if (n == cursor) atCursor = true;
            String s = (String) n.getData();
            if (atCursor) s = "* " + s + " *";
            if (n == o) {
               answer += s;
               break;
            }
            else for (int i = 0; i < s.length(); i++) answer += ' ';
         }
      }
      return answer;
   }
}