set of the same element and allocator        *  types.        *        *  This exchanges the elements between two sets in constant time.        *  Note that the global std::swap() function is specialized such that        *  std::swap(s0,s0) will feed to this function.        */       void       swap(unordered_set& __x)       { _M_h.swap(__x._M_h); }        // observers.        ///  Returns the hash functor object with which the %unordered_set was       ///  constructed.       hasher       hash_function() const       { return _M_h.hash_function(); }        ///  Returns the key comparison object with which the %unordered_set was       ///  constructed.       key_equal       key_eq() const       { return _M_h.key_eq(); }        // lookup.        //@{       /**        *  @brief Tries to locate an element in an %unordered_set.        *  @param  __x  Element to be located.        *  @return  Iterator pointing to sought-after element, or end() if not        *           found.        *        *  This function takes a key and tries to locate the element with which        *  the key matches.  If successful the function returns an iterator        *  pointing to the sought after element.  If unsuccessful it returns the        *  past-the-end ( @c end() ) iterator.        */       iterator       find(const key_type& __x)       { return _M_h.find(__x); }        const_iterator       find(const key_type& __x) const       { return _M_h.find(__x); }       //@}        /**        *  @brief  Finds the number of elements.        *  @param  __x  Element to located.        *  @return  Number of elements with specified key.        *