interface Comparable<A> {
  boolean less(A x);
}

interface Set<A implements Comparable<A>> {
  boolean contains(A x);
  Set<A> include(A x);
}

class ComparableString implements Comparable<ComparableString> {
  private String s;
  ComparableString(String s) { this.s = s; }
  public boolean less(ComparableString other) {
    return s.compareTo(other.s) < 0;
  }
}

abstract class Tree<A implements Comparable<A>>
implements Set<A> {
  public abstract boolean contains(A x);
  public abstract Tree<A> insert (A x);
  
  public Set<A> include(A x) {
    return insert(x);
  }
}

class EmptyTree<A implements Comparable<A>> extends Tree<A> {
  public boolean contains(A x) {
    return false;
  }
  public Tree<A> insert(A x) {
    return new Branch(x, this, this);
  }
}

class Branch<A implements Comparable<A>> extends Tree<A> {
  A elem;
  Tree<A> left;
  Tree<A> right;
  
  public Branch(A elem, Tree<A> left, Tree<A> right) {
    this.elem = elem;
    this.left = left;
    this.right = right;
  }
  
  public boolean contains(A x) {
    if (x.less(elem)) 
      return left.contains(x);
    else if (elem.less(x))
      return right.contains(x);
    else // we assume total ordering, therefore x.equals(elem)
      return true;
  }
  
  public Tree<A> insert(A x) {
    if (x.less(elem)) 
      return new Branch(elem, left.insert(x), right);
    else if (elem.less(x))
      return new Branch(elem, left, right.insert(x));
    else // we assume total ordering, therefore x.equals(elem)
      return this;
  }
}


public class TestForDuplicates {

  public static void main(String[] args) {
    Set<ComparableString> set = new EmptyTree();
    for (int i = 1; i < args.length; i++)
      set.include(new ComparableString(args[i]));
    System.out.println(
       set.contains(new ComparableString(args[0])));
  }
}

class TreeUtils {
  static <A implements Comparable<A>> Tree<A> insertArray(Tree<A> tree, A[] elems) {
    for (int i = 0; i < elems.length; i++)
      tree = tree.insert(elems[i]);
    return tree;
  }
}