docs: @Override
    public void putAll(Map<? extends TypeK, ? extends TypeV> m) {
      for (Map.Entry<? extends TypeK, ? extends TypeV> e : m.entrySet())
        put(e.getKey(), e.getValue());
    }
  
    /** Removes all of the mappings from this map. */
    @Override
    public void clear() {         // Smack a new empty table down
      Object[] newkvs = new NonBlockingHashMap(MIN_SIZE)._kvs;
      while( !CAS_kvs(_kvs,newkvs) ) // Spin until the clear works
        ;
    }
  
    /** Returns <tt>true</tt> if this Map maps one or more keys to the specified
     *  value.  <em>Note</em>: This method requires a full internal traversal of the
     *  hash table and is much slower than {@link #containsKey}.
     *  @param val value whose presence in this map is to be tested
     *  @return <tt>true</tt> if this map maps one or more keys to the specified value
     *  @throws NullPointerException if the specified value is null */
    @Override
    public boolean containsValue( final Object val ) {
      if( val == null ) throw new NullPointerException();
      for( TypeV V : values() )
        if( V == val || V.equals(val) )
          return true;
      return false;
    }
  
    // This function is supposed to do something for Hashtable, and the JCK
    // tests hang until it gets called... by somebody ... for some reason,
    // any reason....
    protected void rehash() {
    }
  
    /**
     * Creates a shallow copy of this hashtable. All the structure of the
     * hashtable itself is copied, but the keys and values are not cloned.
     * This is a relatively expensive operation.
     *
     * @return  a clone of the hashtable.
     */
    @Override
    public Object clone() {
      try {
        // Must clone, to get the class right; NBHM might have been
        // extended so it would be wrong to just make a new NBHM.
        NonBlockingHashMap<TypeK,TypeV> t = (NonBlockingHashMap<TypeK,TypeV>) super.clone();
        // But I don't have an atomic clone operation - the underlying _kvs
        // structure is undergoing rapid change.  If I just clone the _kvs
        // field, the CHM in _kvs[0] won't be in sync.
        //
        // Wipe out the cloned array (it was shallow anyways).
        t.clear();
        // Now copy sanely
        for( TypeK K : keySet() ) {
          final TypeV V = get(K);  // Do an official 'get'
          t.put(K,V);
        }
        return t;
      } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError();
      }
    }
  
    /**
     * Returns a string representation of this map.  The string representation
     * consists of a list of key-value mappings in the order returned by the
     * map's <tt>entrySet</tt> view's iterator, enclosed in braces
     * (<tt>"{}"</tt>).  Adjacent mappings are separated by the characters
     * <tt>", "</tt> (comma and space).  Each key-value mapping is rendered as
     * the key followed by an equals sign (<tt>"="</tt>) followed by the
     * associated value.  Keys and values are converted to strings as by
     * {@link String#valueOf(Object)}.
     *
     * @return a string representation of this map
     */
    @Override
    public String toString() {
      Iterator<Entry<TypeK,TypeV>> i = entrySet().iterator();
      if( !i.hasNext())
        return "{}";
  
      StringBuilder sb = new StringBuilder();
      sb.append('{');
      for (;;) {
        Entry<TypeK,TypeV> e = i.next();
        TypeK key = e.getKey();
        TypeV value = e.getValue();
        sb.append(key   == this ? "(this Map)" : key);
        sb.append('=');
        sb.append(value == this ? "(this Map)" : value);
        if( !i.hasNext())
          return sb.append('}').toString();
        sb.append(", ");
      }
    }
  
    // --- keyeq ---------------------------------------------------------------
    // Check for key equality.  Try direct pointer compare first, then see if
    // the hashes are unequal (fast negative test) and finally do the full-on
    // 'equals' v-call.
    private static boolean keyeq( Object K, Object key, int[] hashes, int hash, int fullhash ) {
      return
        K==key ||                 // Either keys match exactly OR
        // hash exists and matches?  hash can be zero during the install of a
        // new key/value pair.
        ((hashes[hash] == 0 || hashes[hash] == fullhash) &&
         // Do not call the users' "equals()" call with a Tombstone, as this can
         // surprise poorly written "equals()" calls that throw exceptions
         // instead of simply returning false.
         K != TOMBSTONE &&        // Do not call users' equals call with a Tombstone
         // Do the match the hard way - with the users' key being the loop-
         // invariant "this" pointer.  I could have flipped the order of
         // operands (since equals is commutative), but I'm making mega-morphic
         // v-calls in a reprobing loop and nailing down the 'this' argument
         // gives both the JIT and the hardware a chance to prefetch the call target.
         key.equals(K));          // Finally do the hard match
    }