Cider Isn't Darwin Emulation, Really
Something went wrong. Try again.
54 kB · 1350 lines
1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253545556575859606162636465666768697071727374757677787980818283848586878889909192939495969798991001011021031041051061071081091101111121131141151161171181191201211221231241251261271281291301311321331341351361371381391401411421431441451461471481491501511521531541551561571581591601611621631641651661671681691701711721731741751761771781791801811821831841851861871881891901911921931941951961971981992002012022032042052062072082092102112122132142152162172182192202212222232242252262272282292302312322332342352362372382392402412422432442452462472482492502512522532542552562572582592602612622632642652662672682692702712722732742752762772782792802812822832842852862872882892902912922932942952962972982993003013023033043053063073083093103113123133143153163173183193203213223233243253263273283293303313323333343353363373383393403413423433443453463473483493503513523533543553563573583593603613623633643653663673683693703713723733743753763773783793803813823833843853863873883893903913923933943953963973983994004014024034044054064074084094104114124134144154164174184194204214224234244254264274284294304314324334344354364374384394404414424434444454464474484494504514524534544554564574584594604614624634644654664674684694704714724734744754764774784794804814824834844854864874884894904914924934944954964974984995005015025035045055065075085095105115125135145155165175185195205215225235245255265275285295305315325335345355365375385395405415425435445455465475485495505515525535545555565575585595605615625635645655665675685695705715725735745755765775785795805815825835845855865875885895905915925935945955965975985996006016026036046056066076086096106116126136146156166176186196206216226236246256266276286296306316326336346356366376386396406416426436446456466476486496506516526536546556566576586596606616626636646656666676686696706716726736746756766776786796806816826836846856866876886896906916926936946956966976986997007017027037047057067077087097107117127137147157167177187197207217227237247257267277287297307317327337347357367377387397407417427437447457467477487497507517527537547557567577587597607617627637647657667677687697707717727737747757767777787797807817827837847857867877887897907917927937947957967977987998008018028038048058068078088098108118128138148158168178188198208218228238248258268278288298308318328338348358368378388398408418428438448458468478488498508518528538548558568578588598608618628638648658668678688698708718728738748758768778788798808818828838848858868878888898908918928938948958968978988999009019029039049059069079089099109119129139149159169179189199209219229239249259269279289299309319329339349359369379389399409419429439449459469479489499509519529539549559569579589599609619629639649659669679689699709719729739749759769779789799809819829839849859869879889899909919929939949959969979989991000100110021003100410051006100710081009101010111012101310141015101610171018101910201021102210231024102510261027102810291030103110321033103410351036103710381039104010411042104310441045104610471048104910501051105210531054105510561057105810591060106110621063106410651066106710681069107010711072107310741075107610771078107910801081108210831084108510861087108810891090109110921093109410951096109710981099110011011102110311041105110611071108110911101111111211131114111511161117111811191120112111221123112411251126112711281129113011311132113311341135113611371138113911401141114211431144114511461147114811491150115111521153115411551156115711581159116011611162116311641165116611671168116911701171117211731174117511761177117811791180118111821183118411851186118711881189119011911192119311941195119611971198119912001201120212031204120512061207120812091210121112121213121412151216121712181219122012211222122312241225122612271228122912301231123212331234123512361237123812391240124112421243124412451246124712481249125012511252125312541255125612571258125912601261126212631264126512661267126812691270127112721273127412751276127712781279128012811282128312841285128612871288128912901291129212931294129512961297129812991300130113021303130413051306130713081309131013111312131313141315131613171318131913201321132213231324132513261327132813291330133113321333133413351336133713381339134013411342134313441345134613471348134913501351// -*- C++ -*-//===-------------------------- unordered_set -----------------------------===////// The LLVM Compiler Infrastructure//// This file is dual licensed under the MIT and the University of Illinois Open// Source Licenses. See LICENSE.TXT for details.////===----------------------------------------------------------------------===//#ifndef _LIBCPP_UNORDERED_SET#define _LIBCPP_UNORDERED_SET/* unordered_set synopsis#include <initializer_list>namespace std{template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, class Alloc = allocator<Value>>class unordered_set{public: // types typedef Value key_type; typedef key_type value_type; typedef Hash hasher; typedef Pred key_equal; typedef Alloc allocator_type; typedef value_type& reference; typedef const value_type& const_reference; typedef typename allocator_traits<allocator_type>::pointer pointer; typedef typename allocator_traits<allocator_type>::const_pointer const_pointer; typedef typename allocator_traits<allocator_type>::size_type size_type; typedef typename allocator_traits<allocator_type>::difference_type difference_type; typedef /unspecified/ iterator; typedef /unspecified/ const_iterator; typedef /unspecified/ local_iterator; typedef /unspecified/ const_local_iterator; unordered_set() noexcept( is_nothrow_default_constructible<hasher>::value && is_nothrow_default_constructible<key_equal>::value && is_nothrow_default_constructible<allocator_type>::value); explicit unordered_set(size_type n, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); template <class InputIterator> unordered_set(InputIterator f, InputIterator l, size_type n = 0, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); explicit unordered_set(const allocator_type&); unordered_set(const unordered_set&); unordered_set(const unordered_set&, const Allocator&); unordered_set(unordered_set&&) noexcept( is_nothrow_move_constructible<hasher>::value && is_nothrow_move_constructible<key_equal>::value && is_nothrow_move_constructible<allocator_type>::value); unordered_set(unordered_set&&, const Allocator&); unordered_set(initializer_list<value_type>, size_type n = 0, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); unordered_set(size_type n, const allocator_type& a); // C++14 unordered_set(size_type n, const hasher& hf, const allocator_type& a); // C++14 template <class InputIterator> unordered_set(InputIterator f, InputIterator l, size_type n, const allocator_type& a); // C++14 template <class InputIterator> unordered_set(InputIterator f, InputIterator l, size_type n, const hasher& hf, const allocator_type& a); // C++14 unordered_set(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14 unordered_set(initializer_list<value_type> il, size_type n, const hasher& hf, const allocator_type& a); // C++14 ~unordered_set(); unordered_set& operator=(const unordered_set&); unordered_set& operator=(unordered_set&&) noexcept( allocator_type::propagate_on_container_move_assignment::value && is_nothrow_move_assignable<allocator_type>::value && is_nothrow_move_assignable<hasher>::value && is_nothrow_move_assignable<key_equal>::value); unordered_set& operator=(initializer_list<value_type>); allocator_type get_allocator() const noexcept; bool empty() const noexcept; size_type size() const noexcept; size_type max_size() const noexcept; iterator begin() noexcept; iterator end() noexcept; const_iterator begin() const noexcept; const_iterator end() const noexcept; const_iterator cbegin() const noexcept; const_iterator cend() const noexcept; template <class... Args> pair<iterator, bool> emplace(Args&&... args); template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args); pair<iterator, bool> insert(const value_type& obj); pair<iterator, bool> insert(value_type&& obj); iterator insert(const_iterator hint, const value_type& obj); iterator insert(const_iterator hint, value_type&& obj); template <class InputIterator> void insert(InputIterator first, InputIterator last); void insert(initializer_list<value_type>); iterator erase(const_iterator position); iterator erase(iterator position); // C++14 size_type erase(const key_type& k); iterator erase(const_iterator first, const_iterator last); void clear() noexcept; void swap(unordered_set&) noexcept(allocator_traits<Allocator>::is_always_equal::value && noexcept(swap(declval<hasher&>(), declval<hasher&>())) && noexcept(swap(declval<key_equal&>(), declval<key_equal&>()))); // C++17 hasher hash_function() const; key_equal key_eq() const; iterator find(const key_type& k); const_iterator find(const key_type& k) const; size_type count(const key_type& k) const; pair<iterator, iterator> equal_range(const key_type& k); pair<const_iterator, const_iterator> equal_range(const key_type& k) const; size_type bucket_count() const noexcept; size_type max_bucket_count() const noexcept; size_type bucket_size(size_type n) const; size_type bucket(const key_type& k) const; local_iterator begin(size_type n); local_iterator end(size_type n); const_local_iterator begin(size_type n) const; const_local_iterator end(size_type n) const; const_local_iterator cbegin(size_type n) const; const_local_iterator cend(size_type n) const; float load_factor() const noexcept; float max_load_factor() const noexcept; void max_load_factor(float z); void rehash(size_type n); void reserve(size_type n);};template <class Value, class Hash, class Pred, class Alloc> void swap(unordered_set<Value, Hash, Pred, Alloc>& x, unordered_set<Value, Hash, Pred, Alloc>& y) noexcept(noexcept(x.swap(y)));template <class Value, class Hash, class Pred, class Alloc> bool operator==(const unordered_set<Value, Hash, Pred, Alloc>& x, const unordered_set<Value, Hash, Pred, Alloc>& y);template <class Value, class Hash, class Pred, class Alloc> bool operator!=(const unordered_set<Value, Hash, Pred, Alloc>& x, const unordered_set<Value, Hash, Pred, Alloc>& y);template <class Value, class Hash = hash<Value>, class Pred = equal_to<Value>, class Alloc = allocator<Value>>class unordered_multiset{public: // types typedef Value key_type; typedef key_type value_type; typedef Hash hasher; typedef Pred key_equal; typedef Alloc allocator_type; typedef value_type& reference; typedef const value_type& const_reference; typedef typename allocator_traits<allocator_type>::pointer pointer; typedef typename allocator_traits<allocator_type>::const_pointer const_pointer; typedef typename allocator_traits<allocator_type>::size_type size_type; typedef typename allocator_traits<allocator_type>::difference_type difference_type; typedef /unspecified/ iterator; typedef /unspecified/ const_iterator; typedef /unspecified/ local_iterator; typedef /unspecified/ const_local_iterator; unordered_multiset() noexcept( is_nothrow_default_constructible<hasher>::value && is_nothrow_default_constructible<key_equal>::value && is_nothrow_default_constructible<allocator_type>::value); explicit unordered_multiset(size_type n, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); template <class InputIterator> unordered_multiset(InputIterator f, InputIterator l, size_type n = 0, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); explicit unordered_multiset(const allocator_type&); unordered_multiset(const unordered_multiset&); unordered_multiset(const unordered_multiset&, const Allocator&); unordered_multiset(unordered_multiset&&) noexcept( is_nothrow_move_constructible<hasher>::value && is_nothrow_move_constructible<key_equal>::value && is_nothrow_move_constructible<allocator_type>::value); unordered_multiset(unordered_multiset&&, const Allocator&); unordered_multiset(initializer_list<value_type>, size_type n = /see below/, const hasher& hf = hasher(), const key_equal& eql = key_equal(), const allocator_type& a = allocator_type()); unordered_multiset(size_type n, const allocator_type& a); // C++14 unordered_multiset(size_type n, const hasher& hf, const allocator_type& a); // C++14 template <class InputIterator> unordered_multiset(InputIterator f, InputIterator l, size_type n, const allocator_type& a); // C++14 template <class InputIterator> unordered_multiset(InputIterator f, InputIterator l, size_type n, const hasher& hf, const allocator_type& a); // C++14 unordered_multiset(initializer_list<value_type> il, size_type n, const allocator_type& a); // C++14 unordered_multiset(initializer_list<value_type> il, size_type n, const hasher& hf, const allocator_type& a); // C++14 ~unordered_multiset(); unordered_multiset& operator=(const unordered_multiset&); unordered_multiset& operator=(unordered_multiset&&) noexcept( allocator_type::propagate_on_container_move_assignment::value && is_nothrow_move_assignable<allocator_type>::value && is_nothrow_move_assignable<hasher>::value && is_nothrow_move_assignable<key_equal>::value); unordered_multiset& operator=(initializer_list<value_type>); allocator_type get_allocator() const noexcept; bool empty() const noexcept; size_type size() const noexcept; size_type max_size() const noexcept; iterator begin() noexcept; iterator end() noexcept; const_iterator begin() const noexcept; const_iterator end() const noexcept; const_iterator cbegin() const noexcept; const_iterator cend() const noexcept; template <class... Args> iterator emplace(Args&&... args); template <class... Args> iterator emplace_hint(const_iterator position, Args&&... args); iterator insert(const value_type& obj); iterator insert(value_type&& obj); iterator insert(const_iterator hint, const value_type& obj); iterator insert(const_iterator hint, value_type&& obj); template <class InputIterator> void insert(InputIterator first, InputIterator last); void insert(initializer_list<value_type>); iterator erase(const_iterator position); iterator erase(iterator position); // C++14 size_type erase(const key_type& k); iterator erase(const_iterator first, const_iterator last); void clear() noexcept; void swap(unordered_multiset&) noexcept(allocator_traits<Allocator>::is_always_equal::value && noexcept(swap(declval<hasher&>(), declval<hasher&>())) && noexcept(swap(declval<key_equal&>(), declval<key_equal&>()))); // C++17 hasher hash_function() const; key_equal key_eq() const; iterator find(const key_type& k); const_iterator find(const key_type& k) const; size_type count(const key_type& k) const; pair<iterator, iterator> equal_range(const key_type& k); pair<const_iterator, const_iterator> equal_range(const key_type& k) const; size_type bucket_count() const noexcept; size_type max_bucket_count() const noexcept; size_type bucket_size(size_type n) const; size_type bucket(const key_type& k) const; local_iterator begin(size_type n); local_iterator end(size_type n); const_local_iterator begin(size_type n) const; const_local_iterator end(size_type n) const; const_local_iterator cbegin(size_type n) const; const_local_iterator cend(size_type n) const; float load_factor() const noexcept; float max_load_factor() const noexcept; void max_load_factor(float z); void rehash(size_type n); void reserve(size_type n);};template <class Value, class Hash, class Pred, class Alloc> void swap(unordered_multiset<Value, Hash, Pred, Alloc>& x, unordered_multiset<Value, Hash, Pred, Alloc>& y) noexcept(noexcept(x.swap(y)));template <class Value, class Hash, class Pred, class Alloc> bool operator==(const unordered_multiset<Value, Hash, Pred, Alloc>& x, const unordered_multiset<Value, Hash, Pred, Alloc>& y);template <class Value, class Hash, class Pred, class Alloc> bool operator!=(const unordered_multiset<Value, Hash, Pred, Alloc>& x, const unordered_multiset<Value, Hash, Pred, Alloc>& y);} // std*/#include <__config>#include <__hash_table>#include <functional>#include <__debug>#if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)#pragma GCC system_header#endif_LIBCPP_BEGIN_NAMESPACE_STDtemplate <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, class _Alloc = allocator<_Value> >class _LIBCPP_TEMPLATE_VIS unordered_set{public: // types typedef _Value key_type; typedef key_type value_type; typedef _Hash hasher; typedef _Pred key_equal; typedef _Alloc allocator_type; typedef value_type& reference; typedef const value_type& const_reference; static_assert((is_same<value_type, typename allocator_type::value_type>::value), "Invalid allocator::value_type");private: typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table; __table __table_;public: typedef typename __table::pointer pointer; typedef typename __table::const_pointer const_pointer; typedef typename __table::size_type size_type; typedef typename __table::difference_type difference_type; typedef typename __table::const_iterator iterator; typedef typename __table::const_iterator const_iterator; typedef typename __table::const_local_iterator local_iterator; typedef typename __table::const_local_iterator const_local_iterator; _LIBCPP_INLINE_VISIBILITY unordered_set() _NOEXCEPT_(is_nothrow_default_constructible<__table>::value) {#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif } explicit unordered_set(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal());#if _LIBCPP_STD_VER > 11 inline _LIBCPP_INLINE_VISIBILITY unordered_set(size_type __n, const allocator_type& __a) : unordered_set(__n, hasher(), key_equal(), __a) {} inline _LIBCPP_INLINE_VISIBILITY unordered_set(size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_set(__n, __hf, key_equal(), __a) {}#endif unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a); template <class _InputIterator> unordered_set(_InputIterator __first, _InputIterator __last); template <class _InputIterator> unordered_set(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal()); template <class _InputIterator> unordered_set(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);#if _LIBCPP_STD_VER > 11 template <class _InputIterator> inline _LIBCPP_INLINE_VISIBILITY unordered_set(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) : unordered_set(__first, __last, __n, hasher(), key_equal(), __a) {} template <class _InputIterator> unordered_set(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_set(__first, __last, __n, __hf, key_equal(), __a) {}#endif _LIBCPP_INLINE_VISIBILITY explicit unordered_set(const allocator_type& __a); unordered_set(const unordered_set& __u); unordered_set(const unordered_set& __u, const allocator_type& __a);#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY unordered_set(unordered_set&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value); unordered_set(unordered_set&& __u, const allocator_type& __a); unordered_set(initializer_list<value_type> __il); unordered_set(initializer_list<value_type> __il, size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal()); unordered_set(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);#if _LIBCPP_STD_VER > 11 inline _LIBCPP_INLINE_VISIBILITY unordered_set(initializer_list<value_type> __il, size_type __n, const allocator_type& __a) : unordered_set(__il, __n, hasher(), key_equal(), __a) {} inline _LIBCPP_INLINE_VISIBILITY unordered_set(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_set(__il, __n, __hf, key_equal(), __a) {}#endif#endif // _LIBCPP_CXX03_LANG // ~unordered_set() = default; _LIBCPP_INLINE_VISIBILITY unordered_set& operator=(const unordered_set& __u) { __table_ = __u.__table_; return *this; }#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY unordered_set& operator=(unordered_set&& __u) _NOEXCEPT_(is_nothrow_move_assignable<__table>::value); _LIBCPP_INLINE_VISIBILITY unordered_set& operator=(initializer_list<value_type> __il);#endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY allocator_type get_allocator() const _NOEXCEPT {return allocator_type(__table_.__node_alloc());} _LIBCPP_INLINE_VISIBILITY bool empty() const _NOEXCEPT {return __table_.size() == 0;} _LIBCPP_INLINE_VISIBILITY size_type size() const _NOEXCEPT {return __table_.size();} _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT {return __table_.max_size();} _LIBCPP_INLINE_VISIBILITY iterator begin() _NOEXCEPT {return __table_.begin();} _LIBCPP_INLINE_VISIBILITY iterator end() _NOEXCEPT {return __table_.end();} _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT {return __table_.begin();} _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT {return __table_.end();} _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const _NOEXCEPT {return __table_.begin();} _LIBCPP_INLINE_VISIBILITY const_iterator cend() const _NOEXCEPT {return __table_.end();}#ifndef _LIBCPP_CXX03_LANG template <class... _Args> _LIBCPP_INLINE_VISIBILITY pair<iterator, bool> emplace(_Args&&... __args) {return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...);} template <class... _Args> _LIBCPP_INLINE_VISIBILITY#if _LIBCPP_DEBUG_LEVEL >= 2 iterator emplace_hint(const_iterator __p, _Args&&... __args) { _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, "unordered_set::emplace_hint(const_iterator, args...) called with an iterator not" " referring to this unordered_set"); return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first; }#else iterator emplace_hint(const_iterator, _Args&&... __args) {return __table_.__emplace_unique(_VSTD::forward<_Args>(__args)...).first;}#endif _LIBCPP_INLINE_VISIBILITY pair<iterator, bool> insert(value_type&& __x) {return __table_.__insert_unique(_VSTD::move(__x));} _LIBCPP_INLINE_VISIBILITY#if _LIBCPP_DEBUG_LEVEL >= 2 iterator insert(const_iterator __p, value_type&& __x) { _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, "unordered_set::insert(const_iterator, value_type&&) called with an iterator not" " referring to this unordered_set"); return insert(_VSTD::move(__x)).first; }#else iterator insert(const_iterator, value_type&& __x) {return insert(_VSTD::move(__x)).first;}#endif _LIBCPP_INLINE_VISIBILITY void insert(initializer_list<value_type> __il) {insert(__il.begin(), __il.end());}#endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY pair<iterator, bool> insert(const value_type& __x) {return __table_.__insert_unique(__x);} _LIBCPP_INLINE_VISIBILITY#if _LIBCPP_DEBUG_LEVEL >= 2 iterator insert(const_iterator __p, const value_type& __x) { _LIBCPP_ASSERT(__get_const_db()->__find_c_from_i(&__p) == this, "unordered_set::insert(const_iterator, const value_type&) called with an iterator not" " referring to this unordered_set"); return insert(__x).first; }#else iterator insert(const_iterator, const value_type& __x) {return insert(__x).first;}#endif template <class _InputIterator> _LIBCPP_INLINE_VISIBILITY void insert(_InputIterator __first, _InputIterator __last); _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __p) {return __table_.erase(__p);} _LIBCPP_INLINE_VISIBILITY size_type erase(const key_type& __k) {return __table_.__erase_unique(__k);} _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __first, const_iterator __last) {return __table_.erase(__first, __last);} _LIBCPP_INLINE_VISIBILITY void clear() _NOEXCEPT {__table_.clear();} _LIBCPP_INLINE_VISIBILITY void swap(unordered_set& __u) _NOEXCEPT_(__is_nothrow_swappable<__table>::value) {__table_.swap(__u.__table_);} _LIBCPP_INLINE_VISIBILITY hasher hash_function() const {return __table_.hash_function();} _LIBCPP_INLINE_VISIBILITY key_equal key_eq() const {return __table_.key_eq();} _LIBCPP_INLINE_VISIBILITY iterator find(const key_type& __k) {return __table_.find(__k);} _LIBCPP_INLINE_VISIBILITY const_iterator find(const key_type& __k) const {return __table_.find(__k);} _LIBCPP_INLINE_VISIBILITY size_type count(const key_type& __k) const {return __table_.__count_unique(__k);} _LIBCPP_INLINE_VISIBILITY pair<iterator, iterator> equal_range(const key_type& __k) {return __table_.__equal_range_unique(__k);} _LIBCPP_INLINE_VISIBILITY pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {return __table_.__equal_range_unique(__k);} _LIBCPP_INLINE_VISIBILITY size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();} _LIBCPP_INLINE_VISIBILITY size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();} _LIBCPP_INLINE_VISIBILITY size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);} _LIBCPP_INLINE_VISIBILITY size_type bucket(const key_type& __k) const {return __table_.bucket(__k);} _LIBCPP_INLINE_VISIBILITY local_iterator begin(size_type __n) {return __table_.begin(__n);} _LIBCPP_INLINE_VISIBILITY local_iterator end(size_type __n) {return __table_.end(__n);} _LIBCPP_INLINE_VISIBILITY const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);} _LIBCPP_INLINE_VISIBILITY const_local_iterator end(size_type __n) const {return __table_.cend(__n);} _LIBCPP_INLINE_VISIBILITY const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);} _LIBCPP_INLINE_VISIBILITY const_local_iterator cend(size_type __n) const {return __table_.cend(__n);} _LIBCPP_INLINE_VISIBILITY float load_factor() const _NOEXCEPT {return __table_.load_factor();} _LIBCPP_INLINE_VISIBILITY float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();} _LIBCPP_INLINE_VISIBILITY void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);} _LIBCPP_INLINE_VISIBILITY void rehash(size_type __n) {__table_.rehash(__n);} _LIBCPP_INLINE_VISIBILITY void reserve(size_type __n) {__table_.reserve(__n);}#if _LIBCPP_DEBUG_LEVEL >= 2 bool __dereferenceable(const const_iterator* __i) const {return __table_.__dereferenceable(__i);} bool __decrementable(const const_iterator* __i) const {return __table_.__decrementable(__i);} bool __addable(const const_iterator* __i, ptrdiff_t __n) const {return __table_.__addable(__i, __n);} bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const {return __table_.__addable(__i, __n);}#endif // _LIBCPP_DEBUG_LEVEL >= 2};template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql) : __table_(__hf, __eql){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__n);}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a) : __table_(__hf, __eql, __a){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__n);}template <class _Value, class _Hash, class _Pred, class _Alloc>template <class _InputIterator>unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( _InputIterator __first, _InputIterator __last){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif insert(__first, __last);}template <class _Value, class _Hash, class _Pred, class _Alloc>template <class _InputIterator>unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql) : __table_(__hf, __eql){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__n); insert(__first, __last);}template <class _Value, class _Hash, class _Pred, class _Alloc>template <class _InputIterator>unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a) : __table_(__hf, __eql, __a){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__n); insert(__first, __last);}template <class _Value, class _Hash, class _Pred, class _Alloc>inlineunordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( const allocator_type& __a) : __table_(__a){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( const unordered_set& __u) : __table_(__u.__table_){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__u.bucket_count()); insert(__u.begin(), __u.end());}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( const unordered_set& __u, const allocator_type& __a) : __table_(__u.__table_, __a){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__u.bucket_count()); insert(__u.begin(), __u.end());}#ifndef _LIBCPP_CXX03_LANGtemplate <class _Value, class _Hash, class _Pred, class _Alloc>inlineunordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( unordered_set&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value) : __table_(_VSTD::move(__u.__table_)){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); __get_db()->swap(this, &__u);#endif}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( unordered_set&& __u, const allocator_type& __a) : __table_(_VSTD::move(__u.__table_), __a){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif if (__a != __u.get_allocator()) { iterator __i = __u.begin(); while (__u.size() != 0) __table_.__insert_unique(_VSTD::move(__u.__table_.remove(__i++)->__value_)); }#if _LIBCPP_DEBUG_LEVEL >= 2 else __get_db()->swap(this, &__u);#endif}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( initializer_list<value_type> __il){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif insert(__il.begin(), __il.end());}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( initializer_list<value_type> __il, size_type __n, const hasher& __hf, const key_equal& __eql) : __table_(__hf, __eql){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__n); insert(__il.begin(), __il.end());}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_set<_Value, _Hash, _Pred, _Alloc>::unordered_set( initializer_list<value_type> __il, size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a) : __table_(__hf, __eql, __a){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__n); insert(__il.begin(), __il.end());}template <class _Value, class _Hash, class _Pred, class _Alloc>inlineunordered_set<_Value, _Hash, _Pred, _Alloc>&unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=(unordered_set&& __u) _NOEXCEPT_(is_nothrow_move_assignable<__table>::value){ __table_ = _VSTD::move(__u.__table_); return *this;}template <class _Value, class _Hash, class _Pred, class _Alloc>inlineunordered_set<_Value, _Hash, _Pred, _Alloc>&unordered_set<_Value, _Hash, _Pred, _Alloc>::operator=( initializer_list<value_type> __il){ __table_.__assign_unique(__il.begin(), __il.end()); return *this;}#endif // _LIBCPP_CXX03_LANGtemplate <class _Value, class _Hash, class _Pred, class _Alloc>template <class _InputIterator>inlinevoidunordered_set<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, _InputIterator __last){ for (; __first != __last; ++__first) __table_.__insert_unique(*__first);}template <class _Value, class _Hash, class _Pred, class _Alloc>inline _LIBCPP_INLINE_VISIBILITYvoidswap(unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, unordered_set<_Value, _Hash, _Pred, _Alloc>& __y) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))){ __x.swap(__y);}template <class _Value, class _Hash, class _Pred, class _Alloc>booloperator==(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y){ if (__x.size() != __y.size()) return false; typedef typename unordered_set<_Value, _Hash, _Pred, _Alloc>::const_iterator const_iterator; for (const_iterator __i = __x.begin(), __ex = __x.end(), __ey = __y.end(); __i != __ex; ++__i) { const_iterator __j = __y.find(*__i); if (__j == __ey || !(*__i == *__j)) return false; } return true;}template <class _Value, class _Hash, class _Pred, class _Alloc>inline _LIBCPP_INLINE_VISIBILITYbooloperator!=(const unordered_set<_Value, _Hash, _Pred, _Alloc>& __x, const unordered_set<_Value, _Hash, _Pred, _Alloc>& __y){ return !(__x == __y);}template <class _Value, class _Hash = hash<_Value>, class _Pred = equal_to<_Value>, class _Alloc = allocator<_Value> >class _LIBCPP_TEMPLATE_VIS unordered_multiset{public: // types typedef _Value key_type; typedef key_type value_type; typedef _Hash hasher; typedef _Pred key_equal; typedef _Alloc allocator_type; typedef value_type& reference; typedef const value_type& const_reference; static_assert((is_same<value_type, typename allocator_type::value_type>::value), "Invalid allocator::value_type");private: typedef __hash_table<value_type, hasher, key_equal, allocator_type> __table; __table __table_;public: typedef typename __table::pointer pointer; typedef typename __table::const_pointer const_pointer; typedef typename __table::size_type size_type; typedef typename __table::difference_type difference_type; typedef typename __table::const_iterator iterator; typedef typename __table::const_iterator const_iterator; typedef typename __table::const_local_iterator local_iterator; typedef typename __table::const_local_iterator const_local_iterator; _LIBCPP_INLINE_VISIBILITY unordered_multiset() _NOEXCEPT_(is_nothrow_default_constructible<__table>::value) {#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif } explicit unordered_multiset(size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal()); unordered_multiset(size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);#if _LIBCPP_STD_VER > 11 inline _LIBCPP_INLINE_VISIBILITY unordered_multiset(size_type __n, const allocator_type& __a) : unordered_multiset(__n, hasher(), key_equal(), __a) {} inline _LIBCPP_INLINE_VISIBILITY unordered_multiset(size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multiset(__n, __hf, key_equal(), __a) {}#endif template <class _InputIterator> unordered_multiset(_InputIterator __first, _InputIterator __last); template <class _InputIterator> unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal()); template <class _InputIterator> unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n , const hasher& __hf, const key_equal& __eql, const allocator_type& __a);#if _LIBCPP_STD_VER > 11 template <class _InputIterator> inline _LIBCPP_INLINE_VISIBILITY unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n, const allocator_type& __a) : unordered_multiset(__first, __last, __n, hasher(), key_equal(), __a) {} template <class _InputIterator> inline _LIBCPP_INLINE_VISIBILITY unordered_multiset(_InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multiset(__first, __last, __n, __hf, key_equal(), __a) {}#endif _LIBCPP_INLINE_VISIBILITY explicit unordered_multiset(const allocator_type& __a); unordered_multiset(const unordered_multiset& __u); unordered_multiset(const unordered_multiset& __u, const allocator_type& __a);#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY unordered_multiset(unordered_multiset&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value); unordered_multiset(unordered_multiset&& __u, const allocator_type& __a); unordered_multiset(initializer_list<value_type> __il); unordered_multiset(initializer_list<value_type> __il, size_type __n, const hasher& __hf = hasher(), const key_equal& __eql = key_equal()); unordered_multiset(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a);#if _LIBCPP_STD_VER > 11 inline _LIBCPP_INLINE_VISIBILITY unordered_multiset(initializer_list<value_type> __il, size_type __n, const allocator_type& __a) : unordered_multiset(__il, __n, hasher(), key_equal(), __a) {} inline _LIBCPP_INLINE_VISIBILITY unordered_multiset(initializer_list<value_type> __il, size_type __n, const hasher& __hf, const allocator_type& __a) : unordered_multiset(__il, __n, __hf, key_equal(), __a) {}#endif#endif // _LIBCPP_CXX03_LANG // ~unordered_multiset() = default; _LIBCPP_INLINE_VISIBILITY unordered_multiset& operator=(const unordered_multiset& __u) { __table_ = __u.__table_; return *this; }#ifndef _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY unordered_multiset& operator=(unordered_multiset&& __u) _NOEXCEPT_(is_nothrow_move_assignable<__table>::value); unordered_multiset& operator=(initializer_list<value_type> __il);#endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY allocator_type get_allocator() const _NOEXCEPT {return allocator_type(__table_.__node_alloc());} _LIBCPP_INLINE_VISIBILITY bool empty() const _NOEXCEPT {return __table_.size() == 0;} _LIBCPP_INLINE_VISIBILITY size_type size() const _NOEXCEPT {return __table_.size();} _LIBCPP_INLINE_VISIBILITY size_type max_size() const _NOEXCEPT {return __table_.max_size();} _LIBCPP_INLINE_VISIBILITY iterator begin() _NOEXCEPT {return __table_.begin();} _LIBCPP_INLINE_VISIBILITY iterator end() _NOEXCEPT {return __table_.end();} _LIBCPP_INLINE_VISIBILITY const_iterator begin() const _NOEXCEPT {return __table_.begin();} _LIBCPP_INLINE_VISIBILITY const_iterator end() const _NOEXCEPT {return __table_.end();} _LIBCPP_INLINE_VISIBILITY const_iterator cbegin() const _NOEXCEPT {return __table_.begin();} _LIBCPP_INLINE_VISIBILITY const_iterator cend() const _NOEXCEPT {return __table_.end();}#ifndef _LIBCPP_CXX03_LANG template <class... _Args> _LIBCPP_INLINE_VISIBILITY iterator emplace(_Args&&... __args) {return __table_.__emplace_multi(_VSTD::forward<_Args>(__args)...);} template <class... _Args> _LIBCPP_INLINE_VISIBILITY iterator emplace_hint(const_iterator __p, _Args&&... __args) {return __table_.__emplace_hint_multi(__p, _VSTD::forward<_Args>(__args)...);} _LIBCPP_INLINE_VISIBILITY iterator insert(value_type&& __x) {return __table_.__insert_multi(_VSTD::move(__x));} _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __p, value_type&& __x) {return __table_.__insert_multi(__p, _VSTD::move(__x));} _LIBCPP_INLINE_VISIBILITY void insert(initializer_list<value_type> __il) {insert(__il.begin(), __il.end());}#endif // _LIBCPP_CXX03_LANG _LIBCPP_INLINE_VISIBILITY iterator insert(const value_type& __x) {return __table_.__insert_multi(__x);} _LIBCPP_INLINE_VISIBILITY iterator insert(const_iterator __p, const value_type& __x) {return __table_.__insert_multi(__p, __x);} template <class _InputIterator> _LIBCPP_INLINE_VISIBILITY void insert(_InputIterator __first, _InputIterator __last); _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __p) {return __table_.erase(__p);} _LIBCPP_INLINE_VISIBILITY size_type erase(const key_type& __k) {return __table_.__erase_multi(__k);} _LIBCPP_INLINE_VISIBILITY iterator erase(const_iterator __first, const_iterator __last) {return __table_.erase(__first, __last);} _LIBCPP_INLINE_VISIBILITY void clear() _NOEXCEPT {__table_.clear();} _LIBCPP_INLINE_VISIBILITY void swap(unordered_multiset& __u) _NOEXCEPT_(__is_nothrow_swappable<__table>::value) {__table_.swap(__u.__table_);} _LIBCPP_INLINE_VISIBILITY hasher hash_function() const {return __table_.hash_function();} _LIBCPP_INLINE_VISIBILITY key_equal key_eq() const {return __table_.key_eq();} _LIBCPP_INLINE_VISIBILITY iterator find(const key_type& __k) {return __table_.find(__k);} _LIBCPP_INLINE_VISIBILITY const_iterator find(const key_type& __k) const {return __table_.find(__k);} _LIBCPP_INLINE_VISIBILITY size_type count(const key_type& __k) const {return __table_.__count_multi(__k);} _LIBCPP_INLINE_VISIBILITY pair<iterator, iterator> equal_range(const key_type& __k) {return __table_.__equal_range_multi(__k);} _LIBCPP_INLINE_VISIBILITY pair<const_iterator, const_iterator> equal_range(const key_type& __k) const {return __table_.__equal_range_multi(__k);} _LIBCPP_INLINE_VISIBILITY size_type bucket_count() const _NOEXCEPT {return __table_.bucket_count();} _LIBCPP_INLINE_VISIBILITY size_type max_bucket_count() const _NOEXCEPT {return __table_.max_bucket_count();} _LIBCPP_INLINE_VISIBILITY size_type bucket_size(size_type __n) const {return __table_.bucket_size(__n);} _LIBCPP_INLINE_VISIBILITY size_type bucket(const key_type& __k) const {return __table_.bucket(__k);} _LIBCPP_INLINE_VISIBILITY local_iterator begin(size_type __n) {return __table_.begin(__n);} _LIBCPP_INLINE_VISIBILITY local_iterator end(size_type __n) {return __table_.end(__n);} _LIBCPP_INLINE_VISIBILITY const_local_iterator begin(size_type __n) const {return __table_.cbegin(__n);} _LIBCPP_INLINE_VISIBILITY const_local_iterator end(size_type __n) const {return __table_.cend(__n);} _LIBCPP_INLINE_VISIBILITY const_local_iterator cbegin(size_type __n) const {return __table_.cbegin(__n);} _LIBCPP_INLINE_VISIBILITY const_local_iterator cend(size_type __n) const {return __table_.cend(__n);} _LIBCPP_INLINE_VISIBILITY float load_factor() const _NOEXCEPT {return __table_.load_factor();} _LIBCPP_INLINE_VISIBILITY float max_load_factor() const _NOEXCEPT {return __table_.max_load_factor();} _LIBCPP_INLINE_VISIBILITY void max_load_factor(float __mlf) {__table_.max_load_factor(__mlf);} _LIBCPP_INLINE_VISIBILITY void rehash(size_type __n) {__table_.rehash(__n);} _LIBCPP_INLINE_VISIBILITY void reserve(size_type __n) {__table_.reserve(__n);}#if _LIBCPP_DEBUG_LEVEL >= 2 bool __dereferenceable(const const_iterator* __i) const {return __table_.__dereferenceable(__i);} bool __decrementable(const const_iterator* __i) const {return __table_.__decrementable(__i);} bool __addable(const const_iterator* __i, ptrdiff_t __n) const {return __table_.__addable(__i, __n);} bool __subscriptable(const const_iterator* __i, ptrdiff_t __n) const {return __table_.__addable(__i, __n);}#endif // _LIBCPP_DEBUG_LEVEL >= 2};template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( size_type __n, const hasher& __hf, const key_equal& __eql) : __table_(__hf, __eql){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__n);}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a) : __table_(__hf, __eql, __a){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__n);}template <class _Value, class _Hash, class _Pred, class _Alloc>template <class _InputIterator>unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( _InputIterator __first, _InputIterator __last){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif insert(__first, __last);}template <class _Value, class _Hash, class _Pred, class _Alloc>template <class _InputIterator>unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql) : __table_(__hf, __eql){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__n); insert(__first, __last);}template <class _Value, class _Hash, class _Pred, class _Alloc>template <class _InputIterator>unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( _InputIterator __first, _InputIterator __last, size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a) : __table_(__hf, __eql, __a){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__n); insert(__first, __last);}template <class _Value, class _Hash, class _Pred, class _Alloc>inlineunordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( const allocator_type& __a) : __table_(__a){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( const unordered_multiset& __u) : __table_(__u.__table_){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__u.bucket_count()); insert(__u.begin(), __u.end());}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( const unordered_multiset& __u, const allocator_type& __a) : __table_(__u.__table_, __a){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__u.bucket_count()); insert(__u.begin(), __u.end());}#ifndef _LIBCPP_CXX03_LANGtemplate <class _Value, class _Hash, class _Pred, class _Alloc>inlineunordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( unordered_multiset&& __u) _NOEXCEPT_(is_nothrow_move_constructible<__table>::value) : __table_(_VSTD::move(__u.__table_)){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this); __get_db()->swap(this, &__u);#endif}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( unordered_multiset&& __u, const allocator_type& __a) : __table_(_VSTD::move(__u.__table_), __a){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif if (__a != __u.get_allocator()) { iterator __i = __u.begin(); while (__u.size() != 0) __table_.__insert_multi(_VSTD::move(__u.__table_.remove(__i++)->__value_)); }#if _LIBCPP_DEBUG_LEVEL >= 2 else __get_db()->swap(this, &__u);#endif}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( initializer_list<value_type> __il){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif insert(__il.begin(), __il.end());}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( initializer_list<value_type> __il, size_type __n, const hasher& __hf, const key_equal& __eql) : __table_(__hf, __eql){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__n); insert(__il.begin(), __il.end());}template <class _Value, class _Hash, class _Pred, class _Alloc>unordered_multiset<_Value, _Hash, _Pred, _Alloc>::unordered_multiset( initializer_list<value_type> __il, size_type __n, const hasher& __hf, const key_equal& __eql, const allocator_type& __a) : __table_(__hf, __eql, __a){#if _LIBCPP_DEBUG_LEVEL >= 2 __get_db()->__insert_c(this);#endif __table_.rehash(__n); insert(__il.begin(), __il.end());}template <class _Value, class _Hash, class _Pred, class _Alloc>inlineunordered_multiset<_Value, _Hash, _Pred, _Alloc>&unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=( unordered_multiset&& __u) _NOEXCEPT_(is_nothrow_move_assignable<__table>::value){ __table_ = _VSTD::move(__u.__table_); return *this;}template <class _Value, class _Hash, class _Pred, class _Alloc>inlineunordered_multiset<_Value, _Hash, _Pred, _Alloc>&unordered_multiset<_Value, _Hash, _Pred, _Alloc>::operator=( initializer_list<value_type> __il){ __table_.__assign_multi(__il.begin(), __il.end()); return *this;}#endif // _LIBCPP_CXX03_LANGtemplate <class _Value, class _Hash, class _Pred, class _Alloc>template <class _InputIterator>inlinevoidunordered_multiset<_Value, _Hash, _Pred, _Alloc>::insert(_InputIterator __first, _InputIterator __last){ for (; __first != __last; ++__first) __table_.__insert_multi(*__first);}template <class _Value, class _Hash, class _Pred, class _Alloc>inline _LIBCPP_INLINE_VISIBILITYvoidswap(unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y) _NOEXCEPT_(_NOEXCEPT_(__x.swap(__y))){ __x.swap(__y);}template <class _Value, class _Hash, class _Pred, class _Alloc>booloperator==(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y){ if (__x.size() != __y.size()) return false; typedef typename unordered_multiset<_Value, _Hash, _Pred, _Alloc>::const_iterator const_iterator; typedef pair<const_iterator, const_iterator> _EqRng; for (const_iterator __i = __x.begin(), __ex = __x.end(); __i != __ex;) { _EqRng __xeq = __x.equal_range(*__i); _EqRng __yeq = __y.equal_range(*__i); if (_VSTD::distance(__xeq.first, __xeq.second) != _VSTD::distance(__yeq.first, __yeq.second) || !_VSTD::is_permutation(__xeq.first, __xeq.second, __yeq.first)) return false; __i = __xeq.second; } return true;}template <class _Value, class _Hash, class _Pred, class _Alloc>inline _LIBCPP_INLINE_VISIBILITYbooloperator!=(const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __x, const unordered_multiset<_Value, _Hash, _Pred, _Alloc>& __y){ return !(__x == __y);}_LIBCPP_END_NAMESPACE_STD#endif // _LIBCPP_UNORDERED_SET