KeySet(ConcurrentNavigableMap 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() 
{
            return descendingSet().iterator();
}

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

 public boolean equals(Object o) 
{
            if (o == this)
                return true;
            if (!(o instanceof Set))
                return false;
            Collection< ? > c = (Collection< ? >) o;
            try {
                return containsAll(c) && c.containsAll(this);
            } catch (ClassCastException unused)   {
                return false;
            } catch (NullPointerException unused) {
                return false;
            }
}

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

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

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

 public NavigableSet headSet(E toElement,
    boolean inclusive) 
{
            return new ConcurrentSkipListSet< 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 ConcurrentSkipListMap)
                return ((ConcurrentSkipListMap< E,Object >)m).keyIterator();
            else
                return ((ConcurrentSkipListMap.SubMap< E,Object >)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) 
{
 return m.remove(o) != null;
}

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

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

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

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

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

 public Object[] toArray() 
{
 return toList(this).toArray();
}

 public T[] toArray(T[] a) 
{
 return toList(this).toArray(a);
}