KeySet(NavigableMap map) 
{
 m = map;
}

 public E ceiling(E e) 
{
 return m.ceilingKey(e);
}

 public  void clear() 
{
 m.clear();
}

 public Comparator comparator() 
{
 return m.comparator();
}

 public boolean contains(Object o) 
{
 return m.containsKey(o);
}

 public Iterator descendingIterator() 
{
            if (m instanceof TreeMap)
                return ((TreeMap< E,Object >)m).descendingKeyIterator();
            else
                return (Iterator< E >)(((TreeMap.NavigableSubMap)m).descendingKeyIterator());
}

 public NavigableSet descendingSet() 
{
            return new TreeSet(m.descendingMap());
}

 public E first() 
{
 return m.firstKey();
}

 public E floor(E e) 
{
 return m.floorKey(e);
}

 public SortedSet headSet(E toElement) 
{
            return headSet(toElement, false);
}

 public NavigableSet headSet(E toElement,
    boolean inclusive) 
{
            return new TreeSet< E >(m.headMap(toElement, inclusive));
}

 public E higher(E e) 
{
 return m.higherKey(e);
}

 public boolean isEmpty() 
{
 return m.isEmpty();
}

 public Iterator iterator() 
{
            if (m instanceof TreeMap)
                return ((TreeMap< E,Object >)m).keyIterator();
            else
                return (Iterator< E >)(((TreeMap.NavigableSubMap)m).keyIterator());
}

 public E last() 
{
 return m.lastKey();
}

 public E lower(E e) 
{
 return m.lowerKey(e);
}

 public E pollFirst() 
{
            Map.Entry< E,Object > e = m.pollFirstEntry();
            return e == null? null : e.getKey();
}

 public E pollLast() 
{
            Map.Entry< E,Object > e = m.pollLastEntry();
            return e == null? null : e.getKey();
}

 public boolean remove(Object o) 
{
            int oldSize = size();
            m.remove(o);
            return size() != oldSize;
}

 public int size() 
{
 return m.size();
}

 public SortedSet subSet(E fromElement,
    E toElement) 
{
            return subSet(fromElement, true, toElement, false);
}

 public NavigableSet subSet(E fromElement,
    boolean fromInclusive,
    E toElement,
    boolean toInclusive) 
{
            return new TreeSet< E >(m.subMap(fromElement, fromInclusive,
                                           toElement,   toInclusive));
}

 public SortedSet tailSet(E fromElement) 
{
            return tailSet(fromElement, true);
}

 public NavigableSet tailSet(E fromElement,
    boolean inclusive) 
{
            return new TreeSet< E >(m.tailMap(fromElement, inclusive));
}