set& __x)       { _M_h.swap(__x._M_h); }        // observers.        ///  Returns the hash functor object with which the %unordered_multiset       ///  was constructed.       hasher       hash_function() const       { return _M_h.hash_function(); }        ///  Returns the key comparison object with which the %unordered_multiset       ///  was constructed.       key_equal       key_eq() const       { return _M_h.key_eq(); }        // lookup.        //@{       /**        *  @brief Tries to locate an element in an %unordered_multiset.        *  @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.        */       size_type       count(const key_type& __x) const       { return _M_h.count(__x); }        //@{       /**        *  @brief Finds a subsequence matching given key.        *  @param  __x  Key to be located.        *  @return  Pair of iterators that possibly points to the subsequence        *           matching given key.        */       std::pair<iterator, iterator>       equal_range(const key_type& __x)       { return _M_h.equal_range(__x); }        std::pair<const_iterator, const_iterator>       equal_range(const key_type& __x) const       { return _M_h.equal_range(__x); }       //@}        // bucket interface.        /// Returns the number of buckets of the %unordered_multiset.       size_type       bucket_count() const noexcept       { return _M_h.bucket_count(); }        /// Returns the maximum number of buckets of the %unordered_multiset.       size_type       max_bucket_count() const noexcept       { return _M_h.max_bucket_count(); }        /*        * @brief  Returns the number of elements in a given bucket.        * @param  __n  A bucket index.        * @return  The number of elements in the bucket.        */       size_type       bucket_size(size_type __n) const       { return _M_h.bucket_size(__n); }        /*        * @brief  Returns the bucket index of a given element.        * @param  __key  A key instance.        * @return  The key bucket index.        */       size_type       bucket(const key_type& __key) const       { return _M_h.bucket(__key); }        //@{       /**        *  @brief  Returns a read-only (constant) iterator pointing to the first        *         bucket element.        *  @param  __n The bucket index.        *  @return  A read-only local iterator.        */       local_iterator       begin(size_type __n)       { return _M_h.begin(__n); }        const_local_iterator       begin(size_type __n) const       { return _M_h.begin(__n); }        const_local_iterator       cbegin(size_type __n) const       { return _M_h.cbegin(__n); }       //@}        //@{       /**        *  @brief  Returns a read-only (constant) iterator pointing to one past        *         the last bucket elements.        *  @param  __n The bucket index.        *  @return  A read-only local iterator.        */       local_iterator       end(size_type __n)       { return _M_h.end(__n); }        const_local_iterator       end(size_type __n) const       { return _M_h.end(__n); }        const_local_iterator       cend(size_type __n) const       { return _M_h.cend(__n); }       //@}        // hash policy.        /// Returns the average number of elements per bucket.       float       load_factor() const noexcept       { return _M_h.load_factor(); }        /// Returns a positive number that the %unordered_