.        */       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_set.       size_type       bucket_count() const noexcept       { return _M_h.bucket_count(); }        /// Returns the maximum number of buckets of the %unordered_set.       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_set tries to keep the       /// load factor less than or equal to.       float       max_load_factor() const noexcept       { return _M_h.max_load_factor(); }        /**        *  @brief  Change the %unordered_set maximum load factor.        *  @param  __z The new maximum load factor.        */       void       max_load_factor(float __z)       { _M_h.max_load_factor(__z); }        /**        *  @brief  May rehash the %unordered_set.        *  @param  __n The new number of buckets.        *        *  Rehash will occur only if the new number of buckets respect the        *  %unordered_set maximum load factor.        */       void       rehash(size_type __n)       { _M_h.rehash(__n); }        /**        *  @brief  Prepare the %unordered_set for a specified number of        *          elements.        *  @param  __n Number of elements required.        *        *  Same as rehash(ceil(n / max_load_factor())).        */       void       reserve(size_type __n)       { _M_h.reserve(__n); }        template<typename _Value0, typename _Hash0, typename _Pred0,         typename _Alloc0>         friend bool       operator==(const unordered_set<_Value0, _Hash0, _Pred0, _Alloc0>&,    const unordered_set<_Value0, _Hash0, _Pred0, _Alloc0>&);     };    /**    *  @brief A standard container composed of 