diff --git a/include/libtorrent/debug.hpp b/include/libtorrent/debug.hpp
index 00660f844..d16eb2950 100644
--- a/include/libtorrent/debug.hpp
+++ b/include/libtorrent/debug.hpp
@@ -180,6 +180,9 @@ namespace libtorrent
 		void thread_started()
 		{ m_single_thread = pthread_self(); }
 
+		void transfer_ownership()
+		{ m_single_thread = 0; }
+
 	private:
 		mutable pthread_t m_single_thread;
 	};
diff --git a/include/libtorrent/peer_connection.hpp b/include/libtorrent/peer_connection.hpp
index d0b89a088..33d7fae7a 100644
--- a/include/libtorrent/peer_connection.hpp
+++ b/include/libtorrent/peer_connection.hpp
@@ -1468,6 +1468,7 @@ namespace libtorrent
 		// this is true while there is an outstanding
 		// async write job on the socket
 		bool m_socket_is_writing;
+		bool is_single_thread() const;
 #endif
 	};
 
diff --git a/include/libtorrent/torrent.hpp b/include/libtorrent/torrent.hpp
index 1e250cb62..93645428c 100644
--- a/include/libtorrent/torrent.hpp
+++ b/include/libtorrent/torrent.hpp
@@ -78,6 +78,7 @@ POSSIBILITY OF SUCH DAMAGE.
 #include "libtorrent/link.hpp"
 #include "libtorrent/vector_utils.hpp"
 #include "libtorrent/linked_list.hpp"
+#include "libtorrent/debug.hpp"
 
 #if TORRENT_COMPLETE_TYPES_REQUIRED
 #include "libtorrent/peer_connection.hpp"
@@ -233,7 +234,8 @@ namespace libtorrent
 	// for a specific download. It updates itself against
 	// the tracker
 	class TORRENT_EXTRA_EXPORT torrent
-		: public torrent_hot_members
+		: public single_threaded
+		, public torrent_hot_members
 		, public request_callback
 		, public peer_class_set
 		, public boost::enable_shared_from_this<torrent>
@@ -276,6 +278,7 @@ namespace libtorrent
 #if TORRENT_USE_ASSERTS
 		bool has_peer(peer_connection const* p) const
 		{ return sorted_find(m_connections, (peer_connection*)p) != m_connections.end(); }
+		bool is_single_thread() const { return single_threaded::is_single_thread(); }
 #endif
 
 		// this is called when the torrent has metadata.
diff --git a/src/peer_connection.cpp b/src/peer_connection.cpp
index 97f5bc88d..fc37c73b5 100644
--- a/src/peer_connection.cpp
+++ b/src/peer_connection.cpp
@@ -124,6 +124,15 @@ namespace libtorrent
 	}
 #endif
 
+#if TORRENT_USE_ASSERTS
+	bool peer_connection::is_single_thread() const
+	{
+		boost::shared_ptr<torrent> t = m_torrent.lock();
+		if (!t) return true;
+		return t->is_single_thread();
+	}
+#endif
+
 	// outbound connection
 	peer_connection::peer_connection(peer_connection_args const& pack)
 		: peer_connection_hot_members(pack.tor, *pack.ses, *pack.sett)
@@ -262,6 +271,7 @@ namespace libtorrent
 
 	int peer_connection::timeout() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		int ret = m_settings.get_int(settings_pack::peer_timeout);
 #if TORRENT_USE_I2P
 		if (m_peer_info && m_peer_info->is_i2p_addr)
@@ -275,12 +285,14 @@ namespace libtorrent
 
 	void peer_connection::increase_est_reciprocation_rate()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_est_reciprocation_rate += m_est_reciprocation_rate
 			* m_settings.get_int(settings_pack::increase_est_reciprocation_rate) / 100;
 	}
 
 	void peer_connection::decrease_est_reciprocation_rate()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_est_reciprocation_rate -= m_est_reciprocation_rate
 			* m_settings.get_int(settings_pack::decrease_est_reciprocation_rate) / 100;
 	}
@@ -288,6 +300,7 @@ namespace libtorrent
 	bool peer_connection::bittyrant_unchoke_compare(
 		peer_connection const* p) const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(p);
 		peer_connection const& rhs = *p;
 
@@ -317,6 +330,7 @@ namespace libtorrent
 	// return true if 'this' peer should be preferred to be unchoke over p
 	bool peer_connection::unchoke_compare(peer_connection const* p) const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(p);
 		peer_connection const& rhs = *p;
 
@@ -430,6 +444,7 @@ namespace libtorrent
 
 	int peer_connection::get_priority(int channel) const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(channel >= 0 && channel < 2);
 		int prio = 1;
 		for (int i = 0; i < num_classes(); ++i)
@@ -453,6 +468,7 @@ namespace libtorrent
 
 	bool peer_connection::upload_rate_compare(peer_connection const* p) const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		size_type c1;
 		size_type c2;
 
@@ -468,12 +484,14 @@ namespace libtorrent
 
 	void peer_connection::reset_choke_counters()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_downloaded_at_last_round= m_statistics.total_payload_download();
 		m_uploaded_at_last_round = m_statistics.total_payload_upload();
 	}
 
 	void peer_connection::start()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(m_peer_info == 0 || m_peer_info->connection == this);
 		boost::shared_ptr<torrent> t = m_torrent.lock();
 
@@ -534,6 +552,7 @@ namespace libtorrent
 
 	void peer_connection::update_interest()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (!m_need_interest_update)
 		{
 			// we're the first to request an interest update
@@ -549,6 +568,7 @@ namespace libtorrent
 
 	void peer_connection::do_update_interest()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(m_need_interest_update);
 		m_need_interest_update = false;
 
@@ -610,6 +630,7 @@ namespace libtorrent
 #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_ERROR_LOGGING
 	void peer_connection::peer_log(char const* fmt, ...) const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (!m_logger) return;
 
 		va_list v;	
@@ -627,11 +648,13 @@ namespace libtorrent
 #ifndef TORRENT_DISABLE_EXTENSIONS
 	void peer_connection::add_extension(boost::shared_ptr<peer_plugin> ext)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_extensions.push_back(ext);
 	}
 
 	peer_plugin const* peer_connection::find_plugin(char const* type)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		for (extension_list_t::iterator i = m_extensions.begin()
 			, end(m_extensions.end()); i != end; ++i)
 		{
@@ -643,6 +666,7 @@ namespace libtorrent
 
 	void peer_connection::send_allowed_set()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -745,6 +769,7 @@ namespace libtorrent
 
 	void peer_connection::on_metadata_impl()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		boost::shared_ptr<torrent> t = associated_torrent().lock();
 		m_have_piece.resize(t->torrent_file().num_pieces(), m_have_all);
 		m_num_pieces = m_have_piece.count();
@@ -779,6 +804,7 @@ namespace libtorrent
 
 	void peer_connection::init()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -924,6 +950,7 @@ namespace libtorrent
 
 	int peer_connection::picker_options() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		int ret = m_picker_options; 
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -974,6 +1001,7 @@ namespace libtorrent
 
 	void peer_connection::fast_reconnect(bool r)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (!peer_info_struct() || peer_info_struct()->fast_reconnects > 1)
 			return;
 		m_fast_reconnect = r;
@@ -989,6 +1017,7 @@ namespace libtorrent
 
 	void peer_connection::received_piece(int index)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		// dont announce during handshake
 		if (in_handshake()) return;
 
@@ -1025,6 +1054,7 @@ namespace libtorrent
 
 	void peer_connection::announce_piece(int index)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		// dont announce during handshake
 		if (in_handshake()) return;
 
@@ -1055,6 +1085,7 @@ namespace libtorrent
 
 	bool peer_connection::has_piece(int i) const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		boost::shared_ptr<torrent> t = m_torrent.lock();
 		TORRENT_ASSERT(t);
 		TORRENT_ASSERT(t->valid_metadata());
@@ -1065,21 +1096,25 @@ namespace libtorrent
 
 	std::vector<pending_block> const& peer_connection::request_queue() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		return m_request_queue;
 	}
 	
 	std::vector<pending_block> const& peer_connection::download_queue() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		return m_download_queue;
 	}
 	
 	std::vector<peer_request> const& peer_connection::upload_queue() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		return m_requests;
 	}
 
 	time_duration peer_connection::download_queue_time(int extra_bytes) const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		boost::shared_ptr<torrent> t = m_torrent.lock();
 		TORRENT_ASSERT(t);
 
@@ -1123,11 +1158,13 @@ namespace libtorrent
 
 	void peer_connection::add_stat(size_type downloaded, size_type uploaded)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_statistics.add_stat(downloaded, uploaded);
 	}
 
 	void peer_connection::received_bytes(int bytes_payload, int bytes_protocol)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_statistics.received_bytes(bytes_payload, bytes_protocol);
 		if (m_ignore_stats) return;
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -1137,6 +1174,7 @@ namespace libtorrent
 
 	void peer_connection::sent_bytes(int bytes_payload, int bytes_protocol)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_statistics.sent_bytes(bytes_payload, bytes_protocol);
 #ifndef TORRENT_DISABLE_EXTENSIONS
 		if (bytes_payload)
@@ -1156,6 +1194,7 @@ namespace libtorrent
 
 	void peer_connection::trancieve_ip_packet(int bytes, bool ipv6)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_statistics.trancieve_ip_packet(bytes, ipv6);
 		if (m_ignore_stats) return;
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -1165,6 +1204,7 @@ namespace libtorrent
 
 	void peer_connection::sent_syn(bool ipv6)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_statistics.sent_syn(ipv6);
 		if (m_ignore_stats) return;
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -1174,6 +1214,7 @@ namespace libtorrent
 
 	void peer_connection::received_synack(bool ipv6)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_statistics.received_synack(ipv6);
 		if (m_ignore_stats) return;
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -1183,11 +1224,13 @@ namespace libtorrent
 
 	bitfield const& peer_connection::get_bitfield() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		return m_have_piece;
 	}
 
 	void peer_connection::received_valid_data(int index)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		// this fails because we haven't had time to disconnect
 		// seeds yet, and we might have just become one
 //		INVARIANT_CHECK;
@@ -1205,6 +1248,7 @@ namespace libtorrent
 
 	bool peer_connection::received_invalid_data(int index, bool single_peer)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 #ifndef TORRENT_DISABLE_EXTENSIONS
@@ -1223,6 +1267,7 @@ namespace libtorrent
 	// and if it can correspond to a request generated by libtorrent.
 	bool peer_connection::verify_piece(const peer_request& p) const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		boost::shared_ptr<torrent> t = m_torrent.lock();
 		TORRENT_ASSERT(t);
 
@@ -1238,6 +1283,7 @@ namespace libtorrent
 
 	void peer_connection::attach_to_torrent(sha1_hash const& ih, bool allow_encrypted)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 #if defined TORRENT_LOGGING || defined TORRENT_ERROR_LOGGING
@@ -1381,6 +1427,7 @@ namespace libtorrent
 
 	boost::uint32_t peer_connection::peer_rank() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		return m_peer_info == NULL ? 0
 			: m_peer_info->rank(m_ses.external_address(), m_ses.listen_port());
 	}
@@ -1393,6 +1440,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_keepalive()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 #ifdef TORRENT_VERBOSE_LOGGING
@@ -1406,6 +1454,7 @@ namespace libtorrent
 
 	void peer_connection::set_endgame(bool b)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (m_endgame_mode == b) return;
 		m_endgame_mode = b;
 		if (m_endgame_mode)
@@ -1416,6 +1465,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_choke()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 #ifndef TORRENT_DISABLE_EXTENSIONS
@@ -1441,6 +1491,7 @@ namespace libtorrent
 
 	void peer_connection::clear_request_queue()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		boost::shared_ptr<torrent> t = m_torrent.lock();
 		TORRENT_ASSERT(t);
 		if (!t->has_picker())
@@ -1479,6 +1530,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_reject_request(peer_request const& r)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -1570,6 +1622,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_suggest(int index)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 #ifdef TORRENT_VERBOSE_LOGGING
@@ -1628,6 +1681,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_unchoke()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -1670,6 +1724,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_interested()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -1728,6 +1783,7 @@ namespace libtorrent
 
 	void peer_connection::maybe_unchoke_this_peer()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (ignore_unchoke_slots())
 		{
 #ifdef TORRENT_VERBOSE_LOGGING
@@ -1773,6 +1829,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_not_interested()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 #ifndef TORRENT_DISABLE_EXTENSIONS
@@ -1809,6 +1866,7 @@ namespace libtorrent
 
 	void peer_connection::choke_this_peer()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (is_choked()) return;
 		if (ignore_unchoke_slots())
 		{
@@ -1835,6 +1893,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_have(int index)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -1990,6 +2049,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_dont_have(int index)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -2047,6 +2107,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_bitfield(bitfield const& bits)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -2178,6 +2239,7 @@ namespace libtorrent
 
 	bool peer_connection::disconnect_if_redundant()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (m_disconnecting) return false;
 
 		// we cannot disconnect in a constructor
@@ -2218,6 +2280,7 @@ namespace libtorrent
 
 	bool peer_connection::can_disconnect(error_code const& ec) const
 	{
+		TORRENT_ASSERT(is_single_thread());
 #ifndef TORRENT_DISABLE_EXTENSIONS
 		for (extension_list_t::const_iterator i = m_extensions.begin()
 			, end(m_extensions.end()); i != end; ++i)
@@ -2234,6 +2297,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_request(peer_request const& r)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -2435,6 +2499,7 @@ namespace libtorrent
 	// reject all requests to this piece
 	void peer_connection::reject_piece(int index)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		for (std::vector<peer_request>::iterator i = m_requests.begin()
 			, end(m_requests.end()); i != end; ++i)
 		{
@@ -2450,6 +2515,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_piece_fragment(int bytes)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_last_piece = time_now();
 		TORRENT_ASSERT(m_outstanding_bytes >= bytes);
 		m_outstanding_bytes -= bytes;
@@ -2470,6 +2536,7 @@ namespace libtorrent
 
 	void peer_connection::start_receive_piece(peer_request const& r)
 	{
+		TORRENT_ASSERT(is_single_thread());
 #if TORRENT_USE_INVARIANT_CHECKS
 		check_invariant();
 #endif
@@ -2593,6 +2660,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_piece(peer_request const& p, char const* data)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		bool exceeded = false;
 		char* buffer = m_allocator.allocate_disk_buffer(exceeded, self(), "receive buffer");
 
@@ -2619,6 +2687,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_piece(peer_request const& p, disk_buffer_holder& data)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -2930,6 +2999,7 @@ namespace libtorrent
 	void peer_connection::on_disk_write_complete(disk_io_job const* j
 		, peer_request p, boost::shared_ptr<torrent> t)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		torrent_ref_holder h(t.get(), "async_write");
 		if (t) t->dec_refcount("async_write");
 
@@ -3026,6 +3096,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_cancel(peer_request const& r)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 #ifndef TORRENT_DISABLE_EXTENSIONS
@@ -3077,6 +3148,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_dht_port(int listen_port)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 #ifdef TORRENT_VERBOSE_LOGGING
@@ -3094,6 +3166,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_have_all()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -3176,6 +3249,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_have_none()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 #ifdef TORRENT_VERBOSE_LOGGING
@@ -3223,6 +3297,7 @@ namespace libtorrent
 
 	void peer_connection::incoming_allowed_fast(int index)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -3292,6 +3367,7 @@ namespace libtorrent
 
 	std::vector<int> const& peer_connection::allowed_fast()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		boost::shared_ptr<torrent> t = m_torrent.lock();
 		TORRENT_ASSERT(t);
 
@@ -3301,6 +3377,7 @@ namespace libtorrent
 
 	bool peer_connection::can_request_time_critical() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (has_peer_choked() || !is_interesting()) return false;
 		if ((int)m_download_queue.size() + (int)m_request_queue.size()
 			> m_desired_queue_size * 2) return false;
@@ -3318,6 +3395,7 @@ namespace libtorrent
 
 	bool peer_connection::make_time_critical(piece_block const& block)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		std::vector<pending_block>::iterator rit = std::find_if(m_request_queue.begin()
 			, m_request_queue.end(), has_block(block));
 		if (rit == m_request_queue.end()) return false;
@@ -3338,6 +3416,7 @@ namespace libtorrent
 
 	bool peer_connection::add_request(piece_block const& block, int flags)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -3460,6 +3539,7 @@ namespace libtorrent
 
 	void peer_connection::cancel_all_requests()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -3514,6 +3594,7 @@ namespace libtorrent
 
 	void peer_connection::cancel_request(piece_block const& block, bool force)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -3580,6 +3661,7 @@ namespace libtorrent
 
 	bool peer_connection::send_choke()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		if (m_choked)
@@ -3635,6 +3717,7 @@ namespace libtorrent
 
 	bool peer_connection::send_unchoke()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		if (!m_choked) return false;
@@ -3676,6 +3759,7 @@ namespace libtorrent
 
 	void peer_connection::send_interested()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (m_interesting) return;
 		boost::shared_ptr<torrent> t = m_torrent.lock();
 		if (!t->ready_for_connections()) return;
@@ -3690,6 +3774,7 @@ namespace libtorrent
 
 	void peer_connection::send_not_interested()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		// we cannot disconnect in a constructor, and
 		// this function may end up doing that
 		TORRENT_ASSERT(m_in_constructor == false);
@@ -3719,6 +3804,7 @@ namespace libtorrent
 
 	void peer_connection::send_suggest(int piece)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (m_connecting) return;
 		if (in_handshake()) return;
 
@@ -3752,6 +3838,7 @@ namespace libtorrent
 
 	void peer_connection::send_block_requests()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 		
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -3921,6 +4008,7 @@ namespace libtorrent
 
 	void peer_connection::on_connect_timeout()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_queued_for_connection = false;
 
 #if defined TORRENT_LOGGING || defined TORRENT_ERROR_LOGGING
@@ -3935,6 +4023,7 @@ namespace libtorrent
 	
 	void peer_connection::connect_failed(error_code const& e)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(e);
 
 #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_ERROR_LOGGING
@@ -4006,6 +4095,7 @@ namespace libtorrent
 	// 2 protocol error (client sent something invalid)
 	void peer_connection::disconnect(error_code const& ec, operation_t op, int error)
 	{
+		TORRENT_ASSERT(is_single_thread());
 #if TORRENT_USE_ASSERTS
 		m_disconnect_started = true;
 #endif
@@ -4250,6 +4340,7 @@ namespace libtorrent
 
 	bool peer_connection::ignore_unchoke_slots() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (num_classes() == 0) return true;
 
 		if (m_ses.ignore_unchoke_slots_set(*this)) return true;
@@ -4263,6 +4354,7 @@ namespace libtorrent
 
 	bool peer_connection::on_local_network() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (libtorrent::is_local(m_remote.address())
 			|| is_loopback(m_remote.address())) return true;
 		return false;
@@ -4270,6 +4362,7 @@ namespace libtorrent
 
 	void peer_connection::get_peer_info(peer_info& p) const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(!associated_torrent().expired());
 
 		ptime now = time_now();
@@ -4414,6 +4507,7 @@ namespace libtorrent
 	// to the caller
 	bool peer_connection::allocate_disk_receive_buffer(int disk_buffer_size)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		TORRENT_ASSERT(m_packet_size > 0);
@@ -4459,6 +4553,7 @@ namespace libtorrent
 
 	char* peer_connection::release_disk_receive_buffer()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (!m_disk_recv_buffer) return 0;
 
 		TORRENT_ASSERT(m_disk_recv_buffer_size <= m_recv_end);
@@ -4473,6 +4568,7 @@ namespace libtorrent
 	// offset = the offset into the receive buffer where to remove `size` bytes
 	void peer_connection::cut_receive_buffer(int size, int packet_size, int offset)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		TORRENT_ASSERT(packet_size > 0);
@@ -4514,6 +4610,7 @@ namespace libtorrent
 	// in the receive buffer that have been parsed and processed.
 	void peer_connection::normalize_receive_buffer()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(m_recv_end >= m_recv_start);
 		if (m_recv_start == 0) return;
 
@@ -4530,6 +4627,7 @@ namespace libtorrent
 
 	void peer_connection::superseed_piece(int replace_piece, int new_piece)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (new_piece == -1)
 		{
 			if (m_superseed_piece[0] == -1) return;
@@ -4570,6 +4668,7 @@ namespace libtorrent
 
 	void peer_connection::update_desired_queue_size()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (m_snubbed)
 		{
 			m_desired_queue_size = 1;
@@ -4601,6 +4700,7 @@ namespace libtorrent
 
 	void peer_connection::second_tick(int tick_interval_ms)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		ptime now = time_now();
 		boost::shared_ptr<peer_connection> me(self());
 
@@ -4843,6 +4943,7 @@ namespace libtorrent
 
 	void peer_connection::snub_peer()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -4936,6 +5037,7 @@ namespace libtorrent
 
 	int peer_connection::preferred_caching() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		int line_size = 0;
 		if (m_settings.get_bool(settings_pack::guided_read_cache))
 		{
@@ -4960,6 +5062,7 @@ namespace libtorrent
 
 	void peer_connection::fill_send_buffer()
 	{
+		TORRENT_ASSERT(is_single_thread());
 #ifdef TORRENT_EXPENSIVE_INVARIANT_CHECKS
 		INVARIANT_CHECK;
 #endif
@@ -5084,6 +5187,7 @@ namespace libtorrent
 	// checked, while in seed-mode
 	void peer_connection::on_seed_mode_hashed(disk_io_job const* j)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -5137,6 +5241,7 @@ namespace libtorrent
 	void peer_connection::on_disk_read_complete(disk_io_job const* j
 		, peer_request r, ptime issue_time)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		// return value:
 		// 0: success, piece passed hash check
 		// -1: disk failure
@@ -5229,6 +5334,7 @@ namespace libtorrent
 
 	void peer_connection::assign_bandwidth(int channel, int amount)
 	{
+		TORRENT_ASSERT(is_single_thread());
 #ifdef TORRENT_VERBOSE_LOGGING
 		peer_log("%s ASSIGN BANDWIDHT [ bytes: %d ]"
 			, channel == upload_channel ? ">>>" : "<<<", amount);
@@ -5259,6 +5365,7 @@ namespace libtorrent
 	// by the rate limiter to allocate quota for this peer
 	int peer_connection::wanted_transfer(int channel)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		shared_ptr<torrent> t = m_torrent.lock();
 
 		if (channel == download_channel)
@@ -5279,6 +5386,7 @@ namespace libtorrent
 
 	int peer_connection::request_bandwidth(int channel, int bytes)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 		// we can only have one outstanding bandwidth request at a time
 		if (m_channel_state[channel] & peer_info::bw_limit) return 0;
@@ -5349,6 +5457,7 @@ namespace libtorrent
 
 	void peer_connection::uncork_socket()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (!m_corked) return;
 		m_corked = false;
 		setup_send();
@@ -5356,6 +5465,7 @@ namespace libtorrent
 
 	void peer_connection::setup_send()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if (m_disconnecting) return;
 
 		// we may want to request more quota at this point
@@ -5485,6 +5595,7 @@ namespace libtorrent
 
 	void peer_connection::on_disk()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		if ((m_channel_state[download_channel] & peer_info::bw_disk) == 0) return;
 		boost::shared_ptr<peer_connection> me(self());
 	
@@ -5498,6 +5609,7 @@ namespace libtorrent
 
 	void peer_connection::on_allocate_disk_buffer(char* buffer, int buffer_size)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		TORRENT_ASSERT(!m_disk_recv_buffer);
@@ -5514,6 +5626,7 @@ namespace libtorrent
 
 	void peer_connection::setup_receive(sync_t sync)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		if (m_disconnecting) return;
@@ -5551,6 +5664,7 @@ namespace libtorrent
 
 	size_t peer_connection::try_read(sync_t s, error_code& ec)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(m_connected);
 
 		if (m_quota[download_channel] == 0)
@@ -5718,6 +5832,7 @@ namespace libtorrent
 	// returns the last 'bytes' from the receive buffer
 	std::pair<buffer::interval, buffer::interval> peer_connection::wr_recv_buffers(int bytes)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(bytes <= m_recv_pos);
 
 		std::pair<buffer::interval, buffer::interval> vec;
@@ -5752,6 +5867,7 @@ namespace libtorrent
 
 	void peer_connection::reset_recv_buffer(int packet_size)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(m_recv_buffer.size() >= m_recv_end);
 		TORRENT_ASSERT(packet_size > 0);
 		if (m_recv_end > m_packet_size)
@@ -5770,6 +5886,7 @@ namespace libtorrent
 		, chained_buffer::free_buffer_fun destructor, void* userdata
 		, block_cache_reference ref, bool encrypted)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		// bittorrent connections should never use this function, since
 		// they might be encrypted and this would circumvent the actual
 		// encryption. bt_peer_connection overrides this function with
@@ -5783,6 +5900,7 @@ namespace libtorrent
 		, chained_buffer::free_buffer_fun destructor, void* userdata
 		, block_cache_reference ref)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_send_buffer.append_buffer((char*)buffer, size, size, destructor
 			, userdata, ref);
 	}
@@ -5796,6 +5914,7 @@ namespace libtorrent
 	void peer_connection::send_buffer(char const* buf, int size, int flags
 		, void (*fun)(char*, int, void*), void* userdata)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		int free_space = m_send_buffer.space_in_last_buffer();
 		if (free_space > size) free_space = size;
 		if (free_space > 0)
@@ -5845,6 +5964,7 @@ namespace libtorrent
 	void peer_connection::on_receive_data_nb(const error_code& error
 		, std::size_t bytes_transferred)
 	{
+		TORRENT_ASSERT(is_single_thread());
 #if defined TORRENT_ASIO_DEBUGGING
 		complete_async("peer_connection::on_receive_data_nb");
 #endif
@@ -5955,6 +6075,7 @@ namespace libtorrent
 	void peer_connection::on_receive_data(const error_code& error
 		, std::size_t bytes_transferred)
 	{
+		TORRENT_ASSERT(is_single_thread());
 #if defined TORRENT_ASIO_DEBUGGING
 		complete_async("peer_connection::on_receive_data");
 #endif
@@ -5970,6 +6091,7 @@ namespace libtorrent
 	void peer_connection::receive_data_impl(const error_code& error
 		, std::size_t bytes_transferred, int read_loops)
 	{
+		TORRENT_ASSERT(is_single_thread());
 #ifdef TORRENT_VERBOSE_LOGGING
 		peer_log("<<< ON_RECEIVE_DATA [ bytes: %d error: %s ]"
 			, bytes_transferred, error.message().c_str());
@@ -6116,6 +6238,7 @@ namespace libtorrent
 
 	bool peer_connection::can_write() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		// if we have requests or pending data to be sent or announcements to be made
 		// we want to send data
 		return !m_send_buffer.empty()
@@ -6125,6 +6248,7 @@ namespace libtorrent
 
 	bool peer_connection::can_read()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -6169,6 +6293,7 @@ namespace libtorrent
 
 	void peer_connection::on_allow_connect(int ticket)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(m_queued_for_connection);
 		m_queued_for_connection = false;
 
@@ -6263,6 +6388,7 @@ namespace libtorrent
 	
 	void peer_connection::on_connection_complete(error_code const& e)
 	{
+		TORRENT_ASSERT(is_single_thread());
 #if defined TORRENT_ASIO_DEBUGGING
 		complete_async("peer_connection::on_connection_complete");
 #endif
@@ -6418,6 +6544,7 @@ namespace libtorrent
 	void peer_connection::on_send_data(error_code const& error
 		, std::size_t bytes_transferred)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		m_counters.inc_stats_counter(counters::on_write_counter);
 		m_ses.sent_buffer(bytes_transferred);
 
@@ -6524,6 +6651,7 @@ namespace libtorrent
 
 	void peer_connection::check_invariant() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(m_in_use == 1337);
 		TORRENT_ASSERT(m_queued_time_critical <= int(m_request_queue.size()));
 		TORRENT_ASSERT(m_recv_end >= m_recv_start);
@@ -6766,6 +6894,7 @@ namespace libtorrent
 
 	peer_connection::peer_speed_t peer_connection::peer_speed()
 	{
+		TORRENT_ASSERT(is_single_thread());
 		shared_ptr<torrent> t = m_torrent.lock();
 		TORRENT_ASSERT(t);
 
@@ -6786,6 +6915,7 @@ namespace libtorrent
 
 	void peer_connection::keep_alive()
 	{
+		TORRENT_ASSERT(is_single_thread());
 #ifdef TORRENT_EXPENSIVE_INVARIANT_CHECKS
 		INVARIANT_CHECK;
 #endif
@@ -6811,6 +6941,7 @@ namespace libtorrent
 
 	bool peer_connection::is_seed() const
 	{
+		TORRENT_ASSERT(is_single_thread());
 		// if m_num_pieces == 0, we probably don't have the
 		// metadata yet.
 		boost::shared_ptr<torrent> t = m_torrent.lock();
@@ -6819,6 +6950,7 @@ namespace libtorrent
 
 	void peer_connection::set_share_mode(bool u)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		// if the peer is a seed, ignore share mode messages
 		if (is_seed()) return;
 
@@ -6827,6 +6959,7 @@ namespace libtorrent
 
 	void peer_connection::set_upload_only(bool u)
 	{
+		TORRENT_ASSERT(is_single_thread());
 		// if the peer is a seed, don't allow setting
 		// upload_only to false
 		if (m_upload_only || is_seed()) return;
diff --git a/src/torrent.cpp b/src/torrent.cpp
index a898829f8..652294c6c 100644
--- a/src/torrent.cpp
+++ b/src/torrent.cpp
@@ -301,7 +301,7 @@ namespace libtorrent
 
 		if (!m_url.empty() && m_uuid.empty()) m_uuid = m_url;
 
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING || defined TORRENT_ERROR_LOGGING
 		debug_log("creating torrent: %s", torrent_file().name().c_str());
 #endif
@@ -735,7 +735,7 @@ namespace libtorrent
 
 	void torrent::start()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING
 		debug_log("starting torrent");
 #endif
@@ -823,7 +823,7 @@ namespace libtorrent
 #ifndef TORRENT_DISABLE_DHT
 	bool torrent::should_announce_dht() const
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (!m_ses.announce_dht()) return false;
 
 		if (!m_ses.dht()) return false;
@@ -1054,7 +1054,7 @@ namespace libtorrent
 
 	void torrent::handle_disk_error(disk_io_job const* j, peer_connection* c)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (!j->error) return;
 
 #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING || defined TORRENT_ERROR_LOGGING
@@ -1183,7 +1183,7 @@ namespace libtorrent
 		torrent_ref_holder h(this, "read_piece");
 
 		dec_refcount("read_piece");
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		disk_buffer_holder buffer(m_ses, *j);
 
@@ -1242,7 +1242,7 @@ namespace libtorrent
 
 	void torrent::add_piece(int piece, char const* data, int flags)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(piece >= 0 && piece < m_torrent_file->num_pieces());
 		int piece_size = m_torrent_file->piece_size(piece);
 		int blocks_in_piece = (piece_size + block_size() - 1) / block_size();
@@ -1312,7 +1312,7 @@ namespace libtorrent
 		torrent_ref_holder h(this, "add_piece");
 
 		dec_refcount("add_piece");
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		schedule_storage_tick();
 
@@ -1691,7 +1691,7 @@ namespace libtorrent
 	// shared_from_this()
 	void torrent::init()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		if (!need_loaded()) return;
 		TORRENT_ASSERT(m_torrent_file->num_files() > 0);
@@ -1932,7 +1932,7 @@ namespace libtorrent
 
 	void torrent::dec_refcount(char const* purpose)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(m_refcount > 0);
 		--m_refcount;
 		if (m_refcount == 0)
@@ -1947,7 +1947,7 @@ namespace libtorrent
 
 	void torrent::inc_refcount(char const* purpose)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(is_loaded());
 		++m_refcount;
 		if (!m_pinned && m_refcount == 1)
@@ -1956,7 +1956,7 @@ namespace libtorrent
 
 	void torrent::set_pinned(bool p)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (m_pinned == p) return;
 		m_pinned = p;
 
@@ -2104,7 +2104,7 @@ namespace libtorrent
 		bool need_save_resume_data = m_need_save_resume_data;
 
 		dec_refcount("check_fastresume");
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		if (j->ret == piece_manager::fatal_disk_error)
 		{
@@ -2417,7 +2417,7 @@ namespace libtorrent
 
 	void torrent::on_force_recheck(disk_io_job const* j)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		// hold a reference until this function returns
 		torrent_ref_holder h(this, "force_recheck");
@@ -2498,7 +2498,7 @@ namespace libtorrent
 		// hold a reference until this function returns
 		torrent_ref_holder h(this, "start_checking");
 
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		dec_refcount("start_checking");
@@ -2674,7 +2674,7 @@ namespace libtorrent
 
 	void torrent::on_tracker_announce()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		m_waiting_tracker = false;	
 		if (m_abort) return;
 		announce_with_tracker();
@@ -2723,7 +2723,7 @@ namespace libtorrent
 
 	void torrent::dht_announce()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (!m_ses.dht())
 		{
 #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING || defined TORRENT_ERROR_LOGGING
@@ -2804,7 +2804,7 @@ namespace libtorrent
 
 	void torrent::on_dht_announce_response(std::vector<tcp::endpoint> const& peers)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 #if defined TORRENT_LOGGING || defined TORRENT_ERROR_LOGGING
 		debug_log("END DHT announce (%d ms) (%d peers)"
@@ -2836,7 +2836,7 @@ namespace libtorrent
 	void torrent::announce_with_tracker(boost::uint8_t e
 		, address const& bind_interface)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		if (m_trackers.empty())
@@ -3034,7 +3034,7 @@ namespace libtorrent
 
 	void torrent::scrape_tracker()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		m_last_scrape = m_ses.session_time();
 
 		if (m_trackers.empty()) return;
@@ -3053,7 +3053,7 @@ namespace libtorrent
 
 	void torrent::tracker_warning(tracker_request const& req, std::string const& msg)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		INVARIANT_CHECK;
 
@@ -3064,7 +3064,7 @@ namespace libtorrent
  	void torrent::tracker_scrape_response(tracker_request const& req
  		, int complete, int incomplete, int downloaded, int downloaders)
  	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
  
  		INVARIANT_CHECK;
 		TORRENT_ASSERT(req.kind == tracker_request::scrape_request);
@@ -3127,7 +3127,7 @@ namespace libtorrent
 		, address const& external_ip
 		, const std::string& trackerid)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		INVARIANT_CHECK;
 		TORRENT_ASSERT(r.kind == tracker_request::announce_request);
@@ -3400,7 +3400,7 @@ namespace libtorrent
 #if TORRENT_USE_I2P
 	void torrent::on_i2p_resolve(error_code const& ec, char const* dest)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		INVARIANT_CHECK;
 
@@ -3421,7 +3421,7 @@ namespace libtorrent
 	void torrent::on_peer_name_lookup(error_code const& e
 		, std::vector<address> const& host_list, int port)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		INVARIANT_CHECK;
 
@@ -3771,7 +3771,7 @@ namespace libtorrent
 
 	void torrent::on_piece_verified(disk_io_job const* j)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		torrent_ref_holder h(this, "verify_piece");
 
@@ -3874,7 +3874,7 @@ namespace libtorrent
 	// is correct
 	void torrent::we_have(int index)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(!has_picker() || m_picker->has_piece_passed(index));
 
 		inc_stats_counter(counters::num_have_pieces);
@@ -4039,7 +4039,7 @@ namespace libtorrent
 	void torrent::piece_passed(int index)
 	{
 //		INVARIANT_CHECK;
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(!m_picker->has_piece_passed(index));
 
 #if defined TORRENT_LOGGING || defined TORRENT_ERROR_LOGGING
@@ -4135,7 +4135,7 @@ namespace libtorrent
 		// invariant check here since it assumes:
 		// (total_done == m_torrent_file->total_size()) => is_seed()
 		INVARIANT_CHECK;
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		TORRENT_ASSERT(m_picker.get());
 		TORRENT_ASSERT(index >= 0);
@@ -4603,7 +4603,7 @@ namespace libtorrent
 
 	void torrent::abort()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		if (m_abort) return;
@@ -4733,7 +4733,7 @@ namespace libtorrent
 
 	void torrent::on_files_deleted(disk_io_job const* j)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		dec_refcount("delete_files");
 		if (j->ret != 0)
@@ -4750,7 +4750,7 @@ namespace libtorrent
 
 	void torrent::on_save_resume_data(disk_io_job const* j)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		torrent_ref_holder h(this, "save_resume");
 		dec_refcount("save_resume");
 		m_ses.done_async_resume();
@@ -4772,7 +4772,7 @@ namespace libtorrent
 
 	void torrent::on_file_renamed(disk_io_job const* j)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		dec_refcount("rename_file");
 
 		if (j->ret == 0)
@@ -4791,7 +4791,7 @@ namespace libtorrent
 
 	void torrent::on_torrent_paused(disk_io_job const* j)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		if (alerts().should_post<torrent_paused_alert>())
 			alerts().post_alert(torrent_paused_alert(get_handle()));
@@ -5740,7 +5740,7 @@ namespace libtorrent
 		INVARIANT_CHECK;
 
 		TORRENT_ASSERT(p != 0);
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		peer_iterator i = sorted_find(m_connections, p);
 		if (i == m_connections.end())
@@ -5827,7 +5827,7 @@ namespace libtorrent
 
 	void torrent::connect_to_url_seed(std::list<web_seed_entry>::iterator web)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		TORRENT_ASSERT(!web->resolving);
@@ -5980,7 +5980,7 @@ namespace libtorrent
 	void torrent::on_proxy_name_lookup(error_code const& e, tcp::resolver::iterator host
 		, std::list<web_seed_entry>::iterator web)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		INVARIANT_CHECK;
 
@@ -6065,7 +6065,7 @@ namespace libtorrent
 	void torrent::on_name_lookup(error_code const& e, tcp::resolver::iterator host
 		, std::list<web_seed_entry>::iterator web, tcp::endpoint proxy)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		INVARIANT_CHECK;
 
@@ -6113,7 +6113,7 @@ namespace libtorrent
 
 	void torrent::connect_web_seed(std::list<web_seed_entry>::iterator web, tcp::endpoint a)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (m_abort) return;
 
 		if (m_apply_ip_filter
@@ -6304,7 +6304,7 @@ namespace libtorrent
 	
 	void torrent::resolve_peer_country(boost::shared_ptr<peer_connection> const& p) const
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (m_resolving_country
 			|| is_local(p->remote().address())
 			|| p->has_country()
@@ -6339,7 +6339,7 @@ namespace libtorrent
 		, std::vector<address> const& host_list
 		, boost::shared_ptr<peer_connection> p) const
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		INVARIANT_CHECK;
 		
@@ -7013,7 +7013,7 @@ namespace libtorrent
 
 	void torrent::get_download_queue(std::vector<partial_piece_info>* queue)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		queue->clear();
 		std::vector<block_info>& blk = m_ses.block_info_storage();
 		blk.clear();
@@ -7103,7 +7103,7 @@ namespace libtorrent
 	
 	bool torrent::connect_to_peer(torrent_peer* peerinfo, bool ignore_limit)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		TORRENT_ASSERT(peerinfo);
@@ -7301,7 +7301,7 @@ namespace libtorrent
 
 	bool torrent::set_metadata(char const* metadata_buf, int metadata_size)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		if (m_torrent_file->is_valid()) return false;
@@ -8014,7 +8014,7 @@ namespace libtorrent
 
 	void torrent::files_checked()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(m_torrent_file->is_valid());
 
 		if (m_abort)
@@ -8131,7 +8131,7 @@ namespace libtorrent
 
 	alert_manager& torrent::alerts() const
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		return m_ses.alerts();
 	}
 
@@ -8158,7 +8158,7 @@ namespace libtorrent
 
 	void torrent::move_storage(std::string const& save_path, int flags)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		if (m_abort)
@@ -8201,7 +8201,7 @@ namespace libtorrent
 
 	void torrent::on_storage_moved(disk_io_job const* j)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		m_moving_storage = false;
 		dec_refcount("move_storage");
@@ -8231,13 +8231,13 @@ namespace libtorrent
 
 	torrent_handle torrent::get_handle()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		return torrent_handle(shared_from_this());
 	}
 
 	aux::session_settings const& torrent::settings() const
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		return m_ses.settings();
 	}
 
@@ -8292,7 +8292,7 @@ namespace libtorrent
 		TORRENT_ASSERT(want_tick() == m_links[aux::session_interface::torrent_want_tick].in_list());
 		TORRENT_ASSERT((!m_allow_peers && m_auto_managed) == m_links[aux::session_interface::torrent_want_scrape].in_list());
 
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		// this fires during disconnecting peers
 //		if (is_paused()) TORRENT_ASSERT(num_peers() == 0 || m_graceful_pause_mode);
 
@@ -8450,7 +8450,7 @@ namespace libtorrent
 
 	void torrent::set_sequential_download(bool sd)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (m_sequential_download == sd) return;
 		m_sequential_download = sd;
 
@@ -8472,7 +8472,7 @@ namespace libtorrent
 
 	void torrent::set_queue_position(int p)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT((p == -1) == is_finished()
 			|| (!m_auto_managed && p == -1)
 			|| (m_abort && p == -1));
@@ -8488,7 +8488,7 @@ namespace libtorrent
 
 	void torrent::set_max_uploads(int limit, bool state_update)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(limit >= -1);
 		if (limit <= 0) limit = (1<<24)-1;
 		if (m_max_uploads != limit && state_update) state_updated();
@@ -8500,7 +8500,7 @@ namespace libtorrent
 
 	void torrent::set_max_connections(int limit, bool state_update)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(limit >= -1);
 		if (limit <= 0) limit = (1<<24)-1;
 		if (m_max_connections != limit && state_update) state_updated();
@@ -8531,7 +8531,7 @@ namespace libtorrent
 
 	void torrent::set_limit_impl(int limit, int channel, bool state_update)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(limit >= -1);
 		if (limit <= 0) limit = 0;
 
@@ -8556,7 +8556,7 @@ namespace libtorrent
 
 	int torrent::limit_impl(int channel) const
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		if (m_peer_class == 0) return -1;
 		int limit = m_ses.peer_classes().at(m_peer_class)->channel[channel].throttle();
@@ -8576,7 +8576,7 @@ namespace libtorrent
 
 	bool torrent::delete_files()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_ERROR_LOGGING || defined TORRENT_LOGGING
 		log_to_all_peers("DELETING FILES IN TORRENT");
@@ -8600,7 +8600,7 @@ namespace libtorrent
 
 	void torrent::clear_error()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (!m_error) return;
 		bool checking_files = should_check_files();
 		m_ses.trigger_auto_manage();
@@ -8641,7 +8641,7 @@ namespace libtorrent
 
 	void torrent::set_error(error_code const& ec, int error_file)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		m_error = ec;
 		m_error_file = error_file;
 
@@ -8665,7 +8665,7 @@ namespace libtorrent
 
 	void torrent::auto_managed(bool a)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		if (m_auto_managed == a) return;
@@ -8746,7 +8746,7 @@ namespace libtorrent
 	// the higher seed rank, the more important to seed
 	int torrent::seed_rank(aux::session_settings const& s) const
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		enum flags
 		{
 			seed_ratio_not_met = 0x40000000,
@@ -8811,7 +8811,7 @@ namespace libtorrent
 	// just to save an empty resume data file
 	void torrent::save_resume_data(int flags)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 	
 		if (!valid_metadata())
@@ -8886,7 +8886,7 @@ namespace libtorrent
 	
 	bool torrent::should_check_files() const
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		// #error should m_allow_peers really affect checking?
 		return m_state == torrent_status::checking_files
 			&& m_allow_peers
@@ -8898,7 +8898,7 @@ namespace libtorrent
 
 	void torrent::flush_cache()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		// storage may be NULL during shutdown
 		if (!m_storage)
@@ -8914,7 +8914,7 @@ namespace libtorrent
 	void torrent::on_cache_flushed(disk_io_job const* j)
 	{
 		dec_refcount("release_files");
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		if (m_ses.is_aborted()) return;
 
@@ -8929,7 +8929,7 @@ namespace libtorrent
 
 	void torrent::pause(bool graceful)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		if (!m_allow_peers) return;
@@ -8962,7 +8962,7 @@ namespace libtorrent
 
 	void torrent::do_pause()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (!is_paused()) return;
 
 #ifndef TORRENT_DISABLE_EXTENSIONS
@@ -9082,7 +9082,7 @@ namespace libtorrent
 #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_ERROR_LOGGING || defined TORRENT_LOGGING
 	void torrent::log_to_all_peers(char const* message)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_ERROR_LOGGING
 		for (peer_iterator i = m_connections.begin();
 				i != m_connections.end(); ++i)
@@ -9118,7 +9118,7 @@ namespace libtorrent
 	
 	void torrent::set_allow_peers(bool b, bool graceful)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		if (m_allow_peers == b
 			&& m_graceful_pause_mode == graceful) return;
@@ -9145,7 +9145,7 @@ namespace libtorrent
 
 	void torrent::resume()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		if (m_allow_peers
@@ -9171,7 +9171,7 @@ namespace libtorrent
 
 	void torrent::do_resume()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (is_paused()) return;
 
 #ifndef TORRENT_DISABLE_EXTENSIONS
@@ -9205,7 +9205,7 @@ namespace libtorrent
 
 	void torrent::update_tracker_timer(ptime now)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (!m_announcing)
 		{
 #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING || defined TORRENT_ERROR_LOGGING
@@ -9286,7 +9286,7 @@ namespace libtorrent
 
 	void torrent::start_announcing()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (is_paused())
 		{
 #if defined TORRENT_VERBOSE_LOGGING || defined TORRENT_LOGGING
@@ -9346,7 +9346,7 @@ namespace libtorrent
 
 	void torrent::stop_announcing()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (!m_announcing) return;
 
 		error_code ec;
@@ -9385,7 +9385,7 @@ namespace libtorrent
 	void torrent::second_tick(int tick_interval_ms, int /* residual */)
 	{
 		TORRENT_ASSERT(want_tick());
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		boost::weak_ptr<torrent> self(shared_from_this());
@@ -9790,7 +9790,7 @@ namespace libtorrent
 
 	void torrent::refresh_explicit_cache(int cache_size)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (!ready_for_connections()) return;
 
 		if (m_abort) return;
@@ -10268,7 +10268,7 @@ namespace libtorrent
 
 	void torrent::request_time_critical_pieces()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(!upload_mode());
 
 		// build a list of peers and sort it by download_queue_time
@@ -10442,7 +10442,7 @@ namespace libtorrent
 
 	std::set<std::string> torrent::web_seeds(web_seed_entry::type_t type) const
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		std::set<std::string> ret;
 		for (std::list<web_seed_entry>::const_iterator i = m_web_seeds.begin()
 			, end(m_web_seeds.end()); i != end; ++i)
@@ -10496,7 +10496,7 @@ namespace libtorrent
 
 	void torrent::retry_web_seed(peer_connection* p, int retry)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		std::list<web_seed_entry>::iterator i = std::find_if(m_web_seeds.begin(), m_web_seeds.end()
 			, (boost::bind(&torrent_peer::connection, boost::bind(&web_seed_entry::peer_info, _1)) == p));
 
@@ -10525,7 +10525,7 @@ namespace libtorrent
 
 	bool torrent::try_connect_peer()
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(want_peers());
 
 		torrent_state st = get_policy_state();
@@ -10553,7 +10553,7 @@ namespace libtorrent
 
 	torrent_peer* torrent::add_peer(tcp::endpoint const& adr, int source, int flags)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 #if !TORRENT_USE_IPV6
 		if (!adr.address().is_v4()) return NULL;
@@ -10762,7 +10762,7 @@ namespace libtorrent
 #if !TORRENT_NO_FPU
 	void torrent::file_progress(std::vector<float>& fp)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (!valid_metadata())
 		{
 			fp.clear();
@@ -10786,7 +10786,7 @@ namespace libtorrent
 
 	void torrent::file_progress(std::vector<size_type>& fp, int flags)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		if (!valid_metadata())
 		{
 			fp.clear();
@@ -10972,7 +10972,7 @@ namespace libtorrent
 
 	void torrent::set_state(torrent_status::state_t s)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(s != 0); // this state isn't used anymore
 
 #if TORRENT_USE_ASSERTS
@@ -11303,7 +11303,7 @@ namespace libtorrent
 
 	void torrent::add_redundant_bytes(int b, torrent::wasted_reason_t reason)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(b > 0);
 		m_total_redundant_bytes += b;
 
@@ -11316,7 +11316,7 @@ namespace libtorrent
 
 	void torrent::add_failed_bytes(int b)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		TORRENT_ASSERT(b > 0);
 		m_total_failed_bytes += b;
 		m_stats_counters.inc_stats_counter(counters::recv_failed_bytes, b);
@@ -11324,7 +11324,7 @@ namespace libtorrent
 
 	int torrent::num_seeds() const
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 		INVARIANT_CHECK;
 
 		int ret = 0;
@@ -11338,7 +11338,7 @@ namespace libtorrent
 		, int response_code, error_code const& ec, const std::string& msg
 		, int retry_interval)
 	{
-		TORRENT_ASSERT(m_ses.is_single_thread());
+		TORRENT_ASSERT(is_single_thread());
 
 		INVARIANT_CHECK;