Index: /trunk/nv/stl/container/hash_table.hh
===================================================================
--- /trunk/nv/stl/container/hash_table.hh	(revision 403)
+++ /trunk/nv/stl/container/hash_table.hh	(revision 404)
@@ -171,4 +171,31 @@
 		}
 
+ 		hash_table_storage( const hash_table_storage& ) = delete;
+ 		hash_table_storage& operator=( const hash_table_storage& ) = delete;
+
+		inline hash_table_storage( hash_table_storage&& other )
+			: m_buckets( other.m_buckets )
+			, m_bucket_count( other.m_bucket_count )
+			, m_element_count( other.m_element_count )
+			, m_max_load_factor( other.m_max_load_factor )
+		{
+			other.m_buckets = nullptr;
+			other.m_bucket_count = 0;
+			other.m_element_count = 0;
+		}
+		inline hash_table_storage& operator=( hash_table_storage&& other )
+		{
+			if ( this != &other )
+			{
+				free_nodes( m_buckets, m_bucket_count );
+				free_buckets( m_buckets, m_bucket_count );
+				m_buckets         = other.m_buckets;
+				m_bucket_count    = other.m_bucket_count;
+				m_element_count   = other.m_element_count;
+				m_max_load_factor = other.max_load_factor;
+			}
+			return *this;
+		}
+
 		iterator erase( const_iterator which )
 		{
@@ -247,8 +274,8 @@
 
 		template < typename... Args >
-		iterator insert( size_type index, Args&&... args )
+		iterator insert( size_type index, hash_type hash_code, Args&&... args )
 		{
 			node_type* node = alloc_node();
-			base_type::entry_construct( node, nv::forward<Args>( args )... );
+			base_type::entry_construct( node, hash_code, nv::forward<Args>( args )... );
 			node->next = m_buckets[index];
 			m_buckets[index] = node;
@@ -420,5 +447,5 @@
 			const hash_type c = base_type::get_hash( key );
 			size_type       b = base_type::get_bucket_index( c );
-			return do_find_node( b, key, c );
+			return do_find_node( b, c, key );
 		}
 		const_iterator find( const key_type& key ) const
@@ -426,20 +453,40 @@
 			const hash_type c = base_type::get_hash( key );
 			size_type       b = base_type::get_bucket_index( c );
-			return do_find_node( b, key, c );
-		}
-
-		inline insert_return_type insert( const value_type& value )
+			return do_find_node( b, c, key );
+		}
+
+// TODO: implement
+// 		template< typename... Args >
+// 		insert_return_type emplace( Args&&... args )
+// 		{
+// 
+// 		}
+
+		inline insert_return_type insert( value_type&& value )
 		{
 			const hash_type h = base_type::get_value_hash( value );
 			size_type       b = base_type::get_bucket_index( h );
-			iterator        r = do_find_node( b, value, h );
+			iterator        r = do_find_node( b, h, value );
 
 			if ( r == this->end() )
 			{
-				if ( base_type::rehash_check( 1 ) )
-				{
-					b = base_type::get_bucket_index( h );
-				}
-				return insert_return_type( base_type::insert( b, value, h ), true );
+				if ( base_type::rehash_check( 1 ) ) b = base_type::get_bucket_index( h );
+				return insert_return_type( base_type::insert( b, h, nv::forward( value ) ), true );
+			}
+
+			return insert_return_type( r, false );
+		}
+
+
+		inline insert_return_type insert( const value_type& value )
+		{
+			const hash_type h = base_type::get_value_hash( value );
+			size_type       b = base_type::get_bucket_index( h );
+			iterator        r = do_find_node( b, h, value );
+
+			if ( r == this->end() )
+			{
+				if ( base_type::rehash_check( 1 ) ) b = base_type::get_bucket_index( h );
+				return insert_return_type( base_type::insert( b, h, value ), true );
 			}
 
@@ -473,5 +520,5 @@
 			while ( i != this->cend( b ) )
 			{
-				if ( base_type::entry_compare( i.entry(), key, c ) )
+				if ( base_type::entry_compare( i.entry(), c, key ) )
 				{
 					i = base_type::erase_local( b, i );
@@ -490,13 +537,10 @@
 			const hash_type h = base_type::get_hash( key );
 			size_type       b = base_type::get_bucket_index( h );
-			iterator        r = do_find_node( b, key, h );
+			iterator        r = do_find_node( b, h, key );
 
 			if ( r == this->end() )
 			{
-				if ( base_type::rehash_check( 1 ) )
-				{
-					b = base_type::get_bucket_index( h );
-				}
-				return insert_return_type( base_type::insert( b, value_type( key ), h ), true );
+				if ( base_type::rehash_check( 1 ) ) b = base_type::get_bucket_index( h );
+				return insert_return_type( base_type::insert( b, h, key ), true );
 			}
 
@@ -505,5 +549,5 @@
 
 		template < typename ComparableType >
-		iterator do_find_node( size_type index, const ComparableType& query, hash_type h ) const
+		iterator do_find_node( size_type index, hash_type h, const ComparableType& query ) const
 		{
 			const_local_iterator first = this->cbegin( index );
@@ -511,5 +555,5 @@
 			while ( first != last )
 			{
-				if ( base_type::entry_compare( first.entry(), query, h ) )
+				if ( base_type::entry_compare( first.entry(), h, query ) )
 					return base_type::unlocalize( index, first );
 				++first;
Index: /trunk/nv/stl/container/hash_table_policy.hh
===================================================================
--- /trunk/nv/stl/container/hash_table_policy.hh	(revision 403)
+++ /trunk/nv/stl/container/hash_table_policy.hh	(revision 404)
@@ -193,17 +193,23 @@
 		};
 
-		constexpr bool entry_compare( const entry_type* entry, const key_type& key, hash_type ) const
+		constexpr bool entry_compare( const entry_type* entry, hash_type, const key_type& key ) const
 		{
 			return base_type::compare( entry->value.first, key );
 		}
 
-		constexpr bool entry_compare( const entry_type* entry, const value_type& value, hash_type ) const
+		constexpr bool entry_compare( const entry_type* entry, hash_type, const value_type& value ) const
 		{
 			return base_type::compare( entry->value.first, value.first );
 		}
 
-		inline void entry_construct( entry_type* entry, const value_type& value, hash_type ) const
-		{
-			copy_construct_object( &(entry->value), value );
+		template < typename... Args >
+		inline void entry_construct( entry_type* entry, hash_type, Args&&... params ) const
+		{
+			construct_object( &(entry->value), ::nv::forward<Args>( params )... );
+		}
+
+		inline void entry_construct( entry_type* entry, hash_type, Key key ) const
+		{
+			construct_object( &( entry->value ), value_type( ::nv::move( key ), mapped_type() ) );
 		}
 
@@ -239,13 +245,20 @@
 		};
 
-		constexpr bool entry_compare( const entry_type* entry, const key_type& key, hash_type h ) const
+		constexpr bool entry_compare( const entry_type* entry, hash_type h, const key_type& key ) const
 		{
 			return entry->hash_code == h && base_type::compare( entry->value.first, key );
 		}
-		constexpr bool entry_compare( const entry_type* entry, const value_type& value, hash_type h ) const
+		constexpr bool entry_compare( const entry_type* entry, hash_type h, const value_type& value ) const
 		{
 			return entry->hash_code == h &&  base_type::compare( entry->value.first, value.first );
 		}
 
+		template < typename... Args >
+		inline void entry_construct( entry_type* entry, hash_type hash_code, Args&&... params ) const
+		{
+			copy_construct_object( &( entry->value ), ::nv::forward<Args>( params ) );
+			entry->hash_code = hash_code;
+		}
+
 		constexpr hash_type get_entry_hash( const entry_type* entry ) const
 		{
@@ -256,10 +269,5 @@
 			return base_type::get_hash( value.first );
 		}
-		inline void construct( entry_type* entry, const value_type& value, hash_type hash_code ) const
-		{
-			copy_construct_object( &(entry->value), value );
-			entry->hash_code = hash_code;
-		}
-	};
+};
 	
 	struct hash_table_range_mod_policy
Index: /trunk/nv/stl/container/initialize_policy.hh
===================================================================
--- /trunk/nv/stl/container/initialize_policy.hh	(revision 403)
+++ /trunk/nv/stl/container/initialize_policy.hh	(revision 404)
Index: /trunk/nv/stl/memory.hh
===================================================================
--- /trunk/nv/stl/memory.hh	(revision 403)
+++ /trunk/nv/stl/memory.hh	(revision 404)
@@ -124,5 +124,5 @@
 	inline void raw_construct_object( void* object, Args&&... params )
 	{
-		new ( object )T( forward<Args>( params )... );
+		new ( object )T( ::nv::forward<Args>( params )... );
 	}
 
@@ -130,5 +130,5 @@
 	inline void raw_move_construct_object( void* object, T&& original )
 	{
-		new ( object )T( move( original ) );
+		new ( object )T( ::nv::move( original ) );
 	}
 
@@ -142,5 +142,5 @@
 	inline void construct_object( T* object, Args&&... params )
 	{
-		new ( object )T( forward<Args>( params )... );
+		new ( object )T( ::nv::forward<Args>( params )... );
 	}
 
@@ -148,5 +148,5 @@
 	inline void move_construct_object( T* object, T&& original )
 	{
-		new ( object )T( move( original ) );
+		new ( object )T( ::nv::move( original ) );
 	}
 
Index: /trunk/nv/stl/utility/pair.hh
===================================================================
--- /trunk/nv/stl/utility/pair.hh	(revision 403)
+++ /trunk/nv/stl/utility/pair.hh	(revision 404)
@@ -27,10 +27,9 @@
 
 		constexpr pair() : first(), second() {}
-		constexpr pair( const T1& f, const T2& s )
+		constexpr pair( const first_type& f, const second_type& s )
 			: first( f ), second( s ) {}
-		// TODO: this is non-standard, and I dont like it,
-		// but is used in hash_table. Remove?
-		constexpr pair( const T1& f )
-			: first( f ), second() {}
+
+		constexpr pair( first_type&& f, second_type&& s )
+			: first( ::nv::forward<first_type>( f ) ), second( ::nv::forward<second_type>( s ) ) {}
 
 		pair( const pair& ) = default;
@@ -39,6 +38,6 @@
 		this_type& operator= ( this_type&& rhs )
 		{
-			first = forward<first_type>( rhs.first );
-			second = forward<first_type>( rhs.second );
+			first = ::nv::forward<first_type>( rhs.first );
+			second = ::nv::forward<first_type>( rhs.second );
 		}