class BinaryTree<T> {
    private T value;
    private BinaryTree<T> left;
    private BinaryTree<T> right;
    
    public BinaryTree(T value) {
	this.value = value;
	this.left = null;
	this.right = null;
    }

    public BinaryTree(T value, BinaryTree<T> left, BinaryTree<T> right) {
	this.value = value;
	this.left = left;
	this.right = right;
    }

    public void setLeft(BinaryTree<T> left) {
	this.left = left;
    }

    public void setRight(BinaryTree<T> right) {
	this.right = right;
    }

    public void setValue(T value) {
	this.value = value;
    }

    public T getValue() {
	return value;
    }

    public BinaryTree<T> getLeft() {
	return left;
    }

    public BinaryTree<T> getRight() {
	return right;
    }

    /**
     * Computes the (edge) height.
     * Note that this is an instance method, so
     * it must have an instance of BinaryTree<T>,
     * which complicates the implementation.
     */
    public int getHeight() {
	if (left == null && right == null) {
	    return 0;
        } else if (left == null) {
	    return 1 + right.getHeight();
	} else if (right == null) {
	    return 1 + left.getHeight();
	} else {
	    return 1 + Math.max(left.getHeight(), right.getHeight());
	}
    }

    /**
     * Computes the (edge) height.
     * Note that this is a static method.  Since
     * it can always check that root == null directly,
     * the implementation matches the simple recursive
     * height definition shown in class.
     */
    public static <E> int getHeight(BinaryTree<E> root) {
	if (root == null) {
	    return -1;
	} else {
	    return 1 + Math.max(getHeight(root.getLeft()), getHeight(root.getRight()));
	}
    }
}