_Node
_M_buckets.insert(_M_buckets.end(), __ht._M_buckets.size(), (_Node*) 0);
if (const _Node* __cur = __ht._M_buckets[__i]) {
_Node* ___copy = _M_new_node(__cur->_M_val);
for (_Node* __next = __cur->_M_next;
const _Node* _M_cur;
_Hashtable_const_iterator(const _Node* __n, const _Hashtable* __tab)
typename _Alloc_traits<_Node, _Alloc>::allocator_type _M_node_allocator;
_Node* _M_get_node() { return _M_node_allocator.allocate(1); }
void _M_put_node(_Node* __p) { _M_node_allocator.deallocate(__p, 1); }
_Node* _M_get_node() { return _M_node_allocator_type::allocate(1); }
void _M_put_node(_Node* __p) { _M_node_allocator_type::deallocate(__p, 1); }
vector<_Node*,_Alloc> _M_buckets;
for (_Node* __cur = _M_buckets[__bucket]; __cur; __cur = __cur->_M_next)
_Node* __first;
const _Node* __first;
for (const _Node* __cur = _M_buckets[__n]; __cur; __cur = __cur->_M_next)
_M_buckets.insert(_M_buckets.end(), __n_buckets, (_Node*) 0);
_Node* _M_new_node(const value_type& __obj)
_Node* __n = _M_get_node();
void _M_delete_node(_Node* __n)
void _M_erase_bucket(const size_type __n, _Node* __first, _Node* __last);
void _M_erase_bucket(const size_type __n, _Node* __last);
const _Node* __old = _M_cur;
const _Node* __old = _M_cur;
typedef typename hashtable<_Val,_Key,_HF,_Ex,_Eq,_All>::_Node _Node;
_Node* __cur1 = __ht1._M_buckets[__n];
_Node* __cur2 = __ht2._M_buckets[__n];
_Node* __first = _M_buckets[__n];
for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
_Node* __tmp = _M_new_node(__obj);
_Node* __first = _M_buckets[__n];
for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
_Node* __tmp = _M_new_node(__obj);
_Node* __tmp = _M_new_node(__obj);
_Node* __first = _M_buckets[__n];
for (_Node* __cur = __first; __cur; __cur = __cur->_M_next)
_Node* __tmp = _M_new_node(__obj);
for (_Node* __first = _M_buckets[__n]; __first; __first = __first->_M_next)
for (_Node* __cur = __first->_M_next; __cur; __cur = __cur->_M_next)
for (const _Node* __first = _M_buckets[__n] ;
for (const _Node* __cur = __first->_M_next;
_Node* __first = _M_buckets[__n];
_Node* __cur = __first;
_Node* __next = __cur->_M_next;
if (_Node* const __p = __it._M_cur) {
_Node* __cur = _M_buckets[__n];
_Node* __next = __cur->_M_next;
_Node* _M_cur;
erase(iterator(const_cast<_Node*>(__first._M_cur),
iterator(const_cast<_Node*>(__last._M_cur),
_Hashtable_iterator(_Node* __n, _Hashtable* __tab)
erase(iterator(const_cast<_Node*>(__it._M_cur),
vector<_Node*, _All> __tmp(__n, (_Node*)(0),
_Node* __first = _M_buckets[__bucket];
_Node* __next = __tmp[__bucket]->_M_next;
::_M_erase_bucket(const size_type __n, _Node* __first, _Node* __last)
_Node* __cur = _M_buckets[__n];
_Node* __next;
::_M_erase_bucket(const size_type __n, _Node* __last)
_Node* __cur = _M_buckets[__n];
_Node* __next = __cur->_M_next;
_Node* __cur = _M_buckets[__i];
_Node* __next = __cur->_M_next;
_Node* _M_create_node(const _Tp& __x)
_Node* __p = _M_get_node();
_Node* _M_create_node()
_Node* __p = _M_get_node();
iterator begin() { return (_Node*)(_M_node->_M_next); }
const_iterator begin() const { return (_Node*)(_M_node->_M_next); }
_Node* __tmp = _M_create_node(__x);
((_Node*) (__position._M_node->_M_prev))->_M_next = __tmp;
_Node* __next_node = (_Node*) (__position._M_node->_M_next);
_Node* __prev_node = (_Node*) (__position._M_node->_M_prev);
((_Node*) (__last._M_node->_M_prev))->_M_next = __position._M_node;
((_Node*) (__first._M_node->_M_prev))->_M_next = __last._M_node;
((_Node*) (__position._M_node->_M_prev))->_M_next = __first._M_node;
_Node* __tmp = (_Node*) (__position._M_node->_M_prev);
typedef typename list<_Tp,_Alloc>::_Node _Node;
_Node* __e1 = __x._M_node;
_Node* __e2 = __y._M_node;
_Node* __n1 = (_Node*) __e1->_M_next;
_Node* __n2 = (_Node*) __e2->_M_next;
__n1 = (_Node*) __n1->_M_next, __n2 = (_Node*) __n2->_M_next)
_Node* _M_node;
_List_iterator(_Node* __x) : _M_node(__x) {}
((_Node*) (_M_node->_M_next))->_M_next != _M_node) {
((_Node*) (_M_node->_M_next))->_M_next != _M_node) {
_M_node = (_Node*)(_M_node->_M_next);
((_Node*) (_M_node->_M_next))->_M_next != _M_node) {
_M_node = (_Node*)(_M_node->_M_prev);
_Slist_iterator(_Node* __x) : _Slist_iterator_base(__x) {}
reference operator*() const { return ((_Node*) _M_node)->_M_data; }
_Node* _M_create_node(const value_type& __x) {
_Node* __node = _M_get_node();
_Node* _M_create_node() {
_Node* __node = _M_get_node();
iterator begin() { return iterator((_Node*)_M_head._M_next); }
{ return const_iterator((_Node*)_M_head._M_next);}
reference front() { return ((_Node*) _M_head._M_next)->_M_data; }
{ return ((_Node*) _M_head._M_next)->_M_data; }
_Node* __node = (_Node*) _M_head._M_next;
return iterator((_Node*) __slist_previous(&_M_head, __pos._M_node));
return const_iterator((_Node*) __slist_previous(&_M_head, __pos._M_node));
_Node* _M_insert_after(_Node_base* __pos, const value_type& __x) {
return (_Node*) (__slist_make_link(__pos, _M_create_node(__x)));
_Node* _M_insert_after(_Node_base* __pos) {
return (_Node*) (__slist_make_link(__pos, _M_create_node()));
return iterator((_Node*) _M_erase_after(__pos._M_node));
return iterator((_Node*) _M_erase_after(__before_first._M_node,
return (_Node*) _M_erase_after(__slist_previous(&_M_head,
return (_Node*) _M_erase_after(
_Node* __n1 = (_Node*) _M_head._M_next;
const _Node* __n2 = (const _Node*) __x._M_head._M_next;
__n1 = (_Node*) __n1->_M_next;
__n2 = (const _Node*) __n2->_M_next;
_M_insert_after_range(__p1, const_iterator((_Node*)__n2),
_Node* __node = (_Node*) _M_head._M_next;
__node = (_Node*) __node->_M_next;
_Node* __node = (_Node*) _M_head._M_next;
__node = (_Node*) __node->_M_next;
typedef typename slist<_Tp,_Alloc>::_Node _Node;
_Node* __n1 = (_Node*) _SL1._M_head._M_next;
_Node* __n2 = (_Node*) _SL2._M_head._M_next;
__n1 = (_Node*) __n1->_M_next;
__n2 = (_Node*) __n2->_M_next;
if (((_Node*) __cur->_M_next)->_M_data == __val)
if (((_Node*)__cur)->_M_data ==
((_Node*)(__cur->_M_next))->_M_data)
if (((_Node*) __x._M_head._M_next)->_M_data <
((_Node*) __n1->_M_next)->_M_data)
if (__pred(((_Node*) __cur->_M_next)->_M_data))
_Node* __cur = (_Node*) _M_head._M_next;
if (__pred(((_Node*)__cur)->_M_data,
((_Node*)(__cur->_M_next))->_M_data))
__cur = (_Node*) __cur->_M_next;
if (__comp(((_Node*) __x._M_head._M_next)->_M_data,
((_Node*) __n1->_M_next)->_M_data))
media_node _Node() const;
handle._Node().node, handle.destination);
handle._Node().node, handle.source,