Add mse libs for replacing std::vector.

Also add configure flag --enable-stldebug
For now unused.

5 files changed, 3727 insertions, 0 deletions

diff --git a/configure.ac b/configure.ac
index 6ee8ce327..8da4ee8d0 100755
--- a/configure.ac
+++ b/configure.ac
@@ -92,6 +92,19 @@ esac],[glibcdebug_enabled=false])
 
 AM_CONDITIONAL(ENABLE_GLIBCDEBUG, test x$glibcdebug_enabled = xtrue)
 
+# Enable mse classes replacements for stl
+AC_ARG_ENABLE(stldebug,
+[  --enable-stldebug    Enable mse libs],
+[case "${enableval}" in
+  yes) stldebug_enabled=true
+ ;;
+  no)  stldebug_enabled=false
+ ;;
+  *) AC_MSG_ERROR(bad value ${enableval} for --enable-stldebug) ;;
+esac],[stldebug_enabled=false])
+
+AM_CONDITIONAL(ENABLE_STLDEBUG, test x$stldebug_enabled = xtrue)
+
 # Enable OpenGL error reporting
 AC_ARG_ENABLE(openglerrors,
 [  --enable-openglerrors    Enable OpenGL errors reporting],
diff --git a/src/Makefile.am b/src/Makefile.am
index 5bf511b92..af00bbdf8 100644
--- a/src/Makefile.am
+++ b/src/Makefile.am
@@ -132,6 +132,18 @@ manaplus_SOURCES =
 dyecmd_SOURCES =
 endif
 
+if ENABLE_STLDEBUG
+dyecmd_CXXFLAGS += -DENABLE_STL_DEBUG
+manaplus_CXXFLAGS += -DENABLE_STL_DEBUG -DDEBUG_DUMP_LEAKS
+
+manaplus_SOURCES += debug/mse/msemsevector.h \
+	      debug/mse/msemstdvector.h \
+	      debug/mse/mseprimitives.h
+dyecmd_SOURCES += debug/mse/msemsevector.h \
+	      debug/mse/msemstdvector.h \
+	      debug/mse/mseprimitives.h
+endif
+
 if MINGW
 manaplus_SOURCES += manaplus.rc
 dyecmd_SOURCES += manaplus.rc
diff --git a/src/debug/mse/msemsevector.h b/src/debug/mse/msemsevector.h
new file mode 100644
index 000000000..5ac2c4536
--- /dev/null
+++ b/src/debug/mse/msemsevector.h
@@ -0,0 +1,2433 @@
+
+// Copyright (c) 2015 Noah Lopez
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+#ifndef MSEMSEVECTOR_H
+#define MSEMSEVECTOR_H
+
+/*compiler specific defines*/
+#ifdef _MSC_VER
+#if (1700 > _MSC_VER)
+#define MSVC2010_COMPATIBLE 1
+#endif /*(1700 > _MSC_VER)*/
+#if (1900 > _MSC_VER)
+#define MSVC2013_COMPATIBLE 1
+#endif /*(1900 > _MSC_VER)*/
+#else /*_MSC_VER*/
+#if (defined(__GNUC__) || defined(__GNUG__))
+#define GPP_COMPATIBLE 1
+#if ((5 > __GNUC__) && (!defined(__clang__)))
+#define GPP4P8_COMPATIBLE 1
+#endif /*((5 > __GNUC__) && (!defined(__clang__)))*/
+#endif
+#endif /*_MSC_VER*/
+
+//define MSE_MSEVECTOR_USE_MSE_PRIMITIVES 1
+#ifdef MSE_MSEVECTOR_USE_MSE_PRIMITIVES
+#include "debug/mse/mseprimitives.h"
+#endif // MSE_MSEVECTOR_USE_MSE_PRIMITIVES
+
+#include <vector>
+#include <assert.h>
+#include <memory>
+#include <unordered_map>
+#include <functional>
+#include <climits>       // ULONG_MAX
+#include <stdexcept>
+
+#ifdef MSE_CUSTOM_THROW_DEFINITION
+#include <iostream>
+#define MSE_THROW(x) MSE_CUSTOM_THROW_DEFINITION(x)
+#else // MSE_CUSTOM_THROW_DEFINITION
+#define MSE_THROW(x) throw(x)
+#endif // MSE_CUSTOM_THROW_DEFINITION
+
+namespace mse {
+
+#ifdef MSE_MSEVECTOR_USE_MSE_PRIMITIVES
+	typedef mse::CSize_t msev_size_t;
+	typedef mse::CInt msev_int;
+	typedef bool msev_bool; // no added safety benefit to using mse::CBool in this case
+	#define msev_as_a_size_t as_a_size_t
+#else // MSE_MSEVECTOR_USE_MSE_PRIMITIVES
+#if SIZE_MAX <= ULONG_MAX
+#define MSE_MSEVECTOR_BASE_INTEGER_TYPE long int
+#else // SIZE_MAX <= ULONG_MAX
+#define MSE_MSEVECTOR_BASE_INTEGER_TYPE long long int
+#endif // SIZE_MAX <= ULONG_MAX
+
+	typedef size_t msev_size_t;
+	typedef MSE_MSEVECTOR_BASE_INTEGER_TYPE msev_int;
+	typedef bool msev_bool;
+	typedef size_t msev_as_a_size_t;
+#endif // MSE_MSEVECTOR_USE_MSE_PRIMITIVES
+
+
+	class msevector_range_error : public std::range_error { public:
+		using std::range_error::range_error;
+	};
+	class msevector_null_dereference_error : public std::logic_error { public:
+		using std::logic_error::logic_error;
+	};
+
+	/* msev_pointer behaves similar to native pointers. It's a bit safer in that it initializes to
+	nullptr by default and checks for attempted dereference of null pointers. */
+	template<typename _Ty>
+	class msev_pointer {
+	public:
+		msev_pointer() : m_ptr(nullptr) {}
+		msev_pointer(_Ty* ptr) : m_ptr(ptr) {}
+		msev_pointer(const msev_pointer<_Ty>& src) : m_ptr(src.m_ptr) {}
+
+		_Ty& operator*() const {
+#ifndef MSE_DISABLE_MSEAR_POINTER_CHECKS
+			if (nullptr == m_ptr) { MSE_THROW(msevector_null_dereference_error("attempt to dereference null pointer - mse::msev_pointer")); }
+#endif /*MSE_DISABLE_MSEAR_POINTER_CHECKS*/
+			return (*m_ptr);
+		}
+		_Ty* operator->() const {
+#ifndef MSE_DISABLE_MSEAR_POINTER_CHECKS
+			if (nullptr == m_ptr) { MSE_THROW(msevector_null_dereference_error("attempt to dereference null pointer - mse::msev_pointer")); }
+#endif /*MSE_DISABLE_MSEAR_POINTER_CHECKS*/
+			return m_ptr;
+		}
+		msev_pointer<_Ty>& operator=(_Ty* ptr) {
+			m_ptr = ptr;
+			return (*this);
+		}
+		bool operator==(const msev_pointer _Right_cref) const { return (_Right_cref.m_ptr == m_ptr); }
+		bool operator!=(const msev_pointer _Right_cref) const { return (!((*this) == _Right_cref)); }
+		bool operator==(const _Ty* _Right_cref) const { return (_Right_cref == m_ptr); }
+		bool operator!=(const _Ty* _Right_cref) const { return (!((*this) == _Right_cref)); }
+
+		bool operator!() const { return (!m_ptr); }
+		operator bool() const { return (m_ptr != nullptr); }
+
+		operator _Ty*() const { return m_ptr; }
+
+		_Ty* m_ptr;
+	};
+
+#ifndef _XSTD
+#define _XSTD ::std::
+#endif /*_XSTD*/
+
+	template<class _Ty, _Ty _Val>
+	struct integral_constant
+	{	// convenient template for integral constant types
+	static const _Ty value = _Val;
+
+	typedef _Ty value_type;
+	typedef integral_constant<_Ty, _Val> type;
+
+	operator value_type() const
+		{	// return stored value
+		return (value);
+		}
+	};
+
+	template<class _Iter>
+	struct _mse_Is_iterator
+	: public integral_constant<bool, !std::is_integral<_Iter>::value>
+	{	// tests for reasonable iterator candidate
+	};
+	template<typename _InIter>
+	using _mse_RequireInputIter = typename std::enable_if<
+		std::is_convertible<typename std::iterator_traits<_InIter>::iterator_category, std::input_iterator_tag>::value
+		//_mse_Is_iterator<_InIter>::value
+	>::type;
+
+	/* Note that, at the moment, msevector inherits publicly from std::vector. This is not intended to be a permanent
+		characteristic of msevector and any reference to, or interpretation of, an msevector as an std::vector is (and has
+		always been) depricated. msevector endeavors to support the subset of the std::vector interface that is compatible
+		with the security/safety goals of msevector. (The remaining part of the std::vector interface may be supported, as a
+		user option, for compatibility.)
+		In particular, keep in mind that std::vector does not have a virtual destructor, so deallocating an msevector as an
+		std::vector would result in memory leaks. */
+	template<class _Ty, class _A = std::allocator<_Ty> >
+	class msevector : public std::vector<_Ty, _A> {
+	public:
+		typedef std::vector<_Ty, _A> base_class;
+		typedef msevector<_Ty, _A> _Myt;
+
+		typedef typename base_class::value_type value_type;
+		//typedef typename base_class::size_type size_type;
+		typedef msev_size_t size_type;
+		//typedef typename base_class::difference_type difference_type;
+		typedef msev_int difference_type;
+		typedef typename base_class::pointer pointer;
+		typedef typename base_class::const_pointer const_pointer;
+		typedef typename base_class::reference reference;
+		typedef typename base_class::const_reference const_reference;
+
+		explicit msevector(const _A& _Al = _A())
+			: base_class(_Al), m_mmitset(*this) {
+			/*m_debug_size = size();*/
+		}
+		explicit msevector(size_type _N)
+			: base_class(msev_as_a_size_t(_N)), m_mmitset(*this) {
+			/*m_debug_size = size();*/
+		}
+		explicit msevector(size_type _N, const _Ty& _V, const _A& _Al = _A())
+			: base_class(msev_as_a_size_t(_N), _V, _Al), m_mmitset(*this) {
+			/*m_debug_size = size();*/
+		}
+		msevector(base_class&& _X) : base_class(std::move(_X)), m_mmitset(*this) { /*m_debug_size = size();*/ }
+		msevector(const base_class& _X) : base_class(_X), m_mmitset(*this) { /*m_debug_size = size();*/ }
+		msevector(_Myt&& _X) : base_class(std::move(_X)), m_mmitset(*this) { /*m_debug_size = size();*/ }
+		msevector(const _Myt& _X) : base_class(_X), m_mmitset(*this) { /*m_debug_size = size();*/ }
+		typedef typename base_class::const_iterator _It;
+		/* Note that safety cannot be guaranteed when using these constructors that take unsafe typename base_class::iterator and/or pointer parameters. */
+		msevector(_It _F, _It _L, const _A& _Al = _A()) : base_class(_F, _L, _Al), m_mmitset(*this) { /*m_debug_size = size();*/ }
+		msevector(const _Ty*  _F, const _Ty*  _L, const _A& _Al = _A()) : base_class(_F, _L, _Al), m_mmitset(*this) { /*m_debug_size = size();*/ }
+		template<class _Iter
+			//, class = typename std::enable_if<_mse_Is_iterator<_Iter>::value, void>::type
+			, class = _mse_RequireInputIter<_Iter> >
+		msevector(_Iter _First, _Iter _Last) : base_class(_First, _Last), m_mmitset(*this) { /*m_debug_size = size();*/ }
+		template<class _Iter
+			//, class = typename std::enable_if<_mse_Is_iterator<_Iter>::value, void>::type
+			, class = _mse_RequireInputIter<_Iter> >
+		//msevector(_Iter _First, _Iter _Last, const typename base_class::_Alloc& _Al) : base_class(_First, _Last, _Al), m_mmitset(*this) { /*m_debug_size = size();*/ }
+		msevector(_Iter _First, _Iter _Last, const _A& _Al) : base_class(_First, _Last, _Al), m_mmitset(*this) { /*m_debug_size = size();*/ }
+		_Myt& operator=(const base_class& _X) {
+			base_class::operator =(_X);
+			/*m_debug_size = size();*/
+			m_mmitset.reset();
+			return (*this);
+		}
+		_Myt& operator=(_Myt&& _X) {
+			operator=(std::move(static_cast<base_class&>(_X)));
+			m_mmitset.reset();
+			return (*this);
+		}
+		_Myt& operator=(const _Myt& _X) {
+			operator=(static_cast<const base_class&>(_X));
+			m_mmitset.reset();
+			return (*this);
+		}
+		void reserve(size_type _Count)
+		{	// determine new minimum length of allocated storage
+			auto original_capacity = msev_size_t((*this).capacity());
+
+			base_class::reserve(msev_as_a_size_t(_Count));
+
+			auto new_capacity = msev_size_t((*this).capacity());
+			bool realloc_occured = (new_capacity != original_capacity);
+			if (realloc_occured) {
+				m_mmitset.sync_iterators_to_index();
+			}
+		}
+		void shrink_to_fit() {	// reduce capacity
+			auto original_capacity = msev_size_t((*this).capacity());
+
+			base_class::shrink_to_fit();
+
+			auto new_capacity = msev_size_t((*this).capacity());
+			bool realloc_occured = (new_capacity != original_capacity);
+			if (realloc_occured) {
+				m_mmitset.sync_iterators_to_index();
+			}
+		}
+		void resize(size_type _N, const _Ty& _X = _Ty()) {
+			auto original_size = msev_size_t((*this).size());
+			auto original_capacity = msev_size_t((*this).capacity());
+			bool shrinking = (_N < original_size);
+
+			base_class::resize(msev_as_a_size_t(_N), _X);
+			/*m_debug_size = size();*/
+
+			if (shrinking) {
+				m_mmitset.invalidate_inclusive_range(_N, msev_size_t(original_size - 1));
+			}
+			m_mmitset.shift_inclusive_range(original_size, original_size, msev_size_t(_N) - original_size); /*shift the end markers*/
+			auto new_capacity = msev_size_t((*this).capacity());
+			bool realloc_occured = (new_capacity != original_capacity);
+			if (realloc_occured) {
+				m_mmitset.sync_iterators_to_index();
+			}
+		}
+		typename base_class::const_reference operator[](size_type _P) const {
+			return (*this).at(msev_as_a_size_t(_P));
+		}
+		typename base_class::reference operator[](size_type _P) {
+			return (*this).at(msev_as_a_size_t(_P));
+		}
+		typename base_class::reference front() {	// return first element of mutable sequence
+			if (0 == (*this).size()) { MSE_THROW(msevector_range_error("front() on empty - typename base_class::reference front() - msevector")); }
+			return base_class::front();
+		}
+		typename base_class::const_reference front() const {	// return first element of nonmutable sequence
+			if (0 == (*this).size()) { MSE_THROW(msevector_range_error("front() on empty - typename base_class::const_reference front() - msevector")); }
+			return base_class::front();
+		}
+		typename base_class::reference back() {	// return last element of mutable sequence
+			if (0 == (*this).size()) { MSE_THROW(msevector_range_error("back() on empty - typename base_class::reference back() - msevector")); }
+			return base_class::back();
+		}
+		typename base_class::const_reference back() const {	// return last element of nonmutable sequence
+			if (0 == (*this).size()) { MSE_THROW(msevector_range_error("back() on empty - typename base_class::const_reference back() - msevector")); }
+			return base_class::back();
+		}
+		void push_back(_Ty&& _X) {
+			if (m_mmitset.is_empty()) {
+				base_class::push_back(std::move(_X));
+			}
+			else {
+				auto original_size = msev_size_t((*this).size());
+				auto original_capacity = msev_size_t((*this).capacity());
+
+				base_class::push_back(std::move(_X));
+				/*m_debug_size = size();*/
+
+				assert((original_size + 1) == msev_size_t((*this).size()));
+				m_mmitset.shift_inclusive_range(original_size, original_size, 1); /*shift the end markers*/
+				auto new_capacity = msev_size_t((*this).capacity());
+				bool realloc_occured = (new_capacity != original_capacity);
+				if (realloc_occured) {
+					m_mmitset.sync_iterators_to_index();
+				}
+			}
+		}
+		void push_back(const _Ty& _X) {
+			if (m_mmitset.is_empty()) {
+				base_class::push_back(_X);
+			}
+			else {
+				auto original_size = msev_size_t((*this).size());
+				auto original_capacity = msev_size_t((*this).capacity());
+
+				base_class::push_back(_X);
+				/*m_debug_size = size();*/
+
+				assert((original_size + 1) == msev_size_t((*this).size()));
+				m_mmitset.shift_inclusive_range(original_size, original_size, 1); /*shift the end markers*/
+				auto new_capacity = msev_size_t((*this).capacity());
+				bool realloc_occured = (new_capacity != original_capacity);
+				if (realloc_occured) {
+					m_mmitset.sync_iterators_to_index();
+				}
+			}
+		}
+		void pop_back() {
+			if (m_mmitset.is_empty()) {
+				base_class::pop_back();
+			}
+			else {
+				auto original_size = msev_size_t((*this).size());
+				auto original_capacity = msev_size_t((*this).capacity());
+
+				if (0 == original_size) { MSE_THROW(msevector_range_error("pop_back() on empty - void pop_back() - msevector")); }
+				base_class::pop_back();
+				/*m_debug_size = size();*/
+
+				assert((original_size - 1) == msev_size_t((*this).size()));
+				m_mmitset.invalidate_inclusive_range(msev_size_t(original_size - 1), msev_size_t(original_size - 1));
+				m_mmitset.shift_inclusive_range(original_size, original_size, -1); /*shift the end markers*/
+				auto new_capacity = msev_size_t((*this).capacity());
+				bool realloc_occured = (new_capacity != original_capacity);
+				if (realloc_occured) {
+					m_mmitset.sync_iterators_to_index();
+				}
+			}
+		}
+		void assign(_It _F, _It _L) {
+			base_class::assign(_F, _L);
+			/*m_debug_size = size();*/
+			m_mmitset.reset();
+		}
+		template<class _Iter>
+		void assign(_Iter _First, _Iter _Last) {	// assign [_First, _Last)
+			base_class::assign(_First, _Last);
+			/*m_debug_size = size();*/
+			m_mmitset.reset();
+		}
+		void assign(size_type _N, const _Ty& _X = _Ty()) {
+			base_class::assign(msev_as_a_size_t(_N), _X);
+			/*m_debug_size = size();*/
+			m_mmitset.reset();
+		}
+		typename base_class::iterator insert(typename base_class::const_iterator _P, _Ty&& _X) {
+			return (emplace(_P, std::move(_X)));
+		}
+		typename base_class::iterator insert(typename base_class::const_iterator _P, const _Ty& _X = _Ty()) {
+			if (m_mmitset.is_empty()) {
+				typename base_class::iterator retval = base_class::insert(_P, _X);
+				/*m_debug_size = size();*/
+				return retval;
+			}
+			else {
+				msev_int di = std::distance(base_class::cbegin(), _P);
+				msev_size_t d = msev_size_t(di);
+				if ((0 > di) || (msev_size_t((*this).size()) < di)) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); }
+
+				auto original_size = msev_size_t((*this).size());
+				auto original_capacity = msev_size_t((*this).capacity());
+
+				typename base_class::iterator retval = base_class::insert(_P, _X);
+				/*m_debug_size = size();*/
+
+				assert((original_size + 1) == msev_size_t((*this).size()));
+				assert(di == std::distance(base_class::begin(), retval));
+				m_mmitset.shift_inclusive_range(d, original_size, 1);
+				auto new_capacity = msev_size_t((*this).capacity());
+				bool realloc_occured = (new_capacity != original_capacity);
+				if (realloc_occured) {
+					m_mmitset.sync_iterators_to_index();
+				}
+				return retval;
+			}
+		}
+
+#if !(defined(GPP4P8_COMPATIBLE))
+		typename base_class::iterator insert(typename base_class::const_iterator _P, size_type _M, const _Ty& _X) {
+			if (m_mmitset.is_empty()) {
+				typename base_class::iterator retval = base_class::insert(_P, msev_as_a_size_t(_M), _X);
+				/*m_debug_size = size();*/
+				return retval;
+			}
+			else {
+				msev_int di = std::distance(base_class::cbegin(), _P);
+				msev_size_t d = msev_size_t(di);
+				if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); }
+
+				auto original_size = msev_size_t((*this).size());
+				auto original_capacity = msev_size_t((*this).capacity());
+
+				typename base_class::iterator retval = base_class::insert(_P, msev_as_a_size_t(_M), _X);
+				/*m_debug_size = size();*/
+
+				assert((original_size + _M) == msev_size_t((*this).size()));
+				assert(di == std::distance(base_class::begin(), retval));
+				m_mmitset.shift_inclusive_range(d, original_size, msev_int(_M));
+				auto new_capacity = msev_size_t((*this).capacity());
+				bool realloc_occured = (new_capacity != original_capacity);
+				if (realloc_occured) {
+					m_mmitset.sync_iterators_to_index();
+				}
+				return retval;
+			}
+		}
+		template<class _Iter
+			//>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type
+			, class = _mse_RequireInputIter<_Iter> >
+		typename base_class::iterator insert(typename base_class::const_iterator _Where, _Iter _First, _Iter _Last) {	// insert [_First, _Last) at _Where
+			if (m_mmitset.is_empty()) {
+				auto retval = base_class::insert(_Where, _First, _Last);
+				/*m_debug_size = size();*/
+				return retval;
+			}
+			else {
+				msev_int di = std::distance(base_class::cbegin(), _Where);
+				msev_size_t d = msev_size_t(di);
+				if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); }
+
+				auto _M = msev_int(std::distance(_First, _Last));
+				auto original_size = msev_size_t((*this).size());
+				auto original_capacity = msev_size_t((*this).capacity());
+
+				//if (0 > _M) { MSE_THROW(msevector_range_error("invalid argument - typename base_class::iterator insert() - msevector")); }
+				auto retval = base_class::insert(_Where, _First, _Last);
+				/*m_debug_size = size();*/
+
+				assert((original_size + _M) == msev_size_t((*this).size()));
+				assert(di == std::distance(base_class::begin(), retval));
+				m_mmitset.shift_inclusive_range(d, original_size, _M);
+				auto new_capacity = msev_size_t((*this).capacity());
+				bool realloc_occured = (new_capacity != original_capacity);
+				if (realloc_occured) {
+					m_mmitset.sync_iterators_to_index();
+				}
+				return retval;
+			}
+		}
+
+#else /*!(defined(GPP4P8_COMPATIBLE))*/
+
+		/*typename base_class::iterator*/
+		void
+			/* g++4.8 seems to be using the c++98 version of this insert function instead of the c++11 version. */
+			insert(typename base_class::/*const_*/iterator _P, size_t _M, const _Ty& _X) {
+				msev_int di = std::distance(base_class::/*c*/begin(), _P);
+				msev_size_t d = msev_size_t(di);
+				if ((0 > di) || (msev_size_t((*this).size()) < di)) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); }
+
+				auto original_size = msev_size_t((*this).size());
+				auto original_capacity = msev_size_t((*this).capacity());
+
+				/*typename base_class::iterator retval =*/
+					base_class::insert(_P, _M, _X);
+				/*m_debug_size = size();*/
+
+				assert((original_size + _M) == msev_size_t((*this).size()));
+				/*assert(di == std::distance(base_class::begin(), retval));*/
+				m_mmitset.shift_inclusive_range(d, original_size, _M);
+				auto new_capacity = msev_size_t((*this).capacity());
+				bool realloc_occured = (new_capacity != original_capacity);
+				if (realloc_occured) {
+					m_mmitset.sync_iterators_to_index();
+				}
+				/*return retval;*/
+			}
+		template<class _Iter
+			//>typename std::enable_if<_mse_Is_iterator<_Iter>::value, void>::type
+			, class = _mse_RequireInputIter<_Iter> > void
+		insert(typename base_class::/*const_*/iterator _Where, _Iter _First, _Iter _Last) {	// insert [_First, _Last) at _Where
+				msev_int di = std::distance(base_class::/*c*/begin(), _Where);
+				msev_size_t d = msev_size_t(di);
+				if ((0 > di) || (msev_size_t((*this).size()) < di)) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); }
+
+				auto _M = msev_int(std::distance(_First, _Last));
+				auto original_size = msev_size_t((*this).size());
+				auto original_capacity = msev_size_t((*this).capacity());
+
+				//if (0 > _M) { MSE_THROW(msevector_range_error("invalid argument - typename base_class::iterator insert() - msevector")); }
+				/*auto retval =*/
+					base_class::insert(_Where, _First, _Last);
+				/*m_debug_size = size();*/
+
+				assert((original_size + _M) == msev_size_t((*this).size()));
+				/*assert(di == std::distance(base_class::begin(), retval));*/
+				m_mmitset.shift_inclusive_range(d, original_size, _M);
+				auto new_capacity = msev_size_t((*this).capacity());
+				bool realloc_occured = (new_capacity != original_capacity);
+				if (realloc_occured) {
+					m_mmitset.sync_iterators_to_index();
+				}
+				/*return retval;*/
+			}
+#endif /*!(defined(GPP4P8_COMPATIBLE))*/
+
+		template<class ..._Valty>
+		void emplace_back(_Valty&& ..._Val)
+		{	// insert by moving into element at end
+			if (m_mmitset.is_empty()) {
+				base_class::emplace_back(std::forward<_Valty>(_Val)...);
+				/*m_debug_size = size();*/
+			}
+			else {
+				auto original_size = msev_size_t((*this).size());
+				auto original_capacity = msev_size_t((*this).capacity());
+
+				base_class::emplace_back(std::forward<_Valty>(_Val)...);
+				/*m_debug_size = size();*/
+
+				assert((original_size + 1) == msev_size_t((*this).size()));
+				m_mmitset.shift_inclusive_range(original_size, original_size, 1); /*shift the end markers*/
+				auto new_capacity = msev_size_t((*this).capacity());
+				bool realloc_occured = (new_capacity != original_capacity);
+				if (realloc_occured) {
+					m_mmitset.sync_iterators_to_index();
+				}
+			}
+		}
+		template<class ..._Valty>
+#if !(defined(GPP4P8_COMPATIBLE))
+		typename base_class::iterator emplace(typename base_class::const_iterator _Where, _Valty&& ..._Val)
+		{	// insert by moving _Val at _Where
+#else /*!(defined(GPP4P8_COMPATIBLE))*/
+		typename base_class::iterator emplace(typename base_class::/*const_*/iterator _Where, _Valty&& ..._Val)
+		{	// insert by moving _Val at _Where
+#endif /*!(defined(GPP4P8_COMPATIBLE))*/
+
+			if (m_mmitset.is_empty()) {
+				auto retval = base_class::emplace(_Where, std::forward<_Valty>(_Val)...);
+				/*m_debug_size = size();*/
+				return retval;
+			}
+			else {
+
+#if !(defined(GPP4P8_COMPATIBLE))
+				msev_int di = std::distance(base_class::cbegin(), _Where);
+#else /*!(defined(GPP4P8_COMPATIBLE))*/
+				msev_int di = std::distance(base_class::/*c*/begin(), _Where);
+#endif /*!(defined(GPP4P8_COMPATIBLE))*/
+
+				msev_size_t d = msev_size_t(di);
+				if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator emplace() - msevector")); }
+
+				auto original_size = msev_size_t((*this).size());
+				auto original_capacity = msev_size_t((*this).capacity());
+
+				auto retval = base_class::emplace(_Where, std::forward<_Valty>(_Val)...);
+				/*m_debug_size = size();*/
+
+				assert((original_size + 1) == msev_size_t((*this).size()));
+				assert(di == std::distance(base_class::begin(), retval));
+				m_mmitset.shift_inclusive_range(d, original_size, 1);
+				auto new_capacity = msev_size_t((*this).capacity());
+				bool realloc_occured = (new_capacity != original_capacity);
+				if (realloc_occured) {
+					m_mmitset.sync_iterators_to_index();
+				}
+				return retval;
+			}
+		}
+		typename base_class::iterator erase(typename base_class::const_iterator _P) {
+			if (m_mmitset.is_empty()) {
+				typename base_class::iterator retval = base_class::erase(_P);
+				/*m_debug_size = size();*/
+				return retval;
+			}
+			else {
+				msev_int di = std::distance(base_class::cbegin(), _P);
+				msev_size_t d = msev_size_t(di);
+				if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator erase() - msevector")); }
+
+				auto original_size = msev_size_t((*this).size());
+				auto original_capacity = msev_size_t((*this).capacity());
+
+				if (base_class::end() == _P) { MSE_THROW(msevector_range_error("invalid argument - typename base_class::iterator erase(typename base_class::const_iterator _P) - msevector")); }
+				typename base_class::iterator retval = base_class::erase(_P);
+				/*m_debug_size = size();*/
+
+				assert((original_size - 1) == msev_size_t((*this).size()));
+				assert(di == std::distance(base_class::begin(), retval));
+				{
+					m_mmitset.invalidate_inclusive_range(d, d);
+					m_mmitset.shift_inclusive_range(msev_size_t(d + 1), original_size, -1);
+				}
+				auto new_capacity = msev_size_t((*this).capacity());
+				bool realloc_occured = (new_capacity != original_capacity);
+				if (realloc_occured) {
+					m_mmitset.sync_iterators_to_index();
+				}
+				return retval;
+			}
+		}
+		typename base_class::iterator erase(typename base_class::const_iterator _F, typename base_class::const_iterator _L) {
+			if (m_mmitset.is_empty()) {
+				typename base_class::iterator retval = base_class::erase(_F, _L);
+				/*m_debug_size = size();*/
+				return retval;
+			}
+			else {
+				msev_int di = std::distance(base_class::cbegin(), _F);
+				msev_size_t d = msev_size_t(di);
+				if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator erase() - msevector")); }
+				msev_int di2 = std::distance(base_class::cbegin(), _L);
+				msev_size_t d2 = msev_size_t(di2);
+				if ((0 > di2) || ((*this).size() < msev_size_t(di2))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator erase() - msevector")); }
+
+				auto _M = msev_int(std::distance(_F, _L));
+				auto original_size = msev_size_t((*this).size());
+				auto original_capacity = msev_size_t((*this).capacity());
+
+				if ((base_class::end() == _F)/* || (0 > _M)*/) { MSE_THROW(msevector_range_error("invalid argument - typename base_class::iterator erase(typename base_class::iterator _F, typename base_class::iterator _L) - msevector")); }
+				typename base_class::iterator retval = base_class::erase(_F, _L);
+				/*m_debug_size = size();*/
+
+				assert((original_size - _M) == msev_size_t((*this).size()));
+				assert(di == std::distance(base_class::begin(), retval));
+				{
+					if (1 <= _M) {
+						m_mmitset.invalidate_inclusive_range(d, msev_size_t(d + _M - 1));
+					}
+					m_mmitset.shift_inclusive_range(msev_size_t(d + _M), original_size, -_M);
+				}
+				auto new_capacity = msev_size_t((*this).capacity());
+				bool realloc_occured = (new_capacity != original_capacity);
+				if (realloc_occured) {
+					m_mmitset.sync_iterators_to_index();
+				}
+				return retval;
+			}
+		}
+		void clear() {
+			base_class::clear();
+			/*m_debug_size = size();*/
+			m_mmitset.reset();
+		}
+		void swap(base_class& _X) {
+			base_class::swap(_X);
+			/*m_debug_size = size();*/
+			m_mmitset.reset();
+		}
+		void swap(_Myt& _X) {
+			swap(static_cast<base_class&>(_X));
+			m_mmitset.reset();
+		}
+
+		msevector(_XSTD initializer_list<typename base_class::value_type> _Ilist,
+			const _A& _Al = _A())
+			: base_class(_Ilist, _Al), m_mmitset(*this) {	// construct from initializer_list
+			/*m_debug_size = size();*/
+		}
+		_Myt& operator=(_XSTD initializer_list<typename base_class::value_type> _Ilist) {	// assign initializer_list
+			operator=(static_cast<base_class>(_Ilist));
+			m_mmitset.reset();
+			return (*this);
+		}
+		void assign(_XSTD initializer_list<typename base_class::value_type> _Ilist) {	// assign initializer_list
+			base_class::assign(_Ilist);
+			/*m_debug_size = size();*/
+			m_mmitset.reset();
+		}
+#if defined(GPP4P8_COMPATIBLE)
+		/* g++4.8 seems to be (incorrectly) using the c++98 version of this insert function instead of the c++11 version. */
+		/*typename base_class::iterator*/void insert(typename base_class::/*const_*/iterator _Where, _XSTD initializer_list<typename base_class::value_type> _Ilist) {	// insert initializer_list
+			msev_int di = std::distance(base_class::/*c*/begin(), _Where);
+			msev_size_t d = msev_size_t(di);
+			if ((0 > di) || (msev_size_t((*this).size()) < di)) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); }
+
+			auto _M = _Ilist.size();
+			auto original_size = msev_size_t((*this).size());
+			auto original_capacity = msev_size_t((*this).capacity());
+
+			/*auto retval = */base_class::insert(_Where, _Ilist);
+			/*m_debug_size = size();*/
+
+			assert((original_size + _M) == msev_size_t((*this).size()));
+			/*assert(di == std::distance(base_class::begin(), retval));*/
+			m_mmitset.shift_inclusive_range(d, original_size, _M);
+			auto new_capacity = msev_size_t((*this).capacity());
+			bool realloc_occured = (new_capacity != original_capacity);
+			if (realloc_occured) {
+				m_mmitset.sync_iterators_to_index();
+			}
+			/*return retval;*/
+		}
+#else /*defined(GPP4P8_COMPATIBLE)*/
+		typename base_class::iterator insert(typename base_class::const_iterator _Where, _XSTD initializer_list<typename base_class::value_type> _Ilist) {	// insert initializer_list
+			if (m_mmitset.is_empty()) {
+				auto retval = base_class::insert(_Where, _Ilist);
+				/*m_debug_size = size();*/
+				return retval;
+			}
+			else {
+				msev_int di = std::distance(base_class::cbegin(), _Where);
+				msev_size_t d = msev_size_t(di);
+				if ((0 > di) || ((*this).size() < msev_size_t(di))) { MSE_THROW(msevector_range_error("index out of range - typename base_class::iterator insert() - msevector")); }
+
+				auto _M = _Ilist.size();
+				auto original_size = msev_size_t((*this).size());
+				auto original_capacity = msev_size_t((*this).capacity());
+
+				auto retval = base_class::insert(_Where, _Ilist);
+				/*m_debug_size = size();*/
+
+				assert((original_size + _M) == msev_size_t((*this).size()));
+				assert(di == std::distance(base_class::begin(), retval));
+				m_mmitset.shift_inclusive_range(d, original_size, msev_int(_M));
+				auto new_capacity = msev_size_t((*this).capacity());
+				bool realloc_occured = (new_capacity != original_capacity);
+				if (realloc_occured) {
+					m_mmitset.sync_iterators_to_index();
+				}
+				return retval;
+			}
+		}
+#endif /*defined(GPP4P8_COMPATIBLE)*/
+
+		//size_t m_debug_size;
+
+		class random_access_const_iterator_base : public std::iterator<std::random_access_iterator_tag, value_type, difference_type, const_pointer, const_reference> {};
+		class random_access_iterator_base : public std::iterator<std::random_access_iterator_tag, value_type, difference_type, pointer, reference> {};
+
+		/* mm_const_iterator_type acts much like a list iterator. */
+		class mm_const_iterator_type : public random_access_const_iterator_base {
+		public:
+			typedef typename base_class::const_iterator::iterator_category iterator_category;
+			typedef typename base_class::const_iterator::value_type value_type;
+			//typedef typename base_class::const_iterator::difference_type difference_type;
+			typedef msev_int difference_type;
+			typedef difference_type distance_type;	// retained
+			typedef typename base_class::const_iterator::pointer pointer;
+			typedef typename base_class::const_iterator::pointer const_pointer;
+			typedef typename base_class::const_iterator::reference reference;
+			typedef typename base_class::const_reference const_reference;
+
+			void reset() { set_to_end_marker(); }
+			bool points_to_an_item() const {
+				if (m_points_to_an_item) { assert((1 <= m_owner_cptr->size()) && (m_index < m_owner_cptr->size())); return true; }
+				else { assert(!((1 <= m_owner_cptr->size()) && (m_index < m_owner_cptr->size()))); return false; }
+			}
+			bool points_to_end_marker() const {
+				if (false == points_to_an_item()) { assert(m_index == m_owner_cptr->size()); return true; }
+				else { return false; }
+			}
+			bool points_to_beginning() const {
+				if (0 == m_index) { return true; }
+				else { return false; }
+			}
+			/* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */
+			bool has_next_item_or_end_marker() const { return points_to_an_item(); } //his is
+			/* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */
+			bool has_next() const { return has_next_item_or_end_marker(); }
+			bool has_previous() const { return (!points_to_beginning()); }
+			void set_to_beginning() {
+				m_index = 0;
+				if (1 <= m_owner_cptr->size()) {
+					m_points_to_an_item = true;
+				}
+				else { assert(false == m_points_to_an_item); }
+			}
+			void set_to_end_marker() {
+				m_index = m_owner_cptr->size();
+				m_points_to_an_item = false;
+			}
+			void set_to_next() {
+				if (points_to_an_item()) {
+					m_index += 1;
+					if (m_owner_cptr->size() <= m_index) {
+						(*this).m_points_to_an_item = false;
+						if (m_owner_cptr->size() < m_index) { assert(false); reset(); }
+					}
+				}
+				else {
+					MSE_THROW(msevector_range_error("attempt to use invalid const_item_pointer - void set_to_next() - mm_const_iterator_type - msevector"));
+				}
+			}
+			void set_to_previous() {
+				if (has_previous()) {
+					m_index -= 1;
+					(*this).m_points_to_an_item = true;
+				}
+				else {
+					MSE_THROW(msevector_range_error("attempt to use invalid const_item_pointer - void set_to_previous() - mm_const_iterator_type - msevector"));
+				}
+			}
+			mm_const_iterator_type& operator ++() { (*this).set_to_next(); return (*this); }
+			mm_const_iterator_type operator++(int) { mm_const_iterator_type _Tmp = *this; ++*this; return (_Tmp); }
+			mm_const_iterator_type& operator --() { (*this).set_to_previous(); return (*this); }
+			mm_const_iterator_type operator--(int) { mm_const_iterator_type _Tmp = *this; --*this; return (_Tmp); }
+			void advance(difference_type n) {
+				auto new_index = msev_int(m_index) + n;
+				if ((0 > new_index) || (m_owner_cptr->size() < msev_size_t(new_index))) {
+					MSE_THROW(msevector_range_error("index out of range - void advance(difference_type n) - mm_const_iterator_type - msevector"));
+				}
+				else {
+					m_index = msev_size_t(new_index);
+					if (m_owner_cptr->size() <= m_index) {
+						(*this).m_points_to_an_item = false;
+					}
+					else {
+						(*this).m_points_to_an_item = true;
+					}
+				}
+			}
+			void regress(difference_type n) { advance(-n); }
+			mm_const_iterator_type& operator +=(difference_type n) { (*this).advance(n); return (*this); }
+			mm_const_iterator_type& operator -=(difference_type n) { (*this).regress(n); return (*this); }
+			mm_const_iterator_type operator+(difference_type n) const {
+				mm_const_iterator_type retval(*this);
+				retval = (*this);
+				retval.advance(n);
+				return retval;
+			}
+			mm_const_iterator_type operator-(difference_type n) const { return ((*this) + (-n)); }
+			difference_type operator-(const mm_const_iterator_type &rhs) const {
+				if ((rhs.m_owner_cptr) != ((*this).m_owner_cptr)) { MSE_THROW(msevector_range_error("invalid argument - difference_type operator-(const mm_const_iterator_type &rhs) const - msevector::mm_const_iterator_type")); }
+				auto retval = difference_type((*this).m_index) - difference_type(rhs.m_index);
+				assert(difference_type(m_owner_cptr->size()) >= retval);
+				return retval;
+			}
+			const_reference operator*() const {
+				return m_owner_cptr->at(msev_as_a_size_t(m_index));
+			}
+			const_reference item() const { return operator*(); }
+			const_reference previous_item() const {
+				return m_owner_cptr->at(msev_as_a_size_t(m_index - 1));
+			}
+			const_pointer operator->() const {
+				return &(m_owner_cptr->at(msev_as_a_size_t(m_index)));
+			}
+			const_reference operator[](difference_type _Off) const { return (*m_owner_cptr).at(msev_as_a_size_t(difference_type(m_index) + _Off)); }
+			/*
+			mm_const_iterator_type& operator=(const typename base_class::const_iterator& _Right_cref)
+			{
+			msev_int d = std::distance<typename base_class::iterator>(m_owner_cptr->cbegin(), _Right_cref);
+			if ((0 <= d) && (m_owner_cptr->size() >= d)) {
+			if (m_owner_cptr->size() == d) {
+			assert(m_owner_cptr->cend() == _Right_cref);
+			m_points_to_an_item = false;
+			} else {
+			m_points_to_an_item = true;
+			}
+			m_index = msev_size_t(d);
+			base_class::const_iterator::operator=(_Right_cref);
+			}
+			else {
+			MSE_THROW(msevector_range_error("doesn't seem to be a valid assignment value - mm_const_iterator_type& operator=(const typename base_class::const_iterator& _Right_cref) - mm_const_iterator_type - msevector"));
+			}
+			return (*this);
+			}
+			*/
+			mm_const_iterator_type& operator=(const mm_const_iterator_type& _Right_cref)
+			{
+				if (((*this).m_owner_cptr) == (_Right_cref.m_owner_cptr)) {
+					assert((*this).m_owner_cptr->size() >= _Right_cref.m_index);
+					(*this).m_points_to_an_item = _Right_cref.m_points_to_an_item;
+					(*this).m_index = _Right_cref.m_index;
+				}
+				else {
+					MSE_THROW(msevector_range_error("doesn't seem to be a valid assignment value - mm_const_iterator_type& operator=(const typename base_class::iterator& _Right_cref) - mm_const_iterator_type - msevector"));
+				}
+				return (*this);
+			}
+			bool operator==(const mm_const_iterator_type& _Right_cref) const {
+				if (((*this).m_owner_cptr) != (_Right_cref.m_owner_cptr)) { MSE_THROW(msevector_range_error("invalid argument - mm_const_iterator_type& operator==(const mm_const_iterator_type& _Right) - mm_const_iterator_type - msevector")); }
+				return (_Right_cref.m_index == m_index);
+			}
+			bool operator!=(const mm_const_iterator_type& _Right_cref) const { return (!(_Right_cref == (*this))); }
+			bool operator<(const mm_const_iterator_type& _Right) const {
+				if (((*this).m_owner_cptr) != (_Right.m_owner_cptr)) { MSE_THROW(msevector_range_error("invalid argument - mm_const_iterator_type& operator<(const mm_const_iterator_type& _Right) - mm_const_iterator_type - msevector")); }
+				return (m_index < _Right.m_index);
+			}
+			bool operator<=(const mm_const_iterator_type& _Right) const { return (((*this) < _Right) || (_Right == (*this))); }
+			bool operator>(const mm_const_iterator_type& _Right) const { return (!((*this) <= _Right)); }
+			bool operator>=(const mm_const_iterator_type& _Right) const { return (!((*this) < _Right)); }
+			void set_to_const_item_pointer(const mm_const_iterator_type& _Right_cref) {
+				(*this) = _Right_cref;
+			}
+			void invalidate_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last) {
+				if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) {
+					(*this).reset();
+				}
+			}
+			void shift_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last, msev_int shift) {
+				if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) {
+					auto new_index = (*this).m_index + shift;
+					if ((0 > new_index) || (m_owner_cptr->size() < new_index)) {
+						MSE_THROW(msevector_range_error("void shift_inclusive_range() - mm_const_iterator_type - msevector"));
+					}
+					else {
+						(*this).m_index = msev_size_t(new_index);
+						(*this).sync_const_iterator_to_index();
+					}
+				}
+			}
+			msev_size_t position() const {
+				return m_index;
+			}
+			operator typename base_class::const_iterator() const {
+				typename base_class::const_iterator retval = (*m_owner_cptr).cbegin();
+				retval += msev_as_a_size_t(m_index);
+				return retval;
+			}
+
+			/* We actually want to make this constructor private, but doing so seems to break std::make_shared<mm_const_iterator_type>.  */
+			mm_const_iterator_type(const _Myt& owner_cref) : m_owner_cptr(&owner_cref) { set_to_beginning(); }
+		private:
+			mm_const_iterator_type(const mm_const_iterator_type& src_cref) : m_owner_cptr(src_cref.m_owner_cptr) { (*this) = src_cref; }
+			void sync_const_iterator_to_index() {
+				assert(m_owner_cptr->size() >= (*this).m_index);
+			}
+			msev_bool m_points_to_an_item = false;
+			msev_size_t m_index = 0;
+			const _Myt* m_owner_cptr = nullptr;
+			friend class mm_iterator_set_type;
+			friend class /*_Myt*/msevector<_Ty, _A>;
+			friend class mm_iterator_type;
+		};
+		/* mm_iterator_type acts much like a list iterator. */
+		class mm_iterator_type : random_access_iterator_base {
+		public:
+			typedef typename base_class::iterator::iterator_category iterator_category;
+			typedef typename base_class::iterator::value_type value_type;
+			//typedef typename base_class::iterator::difference_type difference_type;
+			typedef msev_int difference_type;
+			typedef difference_type distance_type;	// retained
+			typedef typename base_class::iterator::pointer pointer;
+			typedef typename base_class::iterator::reference reference;
+
+			void reset() { set_to_end_marker(); }
+			bool points_to_an_item() const {
+				if (m_points_to_an_item) { assert((1 <= m_owner_ptr->size()) && (m_index < m_owner_ptr->size())); return true; }
+				else { assert(!((1 <= m_owner_ptr->size()) && (m_index < m_owner_ptr->size())));  return false; }
+			}
+			bool points_to_end_marker() const {
+				if (false == points_to_an_item()) { assert(m_index == m_owner_ptr->size()); return true; }
+				else { return false; }
+			}
+			bool points_to_beginning() const {
+				if (0 == m_index) { return true; }
+				else { return false; }
+			}
+			/* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */
+			bool has_next_item_or_end_marker() const { return points_to_an_item(); }
+			/* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */
+			bool has_next() const { return has_next_item_or_end_marker(); }
+			bool has_previous() const { return (!points_to_beginning()); }
+			void set_to_beginning() {
+				m_index = 0;
+				if (1 <= m_owner_ptr->size()) {
+					m_points_to_an_item = true;
+				}
+				else { assert(false == m_points_to_an_item); }
+			}
+			void set_to_end_marker() {
+				m_index = m_owner_ptr->size();
+				m_points_to_an_item = false;
+			}
+			void set_to_next() {
+				if (points_to_an_item()) {
+					m_index += 1;
+					if (m_owner_ptr->size() <= m_index) {
+						(*this).m_points_to_an_item = false;
+						if (m_owner_ptr->size() < m_index) { assert(false); reset(); }
+					}
+				}
+				else {
+					MSE_THROW(msevector_range_error("attempt to use invalid item_pointer - void set_to_next() - mm_const_iterator_type - msevector"));
+				}
+			}
+			void set_to_previous() {
+				if (has_previous()) {
+					m_index -= 1;
+					(*this).m_points_to_an_item = true;
+				}
+				else {
+					MSE_THROW(msevector_range_error("attempt to use invalid item_pointer - void set_to_previous() - mm_iterator_type - msevector"));
+				}
+			}
+			mm_iterator_type& operator ++() { (*this).set_to_next(); return (*this); }
+			mm_iterator_type operator++(int) { mm_iterator_type _Tmp = *this; ++*this; return (_Tmp); }
+			mm_iterator_type& operator --() { (*this).set_to_previous(); return (*this); }
+			mm_iterator_type operator--(int) { mm_iterator_type _Tmp = *this; --*this; return (_Tmp); }
+			void advance(difference_type n) {
+				auto new_index = msev_int(m_index) + n;
+				if ((0 > new_index) || (m_owner_ptr->size() < msev_size_t(new_index))) {
+					MSE_THROW(msevector_range_error("index out of range - void advance(difference_type n) - mm_iterator_type - msevector"));
+				}
+				else {
+					m_index = msev_size_t(new_index);
+					if (m_owner_ptr->size() <= m_index) {
+						(*this).m_points_to_an_item = false;
+					}
+					else {
+						(*this).m_points_to_an_item = true;
+					}
+				}
+			}
+			void regress(int n) { advance(-n); }
+			mm_iterator_type& operator +=(difference_type n) { (*this).advance(n); return (*this); }
+			mm_iterator_type& operator -=(difference_type n) { (*this).regress(n); return (*this); }
+			mm_iterator_type operator+(difference_type n) const {
+				mm_iterator_type retval(*this);
+				retval = (*this);
+				retval.advance(n);
+				return retval;
+			}
+			mm_iterator_type operator-(difference_type n) const { return ((*this) + (-n)); }
+			difference_type operator-(const mm_iterator_type& rhs) const {
+				if ((rhs.m_owner_ptr) != ((*this).m_owner_ptr)) { MSE_THROW(msevector_range_error("invalid argument - difference_type operator-(const mm_iterator_type& rhs) const - msevector::mm_iterator_type")); }
+				auto retval = difference_type((*this).m_index) - difference_type(rhs.m_index);
+				assert(difference_type(m_owner_ptr->size()) >= retval);
+				return retval;
+			}
+			reference operator*() const {
+				return m_owner_ptr->at(msev_as_a_size_t(m_index));
+			}
+			reference item() const { return operator*(); }
+			reference previous_item() const {
+				return m_owner_ptr->at(msev_as_a_size_t(m_index - 1));
+			}
+			pointer operator->() const {
+				return &(m_owner_ptr->at(msev_as_a_size_t(m_index)));
+			}
+			reference operator[](difference_type _Off) const { return (*m_owner_ptr).at(msev_as_a_size_t(difference_type(m_index) + _Off)); }
+			/*
+			mm_iterator_type& operator=(const typename base_class::iterator& _Right_cref)
+			{
+			msev_int d = std::distance<typename base_class::iterator>(m_owner_ptr->begin(), _Right_cref);
+			if ((0 <= d) && (m_owner_ptr->size() >= d)) {
+			if (m_owner_ptr->size() == d) {
+			assert(m_owner_ptr->end() == _Right_cref);
+			m_points_to_an_item = false;
+			} else {
+			m_points_to_an_item = true;
+			}
+			m_index = msev_size_t(d);
+			base_class::iterator::operator=(_Right_cref);
+			}
+			else {
+			MSE_THROW(msevector_range_error("doesn't seem to be a valid assignment value - mm_iterator_type& operator=(const typename base_class::iterator& _Right_cref) - mm_const_iterator_type - msevector"));
+			}
+			return (*this);
+			}
+			*/
+			mm_iterator_type& operator=(const mm_iterator_type& _Right_cref)
+			{
+				if (((*this).m_owner_ptr) == (_Right_cref.m_owner_ptr)) {
+					assert((*this).m_owner_ptr->size() >= _Right_cref.m_index);
+					(*this).m_points_to_an_item = _Right_cref.m_points_to_an_item;
+					(*this).m_index = _Right_cref.m_index;
+				}
+				else {
+					MSE_THROW(msevector_range_error("doesn't seem to be a valid assignment value - mm_iterator_type& operator=(const typename base_class::iterator& _Right_cref) - mm_const_iterator_type - msevector"));
+				}
+				return (*this);
+			}
+			bool operator==(const mm_iterator_type& _Right_cref) const {
+				if (((*this).m_owner_ptr) != (_Right_cref.m_owner_ptr)) { MSE_THROW(msevector_range_error("invalid argument - mm_iterator_type& operator==(const typename base_class::iterator& _Right) - mm_iterator_type - msevector")); }
+				return (_Right_cref.m_index == m_index);
+			}
+			bool operator!=(const mm_iterator_type& _Right_cref) const { return (!(_Right_cref == (*this))); }
+			bool operator<(const mm_iterator_type& _Right) const {
+				if (((*this).m_owner_ptr) != (_Right.m_owner_ptr)) { MSE_THROW(msevector_range_error("invalid argument - mm_iterator_type& operator<(const typename base_class::iterator& _Right) - mm_iterator_type - msevector")); }
+				return (m_index < _Right.m_index);
+			}
+			bool operator<=(const mm_iterator_type& _Right) const { return (((*this) < _Right) || (_Right == (*this))); }
+			bool operator>(const mm_iterator_type& _Right) const { return (!((*this) <= _Right)); }
+			bool operator>=(const mm_iterator_type& _Right) const { return (!((*this) < _Right)); }
+			void set_to_item_pointer(const mm_iterator_type& _Right_cref) {
+				(*this) = _Right_cref;
+			}
+			void invalidate_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last) {
+				if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) {
+					(*this).reset();
+				}
+			}
+			void shift_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last, msev_int shift) {
+				if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) {
+					auto new_index = (*this).m_index + shift;
+					if ((0 > new_index) || (m_owner_ptr->size() < new_index)) {
+						MSE_THROW(msevector_range_error("void shift_inclusive_range() - mm_iterator_type - msevector"));
+					}
+					else {
+						(*this).m_index = msev_size_t(new_index);
+						(*this).sync_iterator_to_index();
+					}
+				}
+			}
+			msev_size_t position() const {
+				return m_index;
+			}
+			operator mm_const_iterator_type() const {
+				mm_const_iterator_type retval(*m_owner_ptr);
+				retval.set_to_beginning();
+				retval.advance(msev_int(m_index));
+				return retval;
+			}
+			/* We actually want to make this constructor private, but doing so seems to break std::make_shared<mm_iterator_type>.  */
+			mm_iterator_type(_Myt& owner_ref) : m_owner_ptr(&owner_ref) { set_to_beginning(); }
+		private:
+			mm_iterator_type(const mm_iterator_type& src_cref) : m_owner_ptr(src_cref.m_owner_ptr) { (*this) = src_cref; }
+			void sync_iterator_to_index() {
+				assert(m_owner_ptr->size() >= (*this).m_index);
+			}
+			msev_bool m_points_to_an_item = false;
+			msev_size_t m_index = 0;
+			_Myt* m_owner_ptr = nullptr;
+			friend class mm_iterator_set_type;
+			friend class /*_Myt*/msevector<_Ty, _A>;
+		};
+
+	private:
+		typedef std::size_t CHashKey1;
+		class mm_const_iterator_handle_type {
+		public:
+			mm_const_iterator_handle_type(const CHashKey1& key_cref, const std::shared_ptr<mm_const_iterator_type>& shptr_cref) : m_shptr(shptr_cref), m_key(key_cref) {}
+		private:
+			std::shared_ptr<mm_const_iterator_type> m_shptr;
+			CHashKey1 m_key;
+			friend class /*_Myt*/msevector<_Ty, _A>;
+			friend class mm_iterator_set_type;
+		};
+		class mm_iterator_handle_type {
+		public:
+			mm_iterator_handle_type(const CHashKey1& key_cref, const std::shared_ptr<mm_iterator_type>& shptr_ref) : m_shptr(shptr_ref), m_key(key_cref) {}
+		private:
+			std::shared_ptr<mm_iterator_type> m_shptr;
+			CHashKey1 m_key;
+			friend class /*_Myt*/msevector<_Ty, _A>;
+			friend class mm_iterator_set_type;
+		};
+
+		class mm_iterator_set_type {
+		public:
+			class CMMConstIterators : public std::unordered_map<CHashKey1, std::shared_ptr<mm_const_iterator_type>> {};
+			class CMMIterators : public std::unordered_map<CHashKey1, std::shared_ptr<mm_iterator_type>> {};
+
+			class assignable_CMMConstIterators_value_type : public std::pair<CHashKey1, std::shared_ptr<mm_const_iterator_type>> {
+			public:
+				assignable_CMMConstIterators_value_type() {}
+				assignable_CMMConstIterators_value_type(const typename CMMConstIterators::value_type& src) : std::pair<CHashKey1, std::shared_ptr<mm_iterator_type>>(src.first, src.second) {}
+				assignable_CMMConstIterators_value_type& operator=(const typename CMMConstIterators::value_type& rhs) { (*this).first = rhs.first; (*this).second = rhs.second; return (*this); }
+				operator typename CMMConstIterators::value_type() const { return CMMConstIterators::value_type((*this).first, (*this).second); }
+			};
+			class assignable_CMMIterators_value_type : public std::pair<CHashKey1, std::shared_ptr<mm_iterator_type>> {
+			public:
+				assignable_CMMIterators_value_type() {}
+				assignable_CMMIterators_value_type(const typename CMMIterators::value_type& src) : std::pair<CHashKey1, std::shared_ptr<mm_iterator_type>>(src.first, src.second) {}
+				assignable_CMMIterators_value_type& operator=(const typename CMMIterators::value_type& rhs) { (*this).first = rhs.first; (*this).second = rhs.second; return (*this); }
+				operator typename CMMIterators::value_type() const { return CMMIterators::value_type((*this).first, (*this).second); }
+			};
+
+			~mm_iterator_set_type() {
+				if (!mm_const_fast_mode1()) {
+					delete m_aux_mm_const_iterator_shptrs_ptr;
+				}
+				if (!mm_fast_mode1()) {
+					delete m_aux_mm_iterator_shptrs_ptr;
+				}
+			}
+
+			void apply_to_all_mm_const_iterator_shptrs(const std::function<void(std::shared_ptr<mm_const_iterator_type>&)>& func_obj_ref) {
+				if (!mm_const_fast_mode1()) {
+					for (auto it = (*m_aux_mm_const_iterator_shptrs_ptr).begin(); (*m_aux_mm_const_iterator_shptrs_ptr).end() != it; it++) {
+						func_obj_ref((*it).second);
+					}
+				}
+				else {
+					for (int i = 0; i < m_fm1_num_mm_const_iterators; i += 1) {
+						func_obj_ref(m_fm1_key_mm_const_it_array[i].second);
+					}
+				}
+			}
+			void apply_to_all_mm_iterator_shptrs(const std::function<void(std::shared_ptr<mm_iterator_type>&)>& func_obj_ref) {
+				if (!mm_fast_mode1()) {
+					for (auto it = (*m_aux_mm_iterator_shptrs_ptr).begin(); (*m_aux_mm_iterator_shptrs_ptr).end() != it; it++) {
+						func_obj_ref((*it).second);
+					}
+				}
+				else {
+					for (int i = 0; i < m_fm1_num_mm_iterators; i += 1) {
+						func_obj_ref(m_fm1_key_mm_it_array[i].second);
+					}
+				}
+			}
+			mm_iterator_set_type(_Myt& owner_ref) : m_next_available_key(0), m_owner_ptr(&owner_ref) {}
+			void reset() {
+				/* We can use "static" here because the lambda function does not capture any parameters. */
+				static const std::function<void(std::shared_ptr<mm_const_iterator_type>&)> cit_func_obj = [](std::shared_ptr<mm_const_iterator_type>& a) { a->reset(); };
+				apply_to_all_mm_const_iterator_shptrs(cit_func_obj);
+				static const std::function<void(std::shared_ptr<mm_iterator_type>&)> it_func_obj = [](std::shared_ptr<mm_iterator_type>& a) { a->reset(); };
+				apply_to_all_mm_iterator_shptrs(it_func_obj);
+			}
+			void sync_iterators_to_index() {
+				/* No longer used. Relic from when mm_iterator_type contained a "native" iterator. */
+				/* We can use "static" here because the lambda function does not capture any parameters. */
+				/*
+				static const std::function<void(std::shared_ptr<mm_const_iterator_type>&)> cit_func_obj = [](std::shared_ptr<mm_const_iterator_type>& a) { a->sync_const_iterator_to_index(); };
+				apply_to_all_mm_const_iterator_shptrs(cit_func_obj);
+				static const std::function<void(std::shared_ptr<mm_iterator_type>&)> it_func_obj = [](std::shared_ptr<mm_iterator_type>& a) { a->sync_iterator_to_index(); };
+				apply_to_all_mm_iterator_shptrs(it_func_obj);
+				*/
+			}
+			void invalidate_inclusive_range(msev_size_t start_index, msev_size_t end_index) {
+				const std::function<void(std::shared_ptr<mm_const_iterator_type>&)> cit_func_obj = [start_index, end_index](std::shared_ptr<mm_const_iterator_type>& a) { a->invalidate_inclusive_range(start_index, end_index); };
+				apply_to_all_mm_const_iterator_shptrs(cit_func_obj);
+				const std::function<void(std::shared_ptr<mm_iterator_type>&)> it_func_obj = [start_index, end_index](std::shared_ptr<mm_iterator_type>& a) { a->invalidate_inclusive_range(start_index, end_index); };
+				apply_to_all_mm_iterator_shptrs(it_func_obj);
+			}
+			void shift_inclusive_range(msev_size_t start_index, msev_size_t end_index, msev_int shift) {
+				const std::function<void(std::shared_ptr<mm_const_iterator_type>&)> cit_func_obj = [start_index, end_index, shift](std::shared_ptr<mm_const_iterator_type>& a) { a->shift_inclusive_range(start_index, end_index, shift); };
+				apply_to_all_mm_const_iterator_shptrs(cit_func_obj);
+				const std::function<void(std::shared_ptr<mm_iterator_type>&)> it_func_obj = [start_index, end_index, shift](std::shared_ptr<mm_iterator_type>& a) { a->shift_inclusive_range(start_index, end_index, shift); };
+				apply_to_all_mm_iterator_shptrs(it_func_obj);
+			}
+			bool is_empty() const {
+				if (mm_const_fast_mode1()) {
+					if (1 <= m_fm1_num_mm_const_iterators) {
+						return false;
+					}
+				}
+				else {
+					if (1 <= m_aux_mm_const_iterator_shptrs_ptr->size()) {
+						return false;
+					}
+				}
+				if (mm_fast_mode1()) {
+					if (1 <= m_fm1_num_mm_iterators) {
+						return false;
+					}
+				}
+				else {
+					if (1 <= m_aux_mm_iterator_shptrs_ptr->size()) {
+						return false;
+					}
+				}
+				return true;
+			}
+
+			mm_const_iterator_handle_type allocate_new_const_item_pointer() {
+				//auto shptr = std::shared_ptr<mm_const_iterator_type>(new mm_const_iterator_type(*m_owner_ptr));
+				auto shptr = std::make_shared<mm_const_iterator_type>(*m_owner_ptr);
+				auto key = m_next_available_key; m_next_available_key++;
+				mm_const_iterator_handle_type retval(key, shptr);
+				typename CMMConstIterators::value_type new_item(key, shptr);
+				if (!mm_const_fast_mode1()) {
+					(*m_aux_mm_const_iterator_shptrs_ptr).insert(new_item);
+				} else {
+					if (sc_fm1_max_mm_iterators == m_fm1_num_mm_const_iterators) {
+						/* Too many items. Initiate and switch to slow mode. */
+						/* Initialize slow storage. */
+						m_aux_mm_const_iterator_shptrs_ptr = new CMMConstIterators();
+						/* First copy the items from fast storage to slow storage. */
+						for (int i = 0; i < sc_fm1_max_mm_iterators; i += 1) {
+							(*m_aux_mm_const_iterator_shptrs_ptr).insert(m_fm1_key_mm_const_it_array[i]);
+						}
+						/* Add the new items to slow storage. */
+						(*m_aux_mm_const_iterator_shptrs_ptr).insert(new_item);
+					}
+					else {
+						m_fm1_key_mm_const_it_array[m_fm1_num_mm_const_iterators] = new_item;
+						m_fm1_num_mm_const_iterators += 1;
+					}
+				}
+				return retval;
+			}
+			void release_const_item_pointer(mm_const_iterator_handle_type handle) {
+				if (!mm_const_fast_mode1()) {
+					auto it = (*m_aux_mm_const_iterator_shptrs_ptr).find(handle.m_key);
+					if ((*m_aux_mm_const_iterator_shptrs_ptr).end() != it) {
+						(*m_aux_mm_const_iterator_shptrs_ptr).erase(it);
+					}
+					else {
+						/* Do we need to throw here? */
+						MSE_THROW(msevector_range_error("invalid handle - void release_aux_mm_const_iterator(mm_const_iterator_handle_type handle) - msevector::mm_iterator_set_type"));
+					}
+				}
+				else {
+					int found_index = -1;
+					for (int i = 0; i < m_fm1_num_mm_const_iterators; i += 1) {
+						if (handle.m_key == m_fm1_key_mm_const_it_array[i].first) {
+							found_index = i;
+							break;
+						}
+					}
+					if (0 <= found_index) {
+						m_fm1_num_mm_const_iterators -= 1;
+						assert(0 <= m_fm1_num_mm_const_iterators);
+						for (int j = found_index; j < m_fm1_num_mm_const_iterators; j += 1) {
+							m_fm1_key_mm_const_it_array[j] = m_fm1_key_mm_const_it_array[j + 1];
+						}
+					}
+					else {
+						/* Do we need to throw here? */
+						MSE_THROW(msevector_range_error("invalid handle - void release_aux_mm_const_iterator(mm_const_iterator_handle_type handle) - msevector::mm_iterator_set_type"));
+					}
+				}
+			}
+
+			mm_iterator_handle_type allocate_new_item_pointer() {
+				//auto shptr = std::shared_ptr<mm_iterator_type>(new mm_iterator_type(*m_owner_ptr));
+				auto shptr = std::make_shared<mm_iterator_type>(*m_owner_ptr);
+				auto key = m_next_available_key; m_next_available_key++;
+				mm_iterator_handle_type retval(key, shptr);
+				typename CMMIterators::value_type new_item(key, shptr);
+				if (!mm_fast_mode1()) {
+					(*m_aux_mm_iterator_shptrs_ptr).insert(new_item);
+				}
+				else {
+					if (sc_fm1_max_mm_iterators == m_fm1_num_mm_iterators) {
+						/* Too many items. Initiate and switch to slow mode. */
+						/* Initialize slow storage. */
+						m_aux_mm_iterator_shptrs_ptr = new CMMIterators();
+						/* First copy the items from fast storage to slow storage. */
+						for (int i = 0; i < sc_fm1_max_mm_iterators; i += 1) {
+							(*m_aux_mm_iterator_shptrs_ptr).insert(m_fm1_key_mm_it_array[i]);
+						}
+						/* Add the new items to slow storage. */
+						(*m_aux_mm_iterator_shptrs_ptr).insert(new_item);
+					}
+					else {
+						m_fm1_key_mm_it_array[m_fm1_num_mm_iterators] = new_item;
+						m_fm1_num_mm_iterators += 1;
+					}
+				}
+				return retval;
+			}
+			void release_item_pointer(mm_iterator_handle_type handle) {
+				if (!mm_fast_mode1()) {
+					auto it = (*m_aux_mm_iterator_shptrs_ptr).find(handle.m_key);
+					if ((*m_aux_mm_iterator_shptrs_ptr).end() != it) {
+						(*m_aux_mm_iterator_shptrs_ptr).erase(it);
+					}
+					else {
+						/* Do we need to throw here? */
+						MSE_THROW(msevector_range_error("invalid handle - void release_aux_mm_iterator(mm_iterator_handle_type handle) - msevector::mm_iterator_set_type"));
+					}
+				}
+				else {
+					int found_index = -1;
+					for (int i = 0; i < m_fm1_num_mm_iterators; i += 1) {
+						if (handle.m_key == m_fm1_key_mm_it_array[i].first) {
+							found_index = i;
+							break;
+						}
+					}
+					if (0 <= found_index) {
+						m_fm1_num_mm_iterators -= 1;
+						assert(0 <= m_fm1_num_mm_iterators);
+						for (int j = found_index; j < m_fm1_num_mm_iterators; j += 1) {
+							m_fm1_key_mm_it_array[j] = m_fm1_key_mm_it_array[j + 1];
+						}
+					}
+					else {
+						/* Do we need to throw here? */
+						MSE_THROW(msevector_range_error("invalid handle - void release_aux_mm_iterator(mm_iterator_handle_type handle) - msevector::mm_iterator_set_type"));
+					}
+				}
+			}
+			void release_all_item_pointers() {
+				if (!mm_fast_mode1()) {
+					(*m_aux_mm_iterator_shptrs_ptr).clear();
+				}
+				else {
+					for (int i = 0; i < m_fm1_num_mm_iterators; i += 1) {
+						m_fm1_key_mm_it_array[i] = assignable_CMMIterators_value_type();
+					}
+					m_fm1_num_mm_iterators = 0;
+				}
+			}
+			mm_const_iterator_type &const_item_pointer(mm_const_iterator_handle_type handle) const {
+				return (*(handle.m_shptr));
+			}
+			mm_iterator_type &item_pointer(mm_iterator_handle_type handle) {
+				return (*(handle.m_shptr));
+			}
+
+		private:
+			void release_all_const_item_pointers() {
+				if (!mm_const_fast_mode1()) {
+					(*m_aux_mm_const_iterator_shptrs_ptr).clear();
+				}
+				else {
+					for (int i = 0; i < m_fm1_num_mm_const_iterators; i += 1) {
+						m_fm1_key_mm_const_it_array[i] = assignable_CMMConstIterators_value_type();
+					}
+					m_fm1_num_mm_const_iterators = 0;
+				}
+			}
+
+			mm_iterator_set_type& operator=(const mm_iterator_set_type& src_cref) {
+				/* This is a special type of class. The state (i.e. member values) of an object of this class is specific to (and only
+				valid for) the particular instance of the object (or the object of which it is a member). So the correct state of a new
+				copy of this type of object is not a copy of the state, but rather the state of a new object (which is just the default
+				initialization state). */
+				(*this).reset();
+				return (*this);
+			}
+			mm_iterator_set_type& operator=(mm_iterator_set_type&& src) { /* see above */ (*this).reset(); return (*this); }
+			mm_iterator_set_type(const mm_iterator_set_type& src) { /* see above */ }
+			mm_iterator_set_type(const mm_iterator_set_type&& src) { /* see above */ }
+
+			CHashKey1 m_next_available_key = 0;
+
+			static const int sc_fm1_max_mm_iterators = 6/*arbitrary*/;
+
+			bool mm_const_fast_mode1() const { return (nullptr == m_aux_mm_const_iterator_shptrs_ptr); }
+			int m_fm1_num_mm_const_iterators = 0;
+			assignable_CMMConstIterators_value_type m_fm1_key_mm_const_it_array[sc_fm1_max_mm_iterators];
+			CMMConstIterators* m_aux_mm_const_iterator_shptrs_ptr = nullptr;
+
+			bool mm_fast_mode1() const { return (nullptr == m_aux_mm_iterator_shptrs_ptr); }
+			int m_fm1_num_mm_iterators = 0;
+			assignable_CMMIterators_value_type m_fm1_key_mm_it_array[sc_fm1_max_mm_iterators];
+			CMMIterators* m_aux_mm_iterator_shptrs_ptr = nullptr;
+
+			_Myt* m_owner_ptr = nullptr;
+
+			friend class /*_Myt*/msevector<_Ty, _A>;
+		};
+		mutable mm_iterator_set_type m_mmitset;
+
+	public:
+		mm_const_iterator_type &const_item_pointer(mm_const_iterator_handle_type handle) const {
+			return m_mmitset.const_item_pointer(handle);
+		}
+		mm_iterator_type &item_pointer(mm_iterator_handle_type handle) {
+			return m_mmitset.item_pointer(handle);
+		}
+
+	private:
+		mm_const_iterator_handle_type allocate_new_const_item_pointer() const { return m_mmitset.allocate_new_const_item_pointer(); }
+		void release_const_item_pointer(mm_const_iterator_handle_type handle) const { m_mmitset.release_const_item_pointer(handle); }
+		void release_all_const_item_pointers() const { m_mmitset.release_all_const_item_pointers(); }
+		mm_iterator_handle_type allocate_new_item_pointer() const { return m_mmitset.allocate_new_item_pointer(); }
+		void release_item_pointer(mm_iterator_handle_type handle) const { m_mmitset.release_item_pointer(handle); }
+		void release_all_item_pointers() const { m_mmitset.release_all_item_pointers(); }
+
+	public:
+		class cipointer : public random_access_const_iterator_base {
+		public:
+			typedef typename mm_const_iterator_type::iterator_category iterator_category;
+			typedef typename mm_const_iterator_type::value_type value_type;
+			typedef typename mm_const_iterator_type::difference_type difference_type;
+			typedef difference_type distance_type;	// retained
+			typedef typename mm_const_iterator_type::pointer pointer;
+			typedef typename mm_const_iterator_type::const_pointer const_pointer;
+			typedef typename mm_const_iterator_type::reference reference;
+			typedef typename mm_const_iterator_type::const_reference const_reference;
+
+			cipointer(const _Myt& owner_cref) : m_owner_cptr(&owner_cref) {
+				mm_const_iterator_handle_type handle = m_owner_cptr->allocate_new_const_item_pointer();
+				m_handle_shptr = std::make_shared<mm_const_iterator_handle_type>(handle);
+			}
+			cipointer(const cipointer& src_cref) : m_owner_cptr(src_cref.m_owner_cptr) {
+				mm_const_iterator_handle_type handle = m_owner_cptr->allocate_new_const_item_pointer();
+				m_handle_shptr = std::make_shared<mm_const_iterator_handle_type>(handle);
+				const_item_pointer() = src_cref.const_item_pointer();
+			}
+			~cipointer() {
+				m_owner_cptr->release_const_item_pointer(*m_handle_shptr);
+			}
+			mm_const_iterator_type& const_item_pointer() const { return m_owner_cptr->const_item_pointer(*m_handle_shptr); }
+			mm_const_iterator_type& cip() const { return const_item_pointer(); }
+			//const mm_const_iterator_handle_type& handle() const { return (*m_handle_shptr); }
+
+			void reset() { const_item_pointer().reset(); }
+			bool points_to_an_item() const { return const_item_pointer().points_to_an_item(); }
+			bool points_to_end_marker() const { return const_item_pointer().points_to_end_marker(); }
+			bool points_to_beginning() const { return const_item_pointer().points_to_beginning(); }
+			/* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */
+			bool has_next_item_or_end_marker() const { return const_item_pointer().has_next_item_or_end_marker(); }
+			/* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */
+			bool has_next() const { return const_item_pointer().has_next(); }
+			bool has_previous() const { return const_item_pointer().has_previous(); }
+			void set_to_beginning() { const_item_pointer().set_to_beginning(); }
+			void set_to_end_marker() { const_item_pointer().set_to_end_marker(); }
+			void set_to_next() { const_item_pointer().set_to_next(); }
+			void set_to_previous() { const_item_pointer().set_to_previous(); }
+			cipointer& operator ++() { const_item_pointer().operator ++(); return (*this); }
+			cipointer operator++(int) { cipointer _Tmp = *this; ++*this; return (_Tmp); }
+			cipointer& operator --() { const_item_pointer().operator --(); return (*this); }
+			cipointer operator--(int) { cipointer _Tmp = *this; --*this; return (_Tmp); }
+			void advance(difference_type n) { const_item_pointer().advance(n); }
+			void regress(difference_type n) { const_item_pointer().regress(n); }
+			cipointer& operator +=(difference_type n) { const_item_pointer().operator +=(n); return (*this); }
+			cipointer& operator -=(difference_type n) { const_item_pointer().operator -=(n); return (*this); }
+			cipointer operator+(difference_type n) const { auto retval = (*this); retval += n; return retval; }
+			cipointer operator-(difference_type n) const { return ((*this) + (-n)); }
+			difference_type operator-(const cipointer& _Right_cref) const { return const_item_pointer() - (_Right_cref.const_item_pointer()); }
+			const_reference operator*() const { return const_item_pointer().operator*(); }
+			const_reference item() const { return operator*(); }
+			const_reference previous_item() const { return const_item_pointer().previous_item(); }
+			const_pointer operator->() const { return const_item_pointer().operator->(); }
+			const_reference operator[](difference_type _Off) const { return const_item_pointer()[_Off]; }
+			cipointer& operator=(const cipointer& _Right_cref) { const_item_pointer().operator=(_Right_cref.const_item_pointer()); return (*this); }
+			bool operator==(const cipointer& _Right_cref) const { return const_item_pointer().operator==(_Right_cref.const_item_pointer()); }
+			bool operator!=(const cipointer& _Right_cref) const { return (!(_Right_cref == (*this))); }
+			bool operator<(const cipointer& _Right) const { return (const_item_pointer() < _Right.const_item_pointer()); }
+			bool operator<=(const cipointer& _Right) const { return (const_item_pointer() <= _Right.const_item_pointer()); }
+			bool operator>(const cipointer& _Right) const { return (const_item_pointer() > _Right.const_item_pointer()); }
+			bool operator>=(const cipointer& _Right) const { return (const_item_pointer() >= _Right.const_item_pointer()); }
+			void set_to_const_item_pointer(const cipointer& _Right_cref) { const_item_pointer().set_to_const_item_pointer(_Right_cref.const_item_pointer()); }
+			msev_size_t position() const { return const_item_pointer().position(); }
+		private:
+			const _Myt* m_owner_cptr = nullptr;
+			std::shared_ptr<mm_const_iterator_handle_type> m_handle_shptr;
+			friend class /*_Myt*/msevector<_Ty, _A>;
+		};
+		class ipointer : public random_access_iterator_base {
+		public:
+			typedef typename mm_iterator_type::iterator_category iterator_category;
+			typedef typename mm_iterator_type::value_type value_type;
+			typedef typename mm_iterator_type::difference_type difference_type;
+			typedef difference_type distance_type;	// retained
+			typedef typename mm_iterator_type::pointer pointer;
+			typedef typename mm_iterator_type::reference reference;
+
+			ipointer(_Myt& owner_ref) : m_owner_ptr(&owner_ref) {
+				mm_iterator_handle_type handle = m_owner_ptr->allocate_new_item_pointer();
+				m_handle_shptr = std::make_shared<mm_iterator_handle_type>(handle);
+			}
+			ipointer(const ipointer& src_cref) : m_owner_ptr(src_cref.m_owner_ptr) {
+				mm_iterator_handle_type handle = m_owner_ptr->allocate_new_item_pointer();
+				m_handle_shptr = std::make_shared<mm_iterator_handle_type>(handle);
+				item_pointer() = src_cref.item_pointer();
+			}
+			~ipointer() {
+				m_owner_ptr->release_item_pointer(*m_handle_shptr);
+			}
+			mm_iterator_type& item_pointer() const { return m_owner_ptr->item_pointer(*m_handle_shptr); }
+			mm_iterator_type& ip() const { return item_pointer(); }
+			//const mm_iterator_handle_type& handle() const { return (*m_handle_shptr); }
+			operator cipointer() const {
+				cipointer retval(*m_owner_ptr);
+				retval.const_item_pointer().set_to_beginning();
+				retval.const_item_pointer().advance(msev_int(item_pointer().position()));
+				return retval;
+			}
+
+			void reset() { item_pointer().reset(); }
+			bool points_to_an_item() const { return item_pointer().points_to_an_item(); }
+			bool points_to_end_marker() const { return item_pointer().points_to_end_marker(); }
+			bool points_to_beginning() const { return item_pointer().points_to_beginning(); }
+			/* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */
+			bool has_next_item_or_end_marker() const { return item_pointer().has_next_item_or_end_marker(); }
+			/* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */
+			bool has_next() const { return item_pointer().has_next(); }
+			bool has_previous() const { return item_pointer().has_previous(); }
+			void set_to_beginning() { item_pointer().set_to_beginning(); }
+			void set_to_end_marker() { item_pointer().set_to_end_marker(); }
+			void set_to_next() { item_pointer().set_to_next(); }
+			void set_to_previous() { item_pointer().set_to_previous(); }
+			ipointer& operator ++() { item_pointer().operator ++(); return (*this); }
+			ipointer operator++(int) { ipointer _Tmp = *this; ++*this; return (_Tmp); }
+			ipointer& operator --() { item_pointer().operator --(); return (*this); }
+			ipointer operator--(int) { ipointer _Tmp = *this; --*this; return (_Tmp); }
+			void advance(difference_type n) { item_pointer().advance(n); }
+			void regress(difference_type n) { item_pointer().regress(n); }
+			ipointer& operator +=(difference_type n) { item_pointer().operator +=(n); return (*this); }
+			ipointer& operator -=(difference_type n) { item_pointer().operator -=(n); return (*this); }
+			ipointer operator+(difference_type n) const { auto retval = (*this); retval += n; return retval; }
+			ipointer operator-(difference_type n) const { return ((*this) + (-n)); }
+			difference_type operator-(const ipointer& _Right_cref) const { return item_pointer() - (_Right_cref.item_pointer()); }
+			reference operator*() const { return item_pointer().operator*(); }
+			reference item() const { return operator*(); }
+			reference previous_item() const { return item_pointer().previous_item(); }
+			pointer operator->() const { return item_pointer().operator->(); }
+			reference operator[](difference_type _Off) const { return item_pointer()[_Off]; }
+			ipointer& operator=(const ipointer& _Right_cref) { item_pointer().operator=(_Right_cref.item_pointer()); return (*this); }
+			bool operator==(const ipointer& _Right_cref) const { return item_pointer().operator==(_Right_cref.item_pointer()); }
+			bool operator!=(const ipointer& _Right_cref) const { return (!(_Right_cref == (*this))); }
+			bool operator<(const ipointer& _Right) const { return (item_pointer() < _Right.item_pointer()); }
+			bool operator<=(const ipointer& _Right) const { return (item_pointer() <= _Right.item_pointer()); }
+			bool operator>(const ipointer& _Right) const { return (item_pointer() > _Right.item_pointer()); }
+			bool operator>=(const ipointer& _Right) const { return (item_pointer() >= _Right.item_pointer()); }
+			void set_to_item_pointer(const ipointer& _Right_cref) { item_pointer().set_to_item_pointer(_Right_cref.item_pointer()); }
+			msev_size_t position() const { return item_pointer().position(); }
+		private:
+			_Myt* m_owner_ptr = nullptr;
+			std::shared_ptr<mm_iterator_handle_type> m_handle_shptr;
+			friend class /*_Myt*/msevector<_Ty, _A>;
+		};
+
+		ipointer ibegin() {	// return ipointer for beginning of mutable sequence
+			ipointer retval(*this);
+			retval.set_to_beginning();
+			return retval;
+		}
+		cipointer ibegin() const {	// return ipointer for beginning of nonmutable sequence
+			cipointer retval(*this);
+			retval.set_to_beginning();
+			return retval;
+		}
+		ipointer iend() {	// return ipointer for end of mutable sequence
+			ipointer retval(*this);
+			retval.set_to_end_marker();
+			return retval;
+		}
+		cipointer iend() const {	// return ipointer for end of nonmutable sequence
+			cipointer retval(*this);
+			retval.set_to_end_marker();
+			return retval;
+		}
+		cipointer cibegin() const {	// return ipointer for beginning of nonmutable sequence
+			cipointer retval(*this);
+			retval.set_to_beginning();
+			return retval;
+		}
+		cipointer ciend() const {	// return ipointer for end of nonmutable sequence
+			cipointer retval(*this);
+			retval.set_to_end_marker();
+			return retval;
+		}
+
+		msevector(const cipointer &start, const cipointer &end, const _A& _Al = _A())
+			: base_class(_Al), m_mmitset(*this) {
+			/*m_debug_size = size();*/
+			assign(start, end);
+		}
+		void assign(const mm_const_iterator_type &start, const mm_const_iterator_type &end) {
+			if (start.m_owner_cptr != end.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void assign(const mm_const_iterator_type &start, const mm_const_iterator_type &end) - msevector")); }
+			if (start > end) { MSE_THROW(msevector_range_error("invalid arguments - void assign(const mm_const_iterator_type &start, const mm_const_iterator_type &end) - msevector")); }
+			typename base_class::const_iterator _F = start;
+			typename base_class::const_iterator _L = end;
+			(*this).assign(_F, _L);
+		}
+		void assign_inclusive(const mm_const_iterator_type &first, const mm_const_iterator_type &last) {
+			auto end = last;
+			end++; // this should include some checks
+			(*this).assign(first, end);
+		}
+		void assign(const cipointer &start, const cipointer &end) {
+			assign(start.const_item_pointer(), end.const_item_pointer());
+		}
+		void assign_inclusive(const cipointer &first, const cipointer &last) {
+			assign_inclusive(first.const_item_pointer(), last.const_item_pointer());
+		}
+		void insert_before(const mm_const_iterator_type &pos, size_type _M, const _Ty& _X) {
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); }
+			typename base_class::const_iterator _P = pos;
+			(*this).insert(_P, _M, _X);
+		}
+		void insert_before(const mm_const_iterator_type &pos, _Ty&& _X) {
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); }
+			typename base_class::const_iterator _P = pos;
+			(*this).insert(_P, 1, std::move(_X));
+		}
+		void insert_before(const mm_const_iterator_type &pos, const _Ty& _X = _Ty()) { (*this).insert(pos, 1, _X); }
+		template<class _Iter
+			//>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type
+			, class = _mse_RequireInputIter<_Iter> >
+		void insert_before(const mm_const_iterator_type &pos, const _Iter &start, const _Iter &end) {
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); }
+			//if (start.m_owner_cptr != end.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before(const mm_const_iterator_type &pos, const mm_const_iterator_type &start, const mm_const_iterator_type &end) - msevector")); }
+			typename base_class::const_iterator _P = pos;
+			(*this).insert(_P, start, end);
+		}
+		template<class _Iter
+			//>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type
+			, class = _mse_RequireInputIter<_Iter> >
+		void insert_before_inclusive(const mm_const_iterator_type &pos, const _Iter &first, const _Iter &last) {
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); }
+			if (first.m_owner_cptr != last.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before_inclusive(const mm_const_iterator_type &pos, const mm_const_iterator_type &first, const mm_const_iterator_type &last) - msevector")); }
+			if (!(last.points_to_item())) { MSE_THROW(msevector_range_error("invalid argument - void insert_before_inclusive(const mm_const_iterator_type &pos, const mm_const_iterator_type &first, const mm_const_iterator_type &last) - msevector")); }
+			typename base_class::const_iterator _P = pos;
+			auto _L = last;
+			_L++;
+			(*this).insert(_P, first, _L);
+		}
+		void insert_before(const mm_const_iterator_type &pos, _XSTD initializer_list<typename base_class::value_type> _Ilist) {	// insert initializer_list
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); }
+			typename base_class::const_iterator _P = pos;
+			(*this).insert(_P, _Ilist);
+		}
+		ipointer insert_before(const cipointer &pos, size_type _M, const _Ty& _X) {
+			msev_size_t original_pos = pos.position();
+			insert_before(pos.const_item_pointer(), _M, _X);
+			ipointer retval(*this); retval.advance(msev_int(original_pos));
+			return retval;
+		}
+		ipointer insert_before(const cipointer &pos, _Ty&& _X) {
+			msev_size_t original_pos = pos.position();
+			insert_before(pos.const_item_pointer(), std::move(_X));
+			ipointer retval(*this); retval.advance(msev_int(original_pos));
+			return retval;
+		}
+		ipointer insert_before(const cipointer &pos, const _Ty& _X = _Ty()) { return insert_before(pos, 1, _X); }
+		template<class _Iter
+			//>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type
+			, class = _mse_RequireInputIter<_Iter> >
+		ipointer insert_before(const cipointer &pos, const _Iter &start, const _Iter &end) {
+			msev_size_t original_pos = pos.position();
+			insert_before(pos.const_item_pointer(), start, end);
+			ipointer retval(*this); retval.advance(msev_int(original_pos));
+			return retval;
+		}
+		template<class _Iter
+			//>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type
+			, class = _mse_RequireInputIter<_Iter> >
+		ipointer insert_before_inclusive(const cipointer &pos, const _Iter &first, const _Iter &last) {
+			auto end = last; end++;
+			return insert_before(pos, first, end);
+		}
+		ipointer insert_before(const cipointer &pos, _XSTD initializer_list<typename base_class::value_type> _Ilist) {	// insert initializer_list
+			msev_size_t original_pos = pos.position();
+			(*this).insert_before(pos.const_item_pointer(), _Ilist);
+			ipointer retval(*this); retval.advance(msev_int(original_pos));
+			return retval;
+		}
+		void insert_before(msev_size_t pos, _Ty&& _X) {
+			typename base_class::const_iterator _P = (*this).begin() + msev_as_a_size_t(pos);
+			(*this).insert(_P, std::move(_X));
+		}
+		void insert_before(msev_size_t pos, const _Ty& _X = _Ty()) {
+			typename base_class::const_iterator _P = (*this).begin() + msev_as_a_size_t(pos);
+			(*this).insert(_P, _X);
+		}
+		void insert_before(msev_size_t pos, size_t _M, const _Ty& _X) {
+			typename base_class::const_iterator _P = (*this).begin() + msev_as_a_size_t(pos);
+			(*this).insert(_P, _M, _X);
+		}
+		void insert_before(msev_size_t pos, _XSTD initializer_list<typename base_class::value_type> _Ilist) {	// insert initializer_list
+			typename base_class::const_iterator _P = (*this).begin() + msev_as_a_size_t(pos);
+			(*this).insert(_P, _Ilist);
+		}
+		/* These insert() functions are just aliases for their corresponding insert_before() functions. */
+		ipointer insert(const cipointer &pos, size_type _M, const _Ty& _X) { return insert_before(pos, _M, _X); }
+		ipointer insert(const cipointer &pos, _Ty&& _X) { return insert_before(pos, std::move(_X)); }
+		ipointer insert(const cipointer &pos, const _Ty& _X = _Ty()) { return insert_before(pos, _X); }
+		template<class _Iter
+			//>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type
+			, class = _mse_RequireInputIter<_Iter> >
+		ipointer insert(const cipointer &pos, const _Iter &start, const _Iter &end) { return insert_before(pos, start, end); }
+		ipointer insert(const cipointer &pos, _XSTD initializer_list<typename base_class::value_type> _Ilist) { return insert_before(pos, _Ilist); }
+		template<class ..._Valty>
+#if !(defined(GPP4P8_COMPATIBLE))
+		void emplace(const mm_const_iterator_type &pos, _Valty&& ..._Val)
+		{	// insert by moving _Val at pos
+#else /*!(defined(GPP4P8_COMPATIBLE))*/
+		void emplace(const mm_iterator_type &pos, _Valty&& ..._Val)
+		{	// insert by moving _Val at pos
+#endif /*!(defined(GPP4P8_COMPATIBLE))*/
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void emplace() - msevector")); }
+			typename base_class::const_iterator _P = pos;
+			auto retval = base_class::emplace(_P, std::forward<_Valty>(_Val)...);
+		}
+		template<class ..._Valty>
+#if !(defined(GPP4P8_COMPATIBLE))
+		ipointer emplace(const cipointer &pos, _Valty&& ..._Val)
+		{	// insert by moving _Val at pos
+#else /*!(defined(GPP4P8_COMPATIBLE))*/
+		ipointer emplace(const ipointer &pos, _Valty&& ..._Val)
+		{	// insert by moving _Val at pos
+#endif /*!(defined(GPP4P8_COMPATIBLE))*/
+			msev_size_t original_pos = pos.position();
+			(*this).emplace(pos.const_item_pointer(), std::forward<_Valty>(_Val)...);
+			ipointer retval(*this); retval.advance(msev_int(original_pos));
+			return retval;
+		}
+		void erase(const mm_const_iterator_type &pos) {
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
+			typename base_class::const_iterator _P = pos;
+			(*this).erase(_P);
+		}
+		void erase(const mm_const_iterator_type &start, const mm_const_iterator_type &end) {
+			if (start.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
+			if (end.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
+			typename base_class::const_iterator _F = start;
+			typename base_class::const_iterator _L = end;
+			(*this).erase(_F, _L);
+		}
+		void erase_inclusive(const mm_const_iterator_type &first, const mm_const_iterator_type &last) {
+			if (first.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase_inclusive() - msevector")); }
+			if (last.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase_inclusive() - msevector")); }
+			if (!(last.points_to_item())) { MSE_THROW(msevector_range_error("invalid argument - void erase_inclusive() - msevector")); }
+			typename base_class::const_iterator _F = first;
+			typename base_class::const_iterator _L = last;
+			_L++;
+			(*this).erase(_F, _L);
+		}
+		ipointer erase(const cipointer &pos) {
+			auto retval_pos = pos;
+			retval_pos.set_to_next();
+			erase(pos.const_item_pointer());
+			ipointer retval = (*this).ibegin();
+			retval.advance(msev_int(retval_pos.position()));
+			return retval;
+		}
+		ipointer erase(const cipointer &start, const cipointer &end) {
+			auto retval_pos = end;
+			retval_pos.set_to_next();
+			erase(start.const_item_pointer(), end.const_item_pointer());
+			ipointer retval = (*this).ibegin();
+			retval.advance(msev_int(retval_pos.position()));
+			return retval;
+		}
+		ipointer erase_inclusive(const cipointer &first, const cipointer &last) {
+			auto end = last; end.set_to_next();
+			return erase(first, end);
+		}
+		void erase_previous_item(const mm_const_iterator_type &pos) {
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase_previous_item() - msevector")); }
+			if (!(pos.has_previous())) { MSE_THROW(msevector_range_error("invalid arguments - void erase_previous_item() - msevector")); }
+			typename base_class::const_iterator _P = pos;
+			_P--;
+			(*this).erase(_P);
+		}
+		ipointer erase_previous_item(const cipointer &pos) {
+			erase_previous_item(pos.const_item_pointer());
+			ipointer retval = (*this).ibegin();
+			retval.advance(pos.position());
+			return retval;
+		}
+
+
+		/* ss_const_iterator_type is a bounds checked iterator. */
+		class ss_const_iterator_type : public random_access_const_iterator_base {
+		public:
+			typedef typename base_class::const_iterator::iterator_category iterator_category;
+			typedef typename base_class::const_iterator::value_type value_type;
+			//typedef typename base_class::const_iterator::difference_type difference_type;
+			typedef typename _Myt::difference_type difference_type;
+			typedef difference_type distance_type;	// retained
+			typedef typename base_class::const_iterator::pointer pointer;
+			typedef typename base_class::const_pointer const_pointer;
+			typedef typename base_class::const_iterator::reference reference;
+			typedef typename base_class::const_reference const_reference;
+
+			ss_const_iterator_type() {}
+			void assert_valid_index() const {
+				if (m_owner_cptr->size() < m_index) { MSE_THROW(msevector_range_error("invalid index - void assert_valid_index() const - ss_const_iterator_type - msevector")); }
+			}
+			void reset() { set_to_end_marker(); }
+			bool points_to_an_item() const {
+				if (m_owner_cptr->size() > m_index) { return true; }
+				else {
+					if (m_index == m_owner_cptr->size()) { return false; }
+					else { MSE_THROW(msevector_range_error("attempt to use invalid ss_const_iterator_type - bool points_to_an_item() const - ss_const_iterator_type - msevector")); }
+				}
+			}
+			bool points_to_end_marker() const {
+				if (false == points_to_an_item()) {
+					assert(m_index == m_owner_cptr->size());
+					return true;
+				}
+				else { return false; }
+			}
+			bool points_to_beginning() const {
+				if (0 == m_index) { return true; }
+				else { return false; }
+			}
+			/* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */
+			bool has_next_item_or_end_marker() const { return points_to_an_item(); }
+			/* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */
+			bool has_next() const { return has_next_item_or_end_marker(); }
+			bool has_previous() const {
+				if (m_owner_cptr->size() < m_index) {
+					MSE_THROW(msevector_range_error("attempt to use invalid ss_const_iterator_type - bool has_previous() const - ss_const_iterator_type - msevector"));
+				}
+				else if (1 <= m_index) {
+					return true;
+				}
+				else {
+					return false;
+				}
+			}
+			void set_to_beginning() {
+				m_index = 0;
+			}
+			void set_to_end_marker() {
+				m_index = m_owner_cptr->size();
+			}
+			void set_to_next() {
+				if (points_to_an_item()) {
+					m_index += 1;
+				}
+				else {
+					MSE_THROW(msevector_range_error("attempt to use invalid const_item_pointer - void set_to_next() - ss_const_iterator_type - msevector"));
+				}
+			}
+			void set_to_previous() {
+				if (has_previous()) {
+					m_index -= 1;
+				}
+				else {
+					MSE_THROW(msevector_range_error("attempt to use invalid const_item_pointer - void set_to_previous() - ss_const_iterator_type - msevector"));
+				}
+			}
+			ss_const_iterator_type& operator ++() { (*this).set_to_next(); return (*this); }
+			ss_const_iterator_type operator++(int) { ss_const_iterator_type _Tmp = *this; (*this).set_to_next(); return (_Tmp); }
+			ss_const_iterator_type& operator --() { (*this).set_to_previous(); return (*this); }
+			ss_const_iterator_type operator--(int) { ss_const_iterator_type _Tmp = *this; (*this).set_to_previous(); return (_Tmp); }
+			void advance(difference_type n) {
+				auto new_index = msev_int(m_index) + n;
+				if ((0 > new_index) || (m_owner_cptr->size() < msev_size_t(new_index))) {
+					MSE_THROW(msevector_range_error("index out of range - void advance(difference_type n) - ss_const_iterator_type - msevector"));
+				}
+				else {
+					m_index = msev_size_t(new_index);
+				}
+			}
+			void regress(difference_type n) { advance(-n); }
+			ss_const_iterator_type& operator +=(difference_type n) { (*this).advance(n); return (*this); }
+			ss_const_iterator_type& operator -=(difference_type n) { (*this).regress(n); return (*this); }
+			ss_const_iterator_type operator+(difference_type n) const {
+				ss_const_iterator_type retval; retval.m_owner_cptr = m_owner_cptr;
+				retval = (*this);
+				retval.advance(n);
+				return retval;
+			}
+			ss_const_iterator_type operator-(difference_type n) const { return ((*this) + (-n)); }
+			difference_type operator-(const ss_const_iterator_type &rhs) const {
+				if (rhs.m_owner_cptr != (*this).m_owner_cptr) { MSE_THROW(msevector_range_error("invalid argument - difference_type operator-(const ss_const_iterator_type &rhs) const - msevector::ss_const_iterator_type")); }
+				auto retval = difference_type((*this).m_index) - difference_type(rhs.m_index);
+				assert(difference_type((*m_owner_cptr).size()) >= retval);
+				return retval;
+			}
+			const_reference operator*() const {
+				return (*m_owner_cptr).at(msev_as_a_size_t((*this).m_index));
+			}
+			const_reference item() const { return operator*(); }
+			const_reference previous_item() const {
+				return m_owner_cptr->at(msev_as_a_size_t(m_index - 1));
+			}
+			const_pointer operator->() const {
+				return &((*m_owner_cptr).at(msev_as_a_size_t((*this).m_index)));
+			}
+			const_reference operator[](difference_type _Off) const { return (*m_owner_cptr).at(msev_as_a_size_t(difference_type(m_index) + _Off)); }
+			/*
+			ss_const_iterator_type& operator=(const typename base_class::const_iterator& _Right_cref)
+			{
+			msev_int d = std::distance<typename base_class::iterator>(m_owner_cptr->cbegin(), _Right_cref);
+			if ((0 <= d) && (m_owner_cptr->size() >= d)) {
+			if (m_owner_cptr->size() == d) {
+			assert(m_owner_cptr->cend() == _Right_cref);
+			}
+			m_index = msev_size_t(d);
+			base_class::const_iterator::operator=(_Right_cref);
+			}
+			else {
+			MSE_THROW(msevector_range_error("doesn't seem to be a valid assignment value - ss_const_iterator_type& operator=(const typename base_class::const_iterator& _Right_cref) - ss_const_iterator_type - msevector"));
+			}
+			return (*this);
+			}
+			*/
+			ss_const_iterator_type& operator=(const ss_const_iterator_type& _Right_cref) {
+				((*this).m_owner_cptr) = _Right_cref.m_owner_cptr;
+				(*this).m_index = _Right_cref.m_index;
+				return (*this);
+			}
+			bool operator==(const ss_const_iterator_type& _Right_cref) const {
+				if (this->m_owner_cptr != _Right_cref.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid argument - ss_const_iterator_type& operator==(const ss_const_iterator_type& _Right) - ss_const_iterator_type - msevector")); }
+				return (_Right_cref.m_index == m_index);
+			}
+			bool operator!=(const ss_const_iterator_type& _Right_cref) const { return (!(_Right_cref == (*this))); }
+			bool operator<(const ss_const_iterator_type& _Right) const {
+				if (this->m_owner_cptr != _Right.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid argument - ss_const_iterator_type& operator<(const ss_const_iterator_type& _Right) - ss_const_iterator_type - msevector")); }
+				return (m_index < _Right.m_index);
+			}
+			bool operator<=(const ss_const_iterator_type& _Right) const { return (((*this) < _Right) || (_Right == (*this))); }
+			bool operator>(const ss_const_iterator_type& _Right) const { return (!((*this) <= _Right)); }
+			bool operator>=(const ss_const_iterator_type& _Right) const { return (!((*this) < _Right)); }
+			void set_to_const_item_pointer(const ss_const_iterator_type& _Right_cref) {
+				(*this) = _Right_cref;
+			}
+			void invalidate_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last) {
+				if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) {
+					(*this).reset();
+				}
+			}
+			void shift_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last, msev_int shift) {
+				if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) {
+					auto new_index = (*this).m_index + shift;
+					if ((0 > new_index) || (m_owner_cptr->size() < new_index)) {
+						MSE_THROW(msevector_range_error("void shift_inclusive_range() - ss_const_iterator_type - msevector"));
+					}
+					else {
+						(*this).m_index = msev_size_t(new_index);
+						(*this).sync_const_iterator_to_index();
+					}
+				}
+			}
+			msev_size_t position() const {
+				return m_index;
+			}
+			operator typename base_class::const_iterator() const {
+				typename base_class::const_iterator retval = (*m_owner_cptr).cbegin();
+				retval += msev_as_a_size_t(m_index);
+				return retval;
+			}
+		private:
+			void sync_const_iterator_to_index() {
+				assert(m_owner_cptr->size() >= (*this).m_index);
+				//base_class::const_iterator::operator=(m_owner_cptr->cbegin());
+				//base_class::const_iterator::operator+=(msev_as_a_size_t(m_index));
+			}
+			msev_size_t m_index = 0;
+			msev_pointer<const _Myt> m_owner_cptr = nullptr;
+			friend class /*_Myt*/msevector<_Ty, _A>;
+		};
+		/* ss_iterator_type is a bounds checked iterator. */
+		class ss_iterator_type : public random_access_iterator_base {
+		public:
+			typedef typename base_class::iterator::iterator_category iterator_category;
+			typedef typename base_class::iterator::value_type value_type;
+			//typedef typename base_class::iterator::difference_type difference_type;
+			typedef typename _Myt::difference_type difference_type;
+			typedef difference_type distance_type;	// retained
+			typedef typename base_class::iterator::pointer pointer;
+			typedef typename base_class::iterator::reference reference;
+
+			ss_iterator_type() {}
+			void reset() { set_to_end_marker(); }
+			bool points_to_an_item() const {
+				if (m_owner_ptr->size() > m_index) { return true; }
+				else {
+					if (m_index == m_owner_ptr->size()) { return false; }
+					else { MSE_THROW(msevector_range_error("attempt to use invalid ss_iterator_type - bool points_to_an_item() const - ss_iterator_type - msevector")); }
+				}
+			}
+			bool points_to_end_marker() const {
+				if (false == points_to_an_item()) {
+					assert(m_index == m_owner_ptr->size());
+					return true;
+				}
+				else { return false; }
+			}
+			bool points_to_beginning() const {
+				if (0 == m_index) { return true; }
+				else { return false; }
+			}
+			/* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */
+			bool has_next_item_or_end_marker() const { return points_to_an_item(); }
+			/* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */
+			bool has_next() const { return has_next_item_or_end_marker(); }
+			bool has_previous() const {
+				if (m_owner_ptr->size() < m_index) {
+					MSE_THROW(msevector_range_error("attempt to use invalid ss_iterator_type - bool has_previous() const - ss_iterator_type - msevector"));
+				} else if (1 <= m_index) {
+					return true;
+				}
+				else {
+					return false;
+				}
+			}
+			void set_to_beginning() {
+				m_index = 0;
+			}
+			void set_to_end_marker() {
+				m_index = m_owner_ptr->size();
+			}
+			void set_to_next() {
+				if (points_to_an_item()) {
+					m_index += 1;
+				}
+				else {
+					MSE_THROW(msevector_range_error("attempt to use invalid item_pointer - void set_to_next() - ss_const_iterator_type - msevector"));
+				}
+			}
+			void set_to_previous() {
+				if (has_previous()) {
+					m_index -= 1;
+				}
+				else {
+					MSE_THROW(msevector_range_error("attempt to use invalid item_pointer - void set_to_previous() - ss_iterator_type - msevector"));
+				}
+			}
+			ss_iterator_type& operator ++() { (*this).set_to_next(); return (*this); }
+			ss_iterator_type operator++(int) { ss_iterator_type _Tmp = *this; (*this).set_to_next(); return (_Tmp); }
+			ss_iterator_type& operator --() { (*this).set_to_previous(); return (*this); }
+			ss_iterator_type operator--(int) { ss_iterator_type _Tmp = *this; (*this).set_to_previous(); return (_Tmp); }
+			void advance(difference_type n) {
+				auto new_index = msev_int(m_index) + n;
+				if ((0 > new_index) || (m_owner_ptr->size() < msev_size_t(new_index))) {
+					MSE_THROW(msevector_range_error("index out of range - void advance(difference_type n) - ss_iterator_type - msevector"));
+				}
+				else {
+					m_index = msev_size_t(new_index);
+				}
+			}
+			void regress(difference_type n) { advance(-n); }
+			ss_iterator_type& operator +=(difference_type n) { (*this).advance(n); return (*this); }
+			ss_iterator_type& operator -=(difference_type n) { (*this).regress(n); return (*this); }
+			ss_iterator_type operator+(difference_type n) const {
+				ss_iterator_type retval; retval.m_owner_ptr = m_owner_ptr;
+				retval = (*this);
+				retval.advance(n);
+				return retval;
+			}
+			ss_iterator_type operator-(difference_type n) const { return ((*this) + (-n)); }
+			difference_type operator-(const ss_iterator_type& rhs) const {
+				if (rhs.m_owner_ptr != (*this).m_owner_ptr) { MSE_THROW(msevector_range_error("invalid argument - difference_type operator-(const ss_iterator_type& rhs) const - msevector::ss_iterator_type")); }
+				auto retval = difference_type((*this).m_index) - difference_type(rhs.m_index);
+				assert(int((*m_owner_ptr).size()) >= retval);
+				return retval;
+			}
+			reference operator*() const {
+				return (*m_owner_ptr).at(msev_as_a_size_t((*this).m_index));
+			}
+			reference item() const { return operator*(); }
+			reference previous_item() const {
+				return m_owner_ptr->at(msev_as_a_size_t(m_index - 1));
+			}
+			pointer operator->() const {
+				return &((*m_owner_ptr).at(msev_as_a_size_t((*this).m_index)));
+			}
+			reference operator[](difference_type _Off) const { return (*m_owner_ptr).at(msev_as_a_size_t(difference_type(m_index) + _Off)); }
+			/*
+			ss_iterator_type& operator=(const typename base_class::iterator& _Right_cref)
+			{
+			msev_int d = std::distance<typename base_class::iterator>(m_owner_ptr->begin(), _Right_cref);
+			if ((0 <= d) && (m_owner_ptr->size() >= d)) {
+			if (m_owner_ptr->size() == d) {
+			assert(m_owner_ptr->end() == _Right_cref);
+			}
+			m_index = msev_size_t(d);
+			base_class::iterator::operator=(_Right_cref);
+			}
+			else {
+			MSE_THROW(msevector_range_error("doesn't seem to be a valid assignment value - ss_iterator_type& operator=(const typename base_class::iterator& _Right_cref) - ss_const_iterator_type - msevector"));
+			}
+			return (*this);
+			}
+			*/
+			ss_iterator_type& operator=(const ss_iterator_type& _Right_cref) {
+				((*this).m_owner_ptr) = _Right_cref.m_owner_ptr;
+				(*this).m_index = _Right_cref.m_index;
+				return (*this);
+			}
+			bool operator==(const ss_iterator_type& _Right_cref) const {
+				if (this->m_owner_ptr != _Right_cref.m_owner_ptr) { MSE_THROW(msevector_range_error("invalid argument - ss_iterator_type& operator==(const ss_iterator_type& _Right) - ss_iterator_type - msevector")); }
+				return (_Right_cref.m_index == m_index);
+			}
+			bool operator!=(const ss_iterator_type& _Right_cref) const { return (!(_Right_cref == (*this))); }
+			bool operator<(const ss_iterator_type& _Right) const {
+				if (this->m_owner_ptr != _Right.m_owner_ptr) { MSE_THROW(msevector_range_error("invalid argument - ss_iterator_type& operator<(const ss_iterator_type& _Right) - ss_iterator_type - msevector")); }
+				return (m_index < _Right.m_index);
+			}
+			bool operator<=(const ss_iterator_type& _Right) const { return (((*this) < _Right) || (_Right == (*this))); }
+			bool operator>(const ss_iterator_type& _Right) const { return (!((*this) <= _Right)); }
+			bool operator>=(const ss_iterator_type& _Right) const { return (!((*this) < _Right)); }
+			void set_to_item_pointer(const ss_iterator_type& _Right_cref) {
+				(*this) = _Right_cref;
+			}
+			void invalidate_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last) {
+				if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) {
+					(*this).reset();
+				}
+			}
+			void shift_inclusive_range(msev_size_t index_of_first, msev_size_t index_of_last, msev_int shift) {
+				if ((index_of_first <= (*this).m_index) && (index_of_last >= (*this).m_index)) {
+					auto new_index = (*this).m_index + shift;
+					if ((0 > new_index) || (m_owner_ptr->size() < new_index)) {
+						MSE_THROW(msevector_range_error("void shift_inclusive_range() - ss_iterator_type - msevector"));
+					}
+					else {
+						(*this).m_index = msev_size_t(new_index);
+						(*this).sync_iterator_to_index();
+					}
+				}
+			}
+			msev_size_t position() const {
+				return m_index;
+			}
+			operator ss_const_iterator_type() const {
+				ss_const_iterator_type retval;
+				if (nullptr != m_owner_ptr) {
+					retval = m_owner_ptr->ss_cbegin();
+					retval.advance(msev_int(m_index));
+				}
+				return retval;
+			}
+			operator typename base_class::iterator() const {
+				typename base_class::iterator retval = (*m_owner_ptr).begin();
+				retval += msev_as_a_size_t(m_index);
+				return retval;
+			}
+
+		private:
+			void sync_iterator_to_index() {
+				assert(m_owner_ptr->size() >= (*this).m_index);
+				//base_class::iterator::operator=(m_owner_ptr->begin());
+				//base_class::iterator::operator+=(msev_as_a_size_t(m_index));
+			}
+			msev_size_t m_index = 0;
+			msev_pointer<_Myt> m_owner_ptr = nullptr;
+			friend class /*_Myt*/msevector<_Ty, _A>;
+		};
+		typedef std::reverse_iterator<ss_iterator_type> ss_reverse_iterator_type;
+		typedef std::reverse_iterator<ss_const_iterator_type> ss_const_reverse_iterator_type;
+
+		ss_iterator_type ss_begin()
+		{	// return base_class::iterator for beginning of mutable sequence
+			ss_iterator_type retval; retval.m_owner_ptr = this;
+			retval.set_to_beginning();
+			return retval;
+		}
+
+		ss_const_iterator_type ss_begin() const
+		{	// return base_class::iterator for beginning of nonmutable sequence
+			ss_const_iterator_type retval; retval.m_owner_cptr = this;
+			retval.set_to_beginning();
+			return retval;
+		}
+
+		ss_iterator_type ss_end()
+		{	// return base_class::iterator for end of mutable sequence
+			ss_iterator_type retval; retval.m_owner_ptr = this;
+			retval.set_to_end_marker();
+			return retval;
+		}
+
+		ss_const_iterator_type ss_end() const
+		{	// return base_class::iterator for end of nonmutable sequence
+			ss_const_iterator_type retval; retval.m_owner_cptr = this;
+			retval.set_to_end_marker();
+			return retval;
+		}
+
+		ss_const_iterator_type ss_cbegin() const
+		{	// return base_class::iterator for beginning of nonmutable sequence
+			ss_const_iterator_type retval; retval.m_owner_cptr = this;
+			retval.set_to_beginning();
+			return retval;
+		}
+
+		ss_const_iterator_type ss_cend() const
+		{	// return base_class::iterator for end of nonmutable sequence
+			ss_const_iterator_type retval; retval.m_owner_cptr = this;
+			retval.set_to_end_marker();
+			return retval;
+		}
+
+		ss_const_reverse_iterator_type ss_crbegin() const
+		{	// return base_class::iterator for beginning of reversed nonmutable sequence
+			return (ss_rbegin());
+		}
+
+		ss_const_reverse_iterator_type ss_crend() const
+		{	// return base_class::iterator for end of reversed nonmutable sequence
+			return (ss_rend());
+		}
+
+		ss_reverse_iterator_type ss_rbegin()
+		{	// return base_class::iterator for beginning of reversed mutable sequence
+			return (reverse_iterator(ss_end()));
+		}
+
+		ss_const_reverse_iterator_type ss_rbegin() const
+		{	// return base_class::iterator for beginning of reversed nonmutable sequence
+			return (const_reverse_iterator(ss_end()));
+		}
+
+		ss_reverse_iterator_type ss_rend()
+		{	// return base_class::iterator for end of reversed mutable sequence
+			return (reverse_iterator(ss_begin()));
+		}
+
+		ss_const_reverse_iterator_type ss_rend() const
+		{	// return base_class::iterator for end of reversed nonmutable sequence
+			return (const_reverse_iterator(ss_begin()));
+		}
+
+		msevector(const ss_const_iterator_type &start, const ss_const_iterator_type &end, const _A& _Al = _A())
+			: base_class(_Al), m_mmitset(*this) {
+			/*m_debug_size = size();*/
+			assign(start, end);
+		}
+		void assign(const ss_const_iterator_type &start, const ss_const_iterator_type &end) {
+			if (start.m_owner_cptr != end.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void assign(const ss_const_iterator_type &start, const ss_const_iterator_type &end) - msevector")); }
+			if (start > end) { MSE_THROW(msevector_range_error("invalid arguments - void assign(const ss_const_iterator_type &start, const ss_const_iterator_type &end) - msevector")); }
+			typename base_class::const_iterator _F = start;
+			typename base_class::const_iterator _L = end;
+			(*this).assign(_F, _L);
+		}
+		void assign_inclusive(const ss_const_iterator_type &first, const ss_const_iterator_type &last) {
+			auto end = last;
+			end++; // this should include some checks
+			(*this).assign(first, end);
+		}
+		ss_iterator_type insert_before(const ss_const_iterator_type &pos, size_type _M, const _Ty& _X) {
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid argument - void insert_before() - msevector")); }
+			pos.assert_valid_index();
+			msev_size_t original_pos = pos.position();
+			typename base_class::const_iterator _P = pos;
+			(*this).insert(_P, _M, _X);
+			ss_iterator_type retval = ss_begin();
+			retval.advance(msev_int(original_pos));
+			return retval;
+		}
+		ss_iterator_type insert_before(const ss_const_iterator_type &pos, _Ty&& _X) {
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid argument - void insert_before() - msevector")); }
+			pos.assert_valid_index();
+			msev_size_t original_pos = pos.position();
+			typename base_class::const_iterator _P = pos;
+			(*this).insert(_P, std::move(_X));
+			ss_iterator_type retval = ss_begin();
+			retval.advance(msev_int(original_pos));
+			return retval;
+		}
+		ss_iterator_type insert_before(const ss_const_iterator_type &pos, const _Ty& _X = _Ty()) { return (*this).insert(pos, 1, _X); }
+		template<class _Iter
+			//>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type
+			, class = _mse_RequireInputIter<_Iter> >
+		ss_iterator_type insert_before(const ss_const_iterator_type &pos, const _Iter &start, const _Iter &end) {
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid argument - ss_iterator_type insert_before() - msevector")); }
+			//if (start.m_owner_cptr != end.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before(const ss_const_iterator_type &pos, const ss_const_iterator_type &start, const ss_const_iterator_type &end) - msevector")); }
+			pos.assert_valid_index();
+			msev_size_t original_pos = pos.position();
+			typename base_class::const_iterator _P = pos;
+			(*this).insert(_P, start, end);
+			ss_iterator_type retval = ss_begin();
+			retval.advance(msev_int(original_pos));
+			return retval;
+		}
+		ss_iterator_type insert_before(const ss_const_iterator_type &pos, const ss_const_iterator_type& start, const ss_const_iterator_type &end) {
+			if (start.m_owner_cptr != end.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before(const ss_const_iterator_type &pos, const ss_const_iterator_type &start, const ss_const_iterator_type &end) - msevector")); }
+			end.assert_valid_index();
+			if (start > end) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before(const ss_const_iterator_type &pos, const ss_const_iterator_type &start, const ss_const_iterator_type &end) - msevector")); }
+			typename base_class::const_iterator _S = start;
+			typename base_class::const_iterator _E = end;
+			return (*this).insert_before(pos, _S, _E);
+		}
+		ss_iterator_type insert_before(const ss_const_iterator_type &pos, const _Ty* start, const _Ty* end) {
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - ss_iterator_type insert_before() - msevector")); }
+			//if (start.m_owner_cptr != end.m_owner_cptr) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before(const ss_const_iterator_type &pos, const ss_const_iterator_type &start, const ss_const_iterator_type &end) - msevector")); }
+			if (start > end) { MSE_THROW(msevector_range_error("invalid arguments - ss_iterator_type insert_before() - msevector")); }
+			pos.assert_valid_index();
+			msev_size_t original_pos = pos.position();
+			typename base_class::const_iterator _P = pos;
+			(*this).insert(_P, start, end);
+			ss_iterator_type retval = ss_begin();
+			retval.advance(msev_int(original_pos));
+			return retval;
+		}
+		template<class _Iter
+			//>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type
+			, class = _mse_RequireInputIter<_Iter> >
+		ss_iterator_type insert_before_inclusive(const ss_iterator_type &pos, const _Iter &first, const _Iter &last) {
+			auto end = last;
+			end++; // this may include some checks
+			return (*this).insert_before(pos, first, end);
+		}
+		ss_iterator_type insert_before(const ss_const_iterator_type &pos, _XSTD initializer_list<typename base_class::value_type> _Ilist) {	// insert initializer_list
+			if (pos.m_owner_ptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void insert_before() - msevector")); }
+			pos.assert_valid_index();
+			msev_size_t original_pos = pos.position();
+			typename base_class::const_iterator _P = pos;
+			(*this).insert(_P, _Ilist);
+			ss_iterator_type retval = ss_begin();
+			retval.advance(msev_int(original_pos));
+			return retval;
+		}
+		/* These insert() functions are just aliases for their corresponding insert_before() functions. */
+		ss_iterator_type insert(const ss_const_iterator_type &pos, size_type _M, const _Ty& _X) { return insert_before(pos, _M, _X); }
+		ss_iterator_type insert(const ss_const_iterator_type &pos, _Ty&& _X) { return insert_before(pos, std::move(_X)); }
+		ss_iterator_type insert(const ss_const_iterator_type &pos, const _Ty& _X = _Ty()) { return insert_before(pos, _X); }
+		template<class _Iter
+			//>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type
+			, class = _mse_RequireInputIter<_Iter> >
+		ss_iterator_type insert(const ss_const_iterator_type &pos, const _Iter &start, const _Iter &end) { return insert_before(pos, start, end); }
+		ss_iterator_type insert(const ss_const_iterator_type &pos, const _Ty* start, const _Ty* &end) { return insert_before(pos, start, end); }
+		ss_iterator_type insert(const ss_const_iterator_type &pos, _XSTD initializer_list<typename base_class::value_type> _Ilist) { return insert_before(pos, _Ilist); }
+		template<class ..._Valty>
+#if !(defined(GPP4P8_COMPATIBLE))
+		ss_iterator_type emplace(const ss_const_iterator_type &pos, _Valty&& ..._Val)
+		{	// insert by moving _Val at pos
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void emplace() - msevector")); }
+#else /*!(defined(GPP4P8_COMPATIBLE))*/
+		ipointer emplace(const ipointer &pos, _Valty&& ..._Val)
+		{	// insert by moving _Val at pos
+			if (pos.m_owner_ptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void emplace() - msevector")); }
+#endif /*!(defined(GPP4P8_COMPATIBLE))*/
+			pos.assert_valid_index();
+			msev_size_t original_pos = pos.position();
+			typename base_class::const_iterator _P = pos;
+			(*this).emplace(_P,  std::forward<_Valty>(_Val)...);
+			ss_iterator_type retval = ss_begin();
+			retval.advance(msev_int(original_pos));
+			return retval;
+		}
+		ss_iterator_type erase(const ss_const_iterator_type &pos) {
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
+			if (!pos.points_to_an_item()) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
+			auto pos_index = pos.position();
+
+			typename base_class::const_iterator _P = pos;
+			(*this).erase(_P);
+
+			ss_iterator_type retval = (*this).ss_begin();
+			retval.advance(typename ss_const_iterator_type::difference_type(pos_index));
+			return retval;
+		}
+		ss_iterator_type erase(const ss_const_iterator_type &start, const ss_const_iterator_type &end) {
+			if (start.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
+			if (end.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
+			if (start.position() > end.position()) { MSE_THROW(msevector_range_error("invalid arguments - void erase() - msevector")); }
+			auto pos_index = start.position();
+
+			typename base_class::const_iterator _F = start;
+			typename base_class::const_iterator _L = end;
+			(*this).erase(_F, _L);
+
+			ss_iterator_type retval = (*this).ss_begin();
+			retval.advance(typename ss_const_iterator_type::difference_type(pos_index));
+			return retval;
+		}
+		ss_iterator_type erase_inclusive(const ss_const_iterator_type &first, const ss_const_iterator_type &last) {
+			auto end = last; end.set_to_next();
+			return erase(first, end);
+		}
+		void erase_previous_item(const ss_const_iterator_type &pos) {
+			if (pos.m_owner_cptr != this) { MSE_THROW(msevector_range_error("invalid arguments - void erase_previous_item() - msevector")); }
+			if (!(pos.has_previous())) { MSE_THROW(msevector_range_error("invalid arguments - void erase_previous_item() - msevector")); }
+			typename base_class::const_iterator _P = pos;
+			_P--;
+			(*this).erase(_P);
+		}
+	};
+
+}
+
+#undef MSE_THROW
+
+#endif /*ndef MSEMSEVECTOR_H*/
diff --git a/src/debug/mse/msemstdvector.h b/src/debug/mse/msemstdvector.h
new file mode 100644
index 000000000..4cb92be7a
--- /dev/null
+++ b/src/debug/mse/msemstdvector.h
@@ -0,0 +1,396 @@
+
+// Copyright (c) 2015 Noah Lopez
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+#ifndef MSEMSTDVECTOR_H
+#define MSEMSTDVECTOR_H
+
+#include "debug/mse/msemsevector.h"
+
+#ifdef MSE_SAFER_SUBSTITUTES_DISABLED
+#define MSE_MSTDVECTOR_DISABLED
+#endif /*MSE_SAFER_SUBSTITUTES_DISABLED*/
+
+namespace mse {
+
+	namespace mstd {
+
+#ifdef MSE_MSTDVECTOR_DISABLED
+		template<class _Ty, class _A = std::allocator<_Ty> > using vector = std::vector<_Ty, _A>;
+
+#else /*MSE_MSTDVECTOR_DISABLED*/
+
+#ifndef _NOEXCEPT
+#define _NOEXCEPT
+#endif /*_NOEXCEPT*/
+
+		template<class _Ty, class _A = std::allocator<_Ty> >
+		class vector {
+		public:
+			typedef mse::mstd::vector<_Ty, _A> _Myt;
+			typedef mse::msevector<_Ty, _A> _MV;
+
+			typedef typename _MV::allocator_type allocator_type;
+			typedef typename _MV::value_type value_type;
+			typedef typename _MV::size_type size_type;
+			typedef typename _MV::difference_type difference_type;
+			typedef typename _MV::pointer pointer;
+			typedef typename _MV::const_pointer const_pointer;
+			typedef typename _MV::reference reference;
+			typedef typename _MV::const_reference const_reference;
+
+			const _MV& msevector() const { return (*m_shptr); }
+			_MV& msevector() { return (*m_shptr); }
+			operator const _MV() const { return msevector(); }
+			operator _MV() { return msevector(); }
+
+			explicit vector(const _A& _Al = _A()) : m_shptr(std::make_shared<_MV>(_Al)) {}
+			explicit vector(size_type _N) : m_shptr(std::make_shared<_MV>(_N)) {}
+			explicit vector(size_type _N, const _Ty& _V, const _A& _Al = _A()) : m_shptr(std::make_shared<_MV>(_N, _V, _Al)) {}
+			vector(_Myt&& _X) : m_shptr(std::make_shared<_MV>(std::move(_X.msevector()))) {}
+			vector(const _Myt& _X) : m_shptr(std::make_shared<_MV>(_X.msevector())) {}
+			vector(_MV&& _X) : m_shptr(std::make_shared<_MV>(std::move(_X))) {}
+			vector(const _MV& _X) : m_shptr(std::make_shared<_MV>(_X)) {}
+			vector(std::vector<_Ty>&& _X) : m_shptr(std::make_shared<_MV>(std::move(_X))) {}
+			vector(const std::vector<_Ty>& _X) : m_shptr(std::make_shared<_MV>(_X)) {}
+			typedef typename _MV::const_iterator _It;
+			vector(_It _F, _It _L, const _A& _Al = _A()) : m_shptr(std::make_shared<_MV>(_F, _L, _Al)) {}
+			vector(const _Ty* _F, const _Ty* _L, const _A& _Al = _A()) : m_shptr(std::make_shared<_MV>(_F, _L, _Al)) {}
+			template<class _Iter, class = typename std::enable_if<_mse_Is_iterator<_Iter>::value, void>::type>
+			vector(_Iter _First, _Iter _Last) : m_shptr(std::make_shared<_MV>(_First, _Last)) {}
+			template<class _Iter, class = typename std::enable_if<_mse_Is_iterator<_Iter>::value, void>::type>
+			vector(_Iter _First, _Iter _Last, const _A& _Al) : m_shptr(std::make_shared<_MV>(_First, _Last, _Al)) {}
+
+			_Myt& operator=(_MV&& _X) { m_shptr->operator=(std::move(_X)); return (*this); }
+			_Myt& operator=(const _MV& _X) { m_shptr->operator=(_X); return (*this); }
+			_Myt& operator=(_Myt&& _X) { m_shptr->operator=(std::move(_X.msevector())); return (*this); }
+			_Myt& operator=(const _Myt& _X) { m_shptr->operator=(_X.msevector()); return (*this); }
+			void reserve(size_type _Count) { m_shptr->reserve(_Count); }
+			void resize(size_type _N, const _Ty& _X = _Ty()) { m_shptr->resize(_N, _X); }
+			typename _MV::const_reference operator[](size_type _P) const { return m_shptr->operator[](_P); }
+			typename _MV::reference operator[](size_type _P) { return m_shptr->operator[](_P); }
+			void push_back(_Ty&& _X) { m_shptr->push_back(std::move(_X)); }
+			void push_back(const _Ty& _X) { m_shptr->push_back(_X); }
+			void pop_back() { m_shptr->pop_back(); }
+			void assign(_It _F, _It _L) { m_shptr->assign(_F, _L); }
+			void assign(size_type _N, const _Ty& _X = _Ty()) { m_shptr->assign(_N, _X); }
+			template<class ..._Valty>
+			void emplace_back(_Valty&& ..._Val) { m_shptr->emplace_back(std::forward<_Valty>(_Val)...); }
+			void clear() { m_shptr->clear(); }
+			void swap(_MV& _X) { m_shptr->swap(_X); }
+			void swap(_Myt& _X) { m_shptr->swap(_X.msevector()); }
+
+			vector(_XSTD initializer_list<typename _MV::value_type> _Ilist, const _A& _Al = _A()) : m_shptr(std::make_shared<_MV>(_Ilist, _Al)) {}
+			_Myt& operator=(_XSTD initializer_list<typename _MV::value_type> _Ilist) { m_shptr->operator=(_Ilist); return (*this); }
+			void assign(_XSTD initializer_list<typename _MV::value_type> _Ilist) { m_shptr->assign(_Ilist); }
+
+			size_type capacity() const _NOEXCEPT{ return m_shptr->capacity(); }
+			void shrink_to_fit() { m_shptr->shrink_to_fit(); }
+			size_type size() const _NOEXCEPT{ return m_shptr->size(); }
+			size_type max_size() const _NOEXCEPT{ return m_shptr->max_size(); }
+			bool empty() const _NOEXCEPT{ return m_shptr->empty(); }
+			_A get_allocator() const _NOEXCEPT{ return m_shptr->get_allocator(); }
+			typename _MV::const_reference at(size_type _Pos) const { return m_shptr->at(_Pos); }
+			typename _MV::reference at(size_type _Pos) { return m_shptr->at(_Pos); }
+			typename _MV::reference front() { return m_shptr->front(); }
+			typename _MV::const_reference front() const { return m_shptr->front(); }
+			typename _MV::reference back() { return m_shptr->back(); }
+			typename _MV::const_reference back() const { return m_shptr->back(); }
+
+			/* Try to avoid using these whenever possible. */
+			value_type *data() _NOEXCEPT {
+				return m_shptr->data();
+			}
+			const value_type *data() const _NOEXCEPT {
+				return m_shptr->data();
+			}
+
+
+			class const_iterator : public _MV::random_access_const_iterator_base {
+			public:
+				typedef typename _MV::ss_const_iterator_type::iterator_category iterator_category;
+				typedef typename _MV::ss_const_iterator_type::value_type value_type;
+				typedef typename _MV::ss_const_iterator_type::difference_type difference_type;
+				typedef typename _MV::difference_type distance_type;	// retained
+				typedef typename _MV::ss_const_iterator_type::pointer pointer;
+				typedef typename _MV::ss_const_iterator_type::reference reference;
+
+				const_iterator() {}
+				const_iterator(const const_iterator& src_cref) : m_msevector_cshptr(src_cref.m_msevector_cshptr) {
+					(*this) = src_cref;
+				}
+				~const_iterator() {}
+				const typename _MV::ss_const_iterator_type& msevector_ss_const_iterator_type() const { return m_ss_const_iterator; }
+				typename _MV::ss_const_iterator_type& msevector_ss_const_iterator_type() { return m_ss_const_iterator; }
+				const typename _MV::ss_const_iterator_type& mvssci() const { return msevector_ss_const_iterator_type(); }
+				typename _MV::ss_const_iterator_type& mvssci() { return msevector_ss_const_iterator_type(); }
+
+				void reset() { msevector_ss_const_iterator_type().reset(); }
+				bool points_to_an_item() const { return msevector_ss_const_iterator_type().points_to_an_item(); }
+				bool points_to_end_marker() const { return msevector_ss_const_iterator_type().points_to_end_marker(); }
+				bool points_to_beginning() const { return msevector_ss_const_iterator_type().points_to_beginning(); }
+				/* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */
+				bool has_next_item_or_end_marker() const { return msevector_ss_const_iterator_type().has_next_item_or_end_marker(); }
+				/* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */
+				bool has_next() const { return msevector_ss_const_iterator_type().has_next(); }
+				bool has_previous() const { return msevector_ss_const_iterator_type().has_previous(); }
+				void set_to_beginning() { msevector_ss_const_iterator_type().set_to_beginning(); }
+				void set_to_end_marker() { msevector_ss_const_iterator_type().set_to_end_marker(); }
+				void set_to_next() { msevector_ss_const_iterator_type().set_to_next(); }
+				void set_to_previous() { msevector_ss_const_iterator_type().set_to_previous(); }
+				const_iterator& operator ++() { msevector_ss_const_iterator_type().operator ++(); return (*this); }
+				const_iterator operator++(int) { const_iterator _Tmp = *this; ++*this; return (_Tmp); }
+				const_iterator& operator --() { msevector_ss_const_iterator_type().operator --(); return (*this); }
+				const_iterator operator--(int) { const_iterator _Tmp = *this; --*this; return (_Tmp); }
+				void advance(typename _MV::difference_type n) { msevector_ss_const_iterator_type().advance(n); }
+				void regress(typename _MV::difference_type n) { msevector_ss_const_iterator_type().regress(n); }
+				const_iterator& operator +=(difference_type n) { msevector_ss_const_iterator_type().operator +=(n); return (*this); }
+				const_iterator& operator -=(difference_type n) { msevector_ss_const_iterator_type().operator -=(n); return (*this); }
+				const_iterator operator+(difference_type n) const { auto retval = (*this); retval += n; return retval; }
+				const_iterator operator-(difference_type n) const { return ((*this) + (-n)); }
+				typename _MV::difference_type operator-(const const_iterator& _Right_cref) const { return msevector_ss_const_iterator_type() - (_Right_cref.msevector_ss_const_iterator_type()); }
+				typename _MV::const_reference operator*() const { return msevector_ss_const_iterator_type().operator*(); }
+				typename _MV::const_reference item() const { return operator*(); }
+				typename _MV::const_reference previous_item() const { return msevector_ss_const_iterator_type().previous_item(); }
+				typename _MV::const_pointer operator->() const { return msevector_ss_const_iterator_type().operator->(); }
+				typename _MV::const_reference operator[](typename _MV::difference_type _Off) const { return (*(*this + _Off)); }
+				bool operator==(const const_iterator& _Right_cref) const { return msevector_ss_const_iterator_type().operator==(_Right_cref.msevector_ss_const_iterator_type()); }
+				bool operator!=(const const_iterator& _Right_cref) const { return (!(_Right_cref == (*this))); }
+				bool operator<(const const_iterator& _Right) const { return (msevector_ss_const_iterator_type() < _Right.msevector_ss_const_iterator_type()); }
+				bool operator<=(const const_iterator& _Right) const { return (msevector_ss_const_iterator_type() <= _Right.msevector_ss_const_iterator_type()); }
+				bool operator>(const const_iterator& _Right) const { return (msevector_ss_const_iterator_type() > _Right.msevector_ss_const_iterator_type()); }
+				bool operator>=(const const_iterator& _Right) const { return (msevector_ss_const_iterator_type() >= _Right.msevector_ss_const_iterator_type()); }
+				void set_to_const_item_pointer(const const_iterator& _Right_cref) { msevector_ss_const_iterator_type().set_to_const_item_pointer(_Right_cref.msevector_ss_const_iterator_type()); }
+				msev_size_t position() const { return msevector_ss_const_iterator_type().position(); }
+			private:
+				const_iterator(std::shared_ptr<_MV> msevector_shptr) : m_msevector_cshptr(msevector_shptr) {
+					m_ss_const_iterator = msevector_shptr->ss_cbegin();
+				}
+				std::shared_ptr<const _MV> m_msevector_cshptr;
+				/* m_ss_const_iterator needs to be declared after m_msevector_cshptr so that it's destructor will be called first. */
+				typename _MV::ss_const_iterator_type m_ss_const_iterator;
+				friend class /*_Myt*/vector<_Ty, _A>;
+				friend class iterator;
+			};
+			class iterator : public _MV::random_access_iterator_base {
+			public:
+				typedef typename _MV::ss_iterator_type::iterator_category iterator_category;
+				typedef typename _MV::ss_iterator_type::value_type value_type;
+				typedef typename _MV::ss_iterator_type::difference_type difference_type;
+				typedef typename _MV::difference_type distance_type;	// retained
+				typedef typename _MV::ss_iterator_type::pointer pointer;
+				typedef typename _MV::ss_iterator_type::reference reference;
+
+				iterator() {}
+				iterator(const iterator& src_cref) : m_msevector_shptr(src_cref.m_msevector_shptr) {
+					(*this) = src_cref;
+				}
+				~iterator() {}
+				const typename _MV::ss_iterator_type& msevector_ss_iterator_type() const { return m_ss_iterator; }
+				typename _MV::ss_iterator_type& msevector_ss_iterator_type() { return m_ss_iterator; }
+				const typename _MV::ss_iterator_type& mvssi() const { return msevector_ss_iterator_type(); }
+				typename _MV::ss_iterator_type& mvssi() { return msevector_ss_iterator_type(); }
+				operator const_iterator() const {
+					const_iterator retval(m_msevector_shptr);
+					if (m_msevector_shptr) {
+						retval.msevector_ss_const_iterator_type().set_to_beginning();
+						retval.msevector_ss_const_iterator_type().advance(msev_int(msevector_ss_iterator_type().position()));
+					}
+					return retval;
+				}
+
+				void reset() { msevector_ss_iterator_type().reset(); }
+				bool points_to_an_item() const { return msevector_ss_iterator_type().points_to_an_item(); }
+				bool points_to_end_marker() const { return msevector_ss_iterator_type().points_to_end_marker(); }
+				bool points_to_beginning() const { return msevector_ss_iterator_type().points_to_beginning(); }
+				/* has_next_item_or_end_marker() is just an alias for points_to_an_item(). */
+				bool has_next_item_or_end_marker() const { return msevector_ss_iterator_type().has_next_item_or_end_marker(); }
+				/* has_next() is just an alias for points_to_an_item() that's familiar to java programmers. */
+				bool has_next() const { return msevector_ss_iterator_type().has_next(); }
+				bool has_previous() const { return msevector_ss_iterator_type().has_previous(); }
+				void set_to_beginning() { msevector_ss_iterator_type().set_to_beginning(); }
+				void set_to_end_marker() { msevector_ss_iterator_type().set_to_end_marker(); }
+				void set_to_next() { msevector_ss_iterator_type().set_to_next(); }
+				void set_to_previous() { msevector_ss_iterator_type().set_to_previous(); }
+				iterator& operator ++() { msevector_ss_iterator_type().operator ++(); return (*this); }
+				iterator operator++(int) { iterator _Tmp = *this; ++*this; return (_Tmp); }
+				iterator& operator --() { msevector_ss_iterator_type().operator --(); return (*this); }
+				iterator operator--(int) { iterator _Tmp = *this; --*this; return (_Tmp); }
+				void advance(typename _MV::difference_type n) { msevector_ss_iterator_type().advance(n); }
+				void regress(typename _MV::difference_type n) { msevector_ss_iterator_type().regress(n); }
+				iterator& operator +=(difference_type n) { msevector_ss_iterator_type().operator +=(n); return (*this); }
+				iterator& operator -=(difference_type n) { msevector_ss_iterator_type().operator -=(n); return (*this); }
+				iterator operator+(difference_type n) const { auto retval = (*this); retval += n; return retval; }
+				iterator operator-(difference_type n) const { return ((*this) + (-n)); }
+				typename _MV::difference_type operator-(const iterator& _Right_cref) const { return msevector_ss_iterator_type() - (_Right_cref.msevector_ss_iterator_type()); }
+				typename _MV::reference operator*() const { return msevector_ss_iterator_type().operator*(); }
+				typename _MV::reference item() const { return operator*(); }
+				typename _MV::reference previous_item() const { return msevector_ss_iterator_type().previous_item(); }
+				typename _MV::pointer operator->() const { return msevector_ss_iterator_type().operator->(); }
+				typename _MV::reference operator[](typename _MV::difference_type _Off) const { return (*(*this + _Off)); }
+				bool operator==(const iterator& _Right_cref) const { return msevector_ss_iterator_type().operator==(_Right_cref.msevector_ss_iterator_type()); }
+				bool operator!=(const iterator& _Right_cref) const { return (!(_Right_cref == (*this))); }
+				bool operator<(const iterator& _Right) const { return (msevector_ss_iterator_type() < _Right.msevector_ss_iterator_type()); }
+				bool operator<=(const iterator& _Right) const { return (msevector_ss_iterator_type() <= _Right.msevector_ss_iterator_type()); }
+				bool operator>(const iterator& _Right) const { return (msevector_ss_iterator_type() > _Right.msevector_ss_iterator_type()); }
+				bool operator>=(const iterator& _Right) const { return (msevector_ss_iterator_type() >= _Right.msevector_ss_iterator_type()); }
+				void set_to_item_pointer(const iterator& _Right_cref) { msevector_ss_iterator_type().set_to_item_pointer(_Right_cref.msevector_ss_iterator_type()); }
+				msev_size_t position() const { return msevector_ss_iterator_type().position(); }
+			private:
+				std::shared_ptr<_MV> m_msevector_shptr;
+				/* m_ss_iterator needs to be declared after m_msevector_shptr so that it's destructor will be called first. */
+				typename _MV::ss_iterator_type m_ss_iterator;
+				friend class /*_Myt*/vector<_Ty, _A>;
+			};
+
+			iterator begin()
+			{	// return iterator for beginning of mutable sequence
+				iterator retval; retval.m_msevector_shptr = this->m_shptr;
+				(retval.m_ss_iterator) = m_shptr->ss_begin();
+				return retval;
+			}
+
+			const_iterator begin() const
+			{	// return iterator for beginning of nonmutable sequence
+				const_iterator retval; retval.m_msevector_cshptr = this->m_shptr;
+				(retval.m_ss_const_iterator) = m_shptr->ss_begin();
+				return retval;
+			}
+
+			iterator end() {	// return iterator for end of mutable sequence
+				iterator retval; retval.m_msevector_shptr = this->m_shptr;
+				(retval.m_ss_iterator) = m_shptr->ss_end();
+				return retval;
+			}
+			const_iterator end() const {	// return iterator for end of nonmutable sequence
+				const_iterator retval; retval.m_msevector_cshptr = this->m_shptr;
+				(retval.m_ss_const_iterator) = m_shptr->ss_end();
+				return retval;
+			}
+			const_iterator cbegin() const {	// return iterator for beginning of nonmutable sequence
+				const_iterator retval; retval.m_msevector_cshptr = this->m_shptr;
+				(retval.m_ss_const_iterator) = m_shptr->ss_cbegin();
+				return retval;
+			}
+			const_iterator cend() const {	// return iterator for end of nonmutable sequence
+				const_iterator retval; retval.m_msevector_cshptr = this->m_shptr;
+				(retval.m_ss_const_iterator) = m_shptr->ss_cend();
+				return retval;
+			}
+
+
+			vector(const const_iterator &start, const const_iterator &end, const _A& _Al = _A())
+				: m_shptr(std::make_shared<_MV>(start.msevector_ss_const_iterator_type(), end.msevector_ss_const_iterator_type(), _Al)) {}
+			void assign(const const_iterator &start, const const_iterator &end) {
+				m_shptr->assign(start.msevector_ss_const_iterator_type(), end.msevector_ss_const_iterator_type());
+			}
+			void assign_inclusive(const const_iterator &first, const const_iterator &last) {
+				m_shptr->assign_inclusive(first.msevector_ss_const_iterator_type(), last.msevector_ss_const_iterator_type());
+			}
+			iterator insert_before(const const_iterator &pos, size_type _M, const _Ty& _X) {
+				auto res = m_shptr->insert_before(pos.msevector_ss_const_iterator_type(), _M, _X);
+				iterator retval = begin(); retval.msevector_ss_iterator_type() = res;
+				return retval;
+			}
+			iterator insert_before(const const_iterator &pos, _Ty&& _X) {
+				auto res = m_shptr->insert_before(pos.msevector_ss_const_iterator_type(), std::move(_X));
+				iterator retval = begin(); retval.msevector_ss_iterator_type() = res;
+				return retval;
+			}
+			iterator insert_before(const const_iterator &pos, const _Ty& _X = _Ty()) { return insert_before(pos, 1, _X); }
+			template<class _Iter
+				//>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type
+				, class = _mse_RequireInputIter<_Iter> >
+			iterator insert_before(const const_iterator &pos, const _Iter &start, const _Iter &end) {
+				auto res = m_shptr->insert_before(pos.msevector_ss_const_iterator_type(), start, end);
+				iterator retval = begin(); retval.msevector_ss_iterator_type() = res;
+				return retval;
+			}
+			template<class _Iter
+				//>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type
+				, class = _mse_RequireInputIter<_Iter> >
+			iterator insert_before_inclusive(const const_iterator &pos, const _Iter &first, const _Iter &last) {
+				auto end = last; end++;
+				return insert_before(pos, first, end);
+			}
+			iterator insert_before(const const_iterator &pos, _XSTD initializer_list<typename _MV::value_type> _Ilist) {	// insert initializer_list
+				auto res = m_shptr->insert_before(pos.msevector_ss_const_iterator_type(), _Ilist);
+				iterator retval = begin(); retval.msevector_ss_iterator_type() = res;
+				return retval;
+			}
+			void insert_before(msev_size_t pos, const _Ty& _X = _Ty()) {
+				m_shptr->insert_before(pos, _X);
+			}
+			void insert_before(msev_size_t pos, size_type _M, const _Ty& _X) {
+				m_shptr->insert_before(pos, _M, _X);
+			}
+			void insert_before(msev_size_t pos, _XSTD initializer_list<typename _MV::value_type> _Ilist) {	// insert initializer_list
+				m_shptr->insert_before(pos, _Ilist);
+			}
+			/* These insert() functions are just aliases for their corresponding insert_before() functions. */
+			iterator insert(const const_iterator &pos, size_type _M, const _Ty& _X) { return insert_before(pos, _M, _X); }
+			iterator insert(const const_iterator &pos, _Ty&& _X) { return insert_before(pos, std::move(_X)); }
+			iterator insert(const const_iterator &pos, const _Ty& _X = _Ty()) { return insert_before(pos, _X); }
+			template<class _Iter
+				//>typename std::enable_if<_mse_Is_iterator<_Iter>::value, typename base_class::iterator>::type
+				, class = _mse_RequireInputIter<_Iter> >
+			iterator insert(const const_iterator &pos, const _Iter &start, const _Iter &end) { return insert_before(pos, start, end); }
+			iterator insert(const const_iterator &pos, const _Ty* start, const _Ty* end) { return insert_before(pos, start, end); }
+			iterator insert(const const_iterator &pos, _XSTD initializer_list<typename _MV::value_type> _Ilist) { return insert_before(pos, _Ilist); }
+			template<class ..._Valty>
+			iterator emplace(const const_iterator &pos, _Valty&& ..._Val) {
+				auto res = m_shptr->emplace(pos.msevector_ss_const_iterator_type(), std::forward<_Valty>(_Val)...);
+				iterator retval = begin(); retval.msevector_ss_iterator_type() = res;
+				return retval;
+			}
+			iterator erase(const const_iterator &pos) {
+				auto res = m_shptr->erase(pos.msevector_ss_const_iterator_type());
+				iterator retval = begin(); retval.msevector_ss_iterator_type() = res;
+				return retval;
+			}
+			iterator erase(const const_iterator &start, const const_iterator &end) {
+				auto res = m_shptr->erase(start.msevector_ss_const_iterator_type(), end.msevector_ss_const_iterator_type());
+				iterator retval = begin(); retval.msevector_ss_iterator_type() = res;
+				return retval;
+			}
+			iterator erase_inclusive(const const_iterator &first, const const_iterator &last) {
+				auto end = last; end.set_to_next();
+				return erase_inclusive(first, end);
+			}
+			bool operator==(const _Myt& _Right) const {	// test for vector equality
+				return ((*(_Right.m_shptr)) == (*m_shptr));
+			}
+			bool operator<(const _Myt& _Right) const {	// test if _Left < _Right for vectors
+				return ((*m_shptr) < (*(_Right.m_shptr)));
+			}
+
+		private:
+			std::shared_ptr<_MV> m_shptr;
+		};
+
+		template<class _Ty, class _Alloc> inline bool operator!=(const vector<_Ty, _Alloc>& _Left,
+			const vector<_Ty, _Alloc>& _Right) {	// test for vector inequality
+			return (!(_Left == _Right));
+		}
+
+		template<class _Ty, class _Alloc> inline bool operator>(const vector<_Ty, _Alloc>& _Left,
+			const vector<_Ty, _Alloc>& _Right) {	// test if _Left > _Right for vectors
+			return (_Right < _Left);
+		}
+
+		template<class _Ty, class _Alloc> inline bool operator<=(const vector<_Ty, _Alloc>& _Left,
+			const vector<_Ty, _Alloc>& _Right) {	// test if _Left <= _Right for vectors
+			return (!(_Right < _Left));
+		}
+
+		template<class _Ty, class _Alloc> inline bool operator>=(const vector<_Ty, _Alloc>& _Left,
+			const vector<_Ty, _Alloc>& _Right) {	// test if _Left >= _Right for vectors
+			return (!(_Left < _Right));
+		}
+#endif /*MSE_MSTDVECTOR_DISABLED*/
+	}
+}
+#endif /*ndef MSEMSTDVECTOR_H*/
diff --git a/src/debug/mse/mseprimitives.h b/src/debug/mse/mseprimitives.h
new file mode 100644
index 000000000..b470288b9
--- /dev/null
+++ b/src/debug/mse/mseprimitives.h
@@ -0,0 +1,873 @@
+
+// Copyright (c) 2015 Noah Lopez
+// Use, modification, and distribution is subject to the Boost Software
+// License, Version 1.0. (See accompanying file LICENSE_1_0.txt or copy at
+// http://www.boost.org/LICENSE_1_0.txt)
+
+#pragma once
+#ifndef MSEPRIMITIVES_H
+#define MSEPRIMITIVES_H
+
+#include <assert.h>
+#include <climits>       // ULONG_MAX
+#include <limits>       // std::numeric_limits
+#include <stdexcept>      // primitives_range_error
+
+/*compiler specific defines*/
+#ifdef _MSC_VER
+#if (1700 > _MSC_VER)
+#define MSVC2010_COMPATIBLE 1
+#endif /*(1700 > _MSC_VER)*/
+#if (1900 > _MSC_VER)
+#define MSVC2013_COMPATIBLE 1
+#endif /*(1900 > _MSC_VER)*/
+#if (2000 > _MSC_VER)
+#define MSVC2015_COMPATIBLE 1
+#endif /*(1900 > _MSC_VER)*/
+#else /*_MSC_VER*/
+#if (defined(__GNUC__) || defined(__GNUG__))
+#define GPP_COMPATIBLE 1
+#if ((5 > __GNUC__) && (!defined(__clang__)))
+#define GPP4P8_COMPATIBLE 1
+#endif /*((5 > __GNUC__) && (!defined(__clang__)))*/
+#endif /*(defined(__GNUC__) || defined(__GNUG__))*/
+#endif /*_MSC_VER*/
+
+#ifdef MSE_SAFER_SUBSTITUTES_DISABLED
+#define MSE_PRIMITIVES_DISABLED
+#endif /*MSE_SAFER_SUBSTITUTES_DISABLED*/
+
+#if defined(MSVC2013_COMPATIBLE) || defined(MSVC2010_COMPATIBLE)
+#define MSE_CONSTEXPR
+#else // defined(MSVC2013_COMPATIBLE) || defined(MSVC2010_COMPATIBLE)
+#define MSE_CONSTEXPR constexpr
+#endif // defined(MSVC2013_COMPATIBLE) || defined(MSVC2010_COMPATIBLE)
+
+#ifdef MSVC2015_COMPATIBLE
+#ifndef MSE_FORCE_PRIMITIVE_ASSIGN_RANGE_CHECK_ENABLED
+/* msvc2015's incomplete support for "constexpr" means that range checks that should be done at compile time would
+be done at run time, at significant cost. So by default we disable range checks upon assignment. */
+#define MSE_PRIMITIVE_ASSIGN_RANGE_CHECK_DISABLED 1
+#endif // !MSE_FORCE_PRIMITIVE_ASSIGN_RANGE_CHECK_ENABLED
+#endif // MSVC2015_COMPATIBLE
+
+
+#ifdef MSE_CUSTOM_THROW_DEFINITION
+#include <iostream>
+#define MSE_THROW(x) MSE_CUSTOM_THROW_DEFINITION(x)
+#else // MSE_CUSTOM_THROW_DEFINITION
+#define MSE_THROW(x) throw(x)
+#endif // MSE_CUSTOM_THROW_DEFINITION
+
+
+#ifndef MSE_CINT_BASE_INTEGER_TYPE
+#if SIZE_MAX <= ULONG_MAX
+#define MSE_CINT_BASE_INTEGER_TYPE long int
+#else // SIZE_MAX <= ULONG_MAX
+#define MSE_CINT_BASE_INTEGER_TYPE long long int
+#endif // SIZE_MAX <= ULONG_MAX
+#endif // !MSE_CINT_BASE_INTEGER_TYPE
+
+
+namespace mse {
+
+	class primitives_range_error : public std::range_error {
+	public:
+		using std::range_error::range_error;
+	};
+
+	/* When the mse primitive replacements are "disabled" they lose their default initialization and may cause problems for
+	code that relies on it. */
+#ifdef MSE_PRIMITIVES_DISABLED
+	typedef bool CBool;
+	typedef MSE_CINT_BASE_INTEGER_TYPE CInt;
+	typedef size_t CSize_t;
+	static size_t as_a_size_t(CSize_t n) { return (n); }
+#else /*MSE_PRIMITIVES_DISABLED*/
+
+#ifndef NDEBUG
+#ifndef MSE_SUPPRESS_CHECK_USE_BEFORE_SET
+#define MSE_CHECK_USE_BEFORE_SET
+#endif // !MSE_SUPPRESS_CHECK_USE_BEFORE_SET
+#endif // !NDEBUG
+
+	/* This class is just meant to act like the "bool" type, except that it has a default intialization value (false). */
+	class CBool {
+	public:
+		// Constructs zero.
+		CBool() : m_val(false) {}
+
+		// Copy constructor
+		CBool(const CBool &x) : m_val(x.m_val) { note_value_assignment(); };
+
+		// Assignment operator
+		CBool& operator=(const CBool &x) { note_value_assignment(); m_val = x.m_val; return (*this); }
+
+		// Constructors from primitive boolean types
+		CBool(bool   x) { note_value_assignment(); m_val = x; }
+
+		// Casts to primitive boolean types
+		operator bool() const { assert_initialized(); return m_val; }
+
+		CBool& operator |=(const CBool &x) { assert_initialized(); m_val |= x.m_val; return (*this); }
+		CBool& operator &=(const CBool &x) { assert_initialized(); m_val &= x.m_val; return (*this); }
+		CBool& operator ^=(const CBool &x) { assert_initialized(); m_val ^= x.m_val; return (*this); }
+
+		bool m_val;
+
+#ifdef MSE_CHECK_USE_BEFORE_SET
+		void note_value_assignment() { m_initialized = true; }
+		void assert_initialized() const { assert(m_initialized); }
+		bool m_initialized = false;
+#else // MSE_CHECK_USE_BEFORE_SET
+		void note_value_assignment() {}
+		void assert_initialized() const {}
+#endif // MSE_CHECK_USE_BEFORE_SET
+	};
+
+
+	template<typename _TDestination, typename _TSource>
+	MSE_CONSTEXPR static bool sg_can_exceed_upper_bound() {
+		return (
+			((std::numeric_limits<_TSource>::is_signed == std::numeric_limits<_TDestination>::is_signed)
+				&& (std::numeric_limits<_TSource>::digits > std::numeric_limits<_TDestination>::digits))
+			|| ((std::numeric_limits<_TSource>::is_signed != std::numeric_limits<_TDestination>::is_signed)
+				&& ((std::numeric_limits<_TSource>::is_signed && (std::numeric_limits<_TSource>::digits > (1 + std::numeric_limits<_TDestination>::digits)))
+					|| ((!std::numeric_limits<_TSource>::is_signed) && ((1 + std::numeric_limits<_TSource>::digits) > std::numeric_limits<_TDestination>::digits))
+					)
+				)
+			);
+	}
+	template<typename _TDestination, typename _TSource>
+	MSE_CONSTEXPR static bool sg_can_exceed_lower_bound() {
+		return (
+			(std::numeric_limits<_TSource>::is_signed && (!std::numeric_limits<_TDestination>::is_signed))
+			|| (std::numeric_limits<_TSource>::is_signed && (std::numeric_limits<_TSource>::digits > std::numeric_limits<_TDestination>::digits))
+			);
+	}
+
+	template<typename _TDestination, typename _TSource>
+	void g_assign_check_range(const _TSource &x) {
+#ifndef MSE_PRIMITIVE_ASSIGN_RANGE_CHECK_DISABLED
+		/* This probably needs to be cleaned up. But at the moment this should be mostly compile time complexity. And
+		as is it avoids "signed/unsigned" mismatch warnings. */
+		MSE_CONSTEXPR const bool rhs_can_exceed_upper_bound = sg_can_exceed_upper_bound<_TDestination, _TSource>();
+		MSE_CONSTEXPR const bool rhs_can_exceed_lower_bound = sg_can_exceed_lower_bound<_TDestination, _TSource>();
+		MSE_CONSTEXPR const bool can_exceed_bounds = rhs_can_exceed_upper_bound || rhs_can_exceed_lower_bound;
+		if (can_exceed_bounds) {
+			if (rhs_can_exceed_upper_bound) {
+				if (x > _TSource(std::numeric_limits<_TDestination>::max())) {
+					MSE_THROW(primitives_range_error("range error - value to be assigned is out of range of the target (integer) type"));
+				}
+			}
+			if (rhs_can_exceed_lower_bound) {
+				/* We're assuming that std::numeric_limits<>::lowest() will never be greater than zero. */
+				if (0 > x) {
+					if (0 == std::numeric_limits<_TDestination>::lowest()) {
+						MSE_THROW(primitives_range_error("range error - value to be assigned is out of range of the target (integer) type"));
+					}
+					else if (x < _TSource(std::numeric_limits<_TDestination>::lowest())) {
+						MSE_THROW(primitives_range_error("range error - value to be assigned is out of range of the target (integer) type"));
+					}
+				}
+			}
+		}
+#endif // !MSE_PRIMITIVE_ASSIGN_RANGE_CHECK_DISABLED
+	}
+
+	/* The CInt and CSize_t classes are meant to substitute for standard "int" and "size_t" types. The differences between
+	the standard types and these classes are that the classes have a default intialization value (zero), and the
+	classes, as much as possible, try to prevent the problematic behaviour of (possibly negative) signed integers
+	being cast (inadvertently) to the unsigned size_t type. For example, the expression (0 > (int)5 - (size_t)7) evaluates
+	(unintuitively) to false, whereas the expression (0 > (CInt)5 - (CSize_t)7) evaluates to true. Also, the classes do
+	some range checking. For example, the code "CSize_t s = -2;" will throw an exception. */
+	template<typename _Ty>
+	class TIntBase1 {
+	public:
+		// Constructs zero.
+		TIntBase1() : m_val(0) {}
+
+		// Copy constructor
+		TIntBase1(const TIntBase1 &x) : m_val(x.m_val) { note_value_assignment(); };
+
+		// Constructors from primitive integer types
+		explicit TIntBase1(_Ty   x) { note_value_assignment(); m_val = x; }
+
+		template<typename _Tz>
+		void assign_check_range(const _Tz &x) {
+			note_value_assignment();
+			g_assign_check_range<_Ty, _Tz>(x);
+		}
+
+		_Ty m_val;
+
+#ifdef MSE_CHECK_USE_BEFORE_SET
+		void note_value_assignment() { m_initialized = true; }
+		void assert_initialized() const { assert(m_initialized); }
+		bool m_initialized = false;
+#else // MSE_CHECK_USE_BEFORE_SET
+		void note_value_assignment() {}
+		void assert_initialized() const {}
+#endif // MSE_CHECK_USE_BEFORE_SET
+	};
+
+	class CInt : public TIntBase1<MSE_CINT_BASE_INTEGER_TYPE> {
+	public:
+		typedef MSE_CINT_BASE_INTEGER_TYPE _Ty;
+		typedef TIntBase1<_Ty> _Myt;
+
+		// Constructs zero.
+		CInt() : _Myt() {}
+
+		// Copy constructor
+		CInt(const CInt &x) : _Myt(x) {};
+		CInt(const _Myt &x) : _Myt(x) {};
+
+		// Assignment operator
+		CInt& operator=(const CInt &x) { (*this).note_value_assignment(); m_val = x.m_val; return (*this); }
+		//CInt& operator=(const _Ty &x) { (*this).note_value_assignment(); m_val = x; return (*this); }
+
+		CInt& operator=(long long x) { assign_check_range<long long>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		CInt& operator=(long x) { assign_check_range<long>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		CInt& operator=(int x) { assign_check_range<int>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		CInt& operator=(short x) { assign_check_range<short>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		CInt& operator=(char x) { assign_check_range<char>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		CInt& operator=(size_t x) { assign_check_range<size_t>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		//CInt& operator=(CSize_t x) { assign_check_range<size_t>(x.as_a_size_t()); m_val = x.as_a_size_t(); return (*this); }
+		/* We would have liked to have assignment operators for the unsigned primitive integer types, but one of them could
+		potentially clash with the size_t assignment operator. */
+		//CInt& operator=(unsigned long long x) { assign_check_range<unsigned long long>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		//CInt& operator=(unsigned long x) { assign_check_range<unsigned long>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		//CInt& operator=(unsigned int x) { assign_check_range<unsigned int>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		//CInt& operator=(unsigned short x) { assign_check_range<unsigned short>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		//CInt& operator=(unsigned char x) { assign_check_range<unsigned char>(x); m_val = static_cast<_Ty>(x); return (*this); }
+
+		// Constructors from primitive integer types
+		//CInt(_Ty   x) { m_val = x; }
+		CInt(long long  x) { assign_check_range<long long>(x); m_val = static_cast<_Ty>(x); }
+		CInt(long  x) { assign_check_range< long>(x); m_val = static_cast<_Ty>(x); }
+		CInt(int   x) { assign_check_range<int>(x); m_val = static_cast<_Ty>(x); }
+		CInt(short x) { assign_check_range<short>(x); m_val = static_cast<_Ty>(x); }
+		CInt(char x) { assign_check_range<char>(x); m_val = static_cast<_Ty>(x); }
+		CInt(size_t   x) { assign_check_range<size_t>(x); m_val = static_cast<_Ty>(x); }
+		//CInt(CSize_t   x) { assign_check_range<size_t>(x.as_a_size_t()); m_val = x.as_a_size_t(); }
+		/* We would have liked to have constructors for the unsigned primitive integer types, but one of them could
+		potentially clash with the size_t constructor. */
+		//CInt(unsigned long long  x) { assign_check_range<unsigned long long>(x); m_val = static_cast<_Ty>(x); }
+		//CInt(unsigned long  x) { assign_check_range<unsigned long>(x); m_val = static_cast<_Ty>(x); }
+		//CInt(unsigned int   x) { assign_check_range<unsigned int>(x); m_val = static_cast<_Ty>(x); }
+		//CInt(unsigned short x) { assign_check_range<unsigned short>(x); m_val = static_cast<_Ty>(x); }
+		//CInt(unsigned char x) { assign_check_range<unsigned char>(x); m_val = static_cast<_Ty>(x); }
+
+		// Casts to primitive integer types
+		operator _Ty() const { (*this).assert_initialized(); return m_val; }
+
+		CInt operator ~() const { (*this).assert_initialized(); return CInt(~m_val); }
+		CInt& operator |=(const CInt &x) { (*this).assert_initialized(); m_val |= x.m_val; return (*this); }
+		CInt& operator &=(const CInt &x) { (*this).assert_initialized(); m_val &= x.m_val; return (*this); }
+		CInt& operator ^=(const CInt &x) { (*this).assert_initialized(); m_val ^= x.m_val; return (*this); }
+
+		CInt operator -() const { (*this).assert_initialized(); return CInt(-m_val); }
+		CInt& operator +=(const CInt &x) { (*this).assert_initialized(); m_val += x.m_val; return (*this); }
+		CInt& operator -=(const CInt &x) { (*this).assert_initialized(); m_val -= x.m_val; return (*this); }
+		CInt& operator *=(const CInt &x) { (*this).assert_initialized(); m_val *= x.m_val; return (*this); }
+		CInt& operator /=(const CInt &x) { (*this).assert_initialized(); m_val /= x.m_val; return (*this); }
+		CInt& operator %=(const CInt &x) { (*this).assert_initialized(); m_val %= x.m_val; return (*this); }
+		CInt& operator >>=(const CInt &x) { (*this).assert_initialized(); m_val >>= x.m_val; return (*this); }
+		CInt& operator <<=(const CInt &x) { (*this).assert_initialized(); m_val <<= x.m_val; return (*this); }
+
+		CInt operator +(const CInt &x) const { (*this).assert_initialized(); return CInt(m_val + x.m_val); }
+		CInt operator +(long long x) const { (*this).assert_initialized(); return ((*this) + CInt(x)); }
+		CInt operator +(long x) const { (*this).assert_initialized(); return ((*this) + CInt(x)); }
+		CInt operator +(int x) const { (*this).assert_initialized(); return ((*this) + CInt(x)); }
+		CInt operator +(short x) const { (*this).assert_initialized(); return ((*this) + CInt(x)); }
+		CInt operator +(char x) const { (*this).assert_initialized(); return ((*this) + CInt(x)); }
+		CInt operator +(size_t x) const { (*this).assert_initialized(); return ((*this) + CInt(x)); }
+		//CInt operator +(CSize_t x) const { (*this).assert_initialized(); return ((*this) + CInt(x)); }
+
+		CInt operator -(const CInt &x) const { (*this).assert_initialized(); return CInt(m_val - x.m_val); }
+		CInt operator -(long long x) const { (*this).assert_initialized(); return ((*this) - CInt(x)); }
+		CInt operator -(long x) const { (*this).assert_initialized(); return ((*this) - CInt(x)); }
+		CInt operator -(int x) const { (*this).assert_initialized(); return ((*this) - CInt(x)); }
+		CInt operator -(short x) const { (*this).assert_initialized(); return ((*this) - CInt(x)); }
+		CInt operator -(char x) const { (*this).assert_initialized(); return ((*this) - CInt(x)); }
+		CInt operator -(size_t x) const { (*this).assert_initialized(); return ((*this) - CInt(x)); }
+		//CInt operator -(CSize_t x) const { (*this).assert_initialized(); return ((*this) - CInt(x)); }
+
+		CInt operator *(const CInt &x) const { (*this).assert_initialized(); return CInt(m_val * x.m_val); }
+		CInt operator *(long long x) const { (*this).assert_initialized(); return ((*this) * CInt(x)); }
+		CInt operator *(long x) const { (*this).assert_initialized(); return ((*this) * CInt(x)); }
+		CInt operator *(int x) const { (*this).assert_initialized(); return ((*this) * CInt(x)); }
+		CInt operator *(short x) const { (*this).assert_initialized(); return ((*this) * CInt(x)); }
+		CInt operator *(char x) const { (*this).assert_initialized(); return ((*this) * CInt(x)); }
+		CInt operator *(size_t x) const { (*this).assert_initialized(); return ((*this) * CInt(x)); }
+		//CInt operator *(CSize_t x) const { (*this).assert_initialized(); return ((*this) * CInt(x)); }
+
+		CInt operator /(const CInt &x) const { (*this).assert_initialized(); return CInt(m_val / x.m_val); }
+		CInt operator /(long long x) const { (*this).assert_initialized(); return ((*this) / CInt(x)); }
+		CInt operator /(long x) const { (*this).assert_initialized(); return ((*this) / CInt(x)); }
+		CInt operator /(int x) const { (*this).assert_initialized(); return ((*this) / CInt(x)); }
+		CInt operator /(short x) const { (*this).assert_initialized(); return ((*this) / CInt(x)); }
+		CInt operator /(char x) const { (*this).assert_initialized(); return ((*this) / CInt(x)); }
+		CInt operator /(size_t x) const { (*this).assert_initialized(); return ((*this) / CInt(x)); }
+		//CInt operator /(CSize_t x) const { (*this).assert_initialized(); return ((*this) / CInt(x)); }
+
+		bool operator <(const CInt &x) const { (*this).assert_initialized(); return (m_val < x.m_val); }
+		bool operator <(long long x) const { (*this).assert_initialized(); return ((*this) < CInt(x)); }
+		bool operator <(long x) const { (*this).assert_initialized(); return ((*this) < CInt(x)); }
+		bool operator <(int x) const { (*this).assert_initialized(); return ((*this) < CInt(x)); }
+		bool operator <(short x) const { (*this).assert_initialized(); return ((*this) < CInt(x)); }
+		bool operator <(char x) const { (*this).assert_initialized(); return ((*this) < CInt(x)); }
+		bool operator <(size_t x) const { (*this).assert_initialized(); return ((*this) < CInt(x)); }
+		//bool operator <(CSize_t x) const { (*this).assert_initialized(); return ((*this) < CInt(x)); }
+
+		bool operator >(const CInt &x) const { (*this).assert_initialized(); return (m_val > x.m_val); }
+		bool operator >(long long x) const { (*this).assert_initialized(); return ((*this) > CInt(x)); }
+		bool operator >(long x) const { (*this).assert_initialized(); return ((*this) > CInt(x)); }
+		bool operator >(int x) const { (*this).assert_initialized(); return ((*this) > CInt(x)); }
+		bool operator >(short x) const { (*this).assert_initialized(); return ((*this) > CInt(x)); }
+		bool operator >(char x) const { (*this).assert_initialized(); return ((*this) > CInt(x)); }
+		bool operator >(size_t x) const { (*this).assert_initialized(); return ((*this) > CInt(x)); }
+		//bool operator >(CSize_t x) const { (*this).assert_initialized(); return ((*this) > CInt(x)); }
+
+		bool operator <=(const CInt &x) const { (*this).assert_initialized(); return (m_val <= x.m_val); }
+		bool operator <=(long long x) const { (*this).assert_initialized(); return ((*this) <= CInt(x)); }
+		bool operator <=(long x) const { (*this).assert_initialized(); return ((*this) <= CInt(x)); }
+		bool operator <=(int x) const { (*this).assert_initialized(); return ((*this) <= CInt(x)); }
+		bool operator <=(short x) const { (*this).assert_initialized(); return ((*this) <= CInt(x)); }
+		bool operator <=(char x) const { (*this).assert_initialized(); return ((*this) <= CInt(x)); }
+		bool operator <=(size_t x) const { (*this).assert_initialized(); return ((*this) <= CInt(x)); }
+		//bool operator <=(CSize_t x) const { (*this).assert_initialized(); return ((*this) <= CInt(x)); }
+
+		bool operator >=(const CInt &x) const { (*this).assert_initialized(); return (m_val >= x.m_val); }
+		bool operator >=(long long x) const { (*this).assert_initialized(); return ((*this) >= CInt(x)); }
+		bool operator >=(long x) const { (*this).assert_initialized(); return ((*this) >= CInt(x)); }
+		bool operator >=(int x) const { (*this).assert_initialized(); return ((*this) >= CInt(x)); }
+		bool operator >=(short x) const { (*this).assert_initialized(); return ((*this) >= CInt(x)); }
+		bool operator >=(char x) const { (*this).assert_initialized(); return ((*this) >= CInt(x)); }
+		bool operator >=(size_t x) const { (*this).assert_initialized(); return ((*this) >= CInt(x)); }
+		//bool operator >=(CSize_t x) const { (*this).assert_initialized(); return ((*this) >= CInt(x)); }
+
+		bool operator ==(const CInt &x) const { (*this).assert_initialized(); return (m_val == x.m_val); }
+		bool operator ==(long long x) const { (*this).assert_initialized(); return ((*this) == CInt(x)); }
+		bool operator ==(long x) const { (*this).assert_initialized(); return ((*this) == CInt(x)); }
+		bool operator ==(int x) const { (*this).assert_initialized(); return ((*this) == CInt(x)); }
+		bool operator ==(short x) const { (*this).assert_initialized(); return ((*this) == CInt(x)); }
+		bool operator ==(char x) const { (*this).assert_initialized(); return ((*this) == CInt(x)); }
+		bool operator ==(size_t x) const { (*this).assert_initialized(); return ((*this) == CInt(x)); }
+		//bool operator ==(CSize_t x) const { (*this).assert_initialized(); return ((*this) == CInt(x)); }
+
+		bool operator !=(const CInt &x) const { (*this).assert_initialized(); return (m_val != x.m_val); }
+		bool operator !=(long long x) const { (*this).assert_initialized(); return ((*this) != CInt(x)); }
+		bool operator !=(long x) const { (*this).assert_initialized(); return ((*this) != CInt(x)); }
+		bool operator !=(int x) const { (*this).assert_initialized(); return ((*this) != CInt(x)); }
+		bool operator !=(short x) const { (*this).assert_initialized(); return ((*this) != CInt(x)); }
+		bool operator !=(char x) const { (*this).assert_initialized(); return ((*this) != CInt(x)); }
+		bool operator !=(size_t x) const { (*this).assert_initialized(); return ((*this) != CInt(x)); }
+		//bool operator !=(CSize_t x) const { (*this).assert_initialized(); return ((*this) != CInt(x)); }
+
+		// INCREMENT/DECREMENT OPERATORS
+		CInt& operator ++() { (*this).assert_initialized(); m_val++; return (*this); }
+		CInt operator ++(int) {
+			(*this).assert_initialized();
+			CInt tmp(*this); // copy
+			operator++(); // pre-increment
+			return tmp;   // return old value
+		}
+		CInt& operator --() {
+			(*this).assert_initialized();
+			if (0 <= std::numeric_limits<_Ty>::lowest()) {
+				(*this).assert_initialized();
+				(*this) = (*this) - 1; return (*this);
+			}
+			else {
+				(*this).assert_initialized();
+				m_val--; return (*this);
+			}
+		}
+		CInt operator --(int) {
+			(*this).assert_initialized();
+			CInt tmp(*this); // copy
+			operator--(); // pre-decrement
+			return tmp;   // return old value
+		}
+
+		//_Ty m_val;
+	};
+}
+
+namespace std {
+#ifndef _THROW0
+#define _THROW0()
+#endif // !_THROW0
+#ifndef _STCONS
+#define _STCONS(ty, name, val)	static constexpr ty name = static_cast<ty>(val)
+#endif // !_STCONS
+
+	template<> class numeric_limits<mse::CInt> {	// limits for type int
+	public:
+		typedef MSE_CINT_BASE_INTEGER_TYPE _Ty;
+
+		static constexpr _Ty(min)() _THROW0()
+		{	// return minimum value
+			return numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::min();
+		}
+		static constexpr _Ty(max)() _THROW0()
+		{	// return maximum value
+			return numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::max();
+		}
+		static constexpr _Ty lowest() _THROW0()
+		{	// return most negative value
+			return numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::lowest();
+		}
+		static constexpr _Ty epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+			return numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::epsilon();
+		}
+		static constexpr _Ty round_error() _THROW0()
+		{	// return largest rounding error
+			return numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::round_error();
+		}
+		static constexpr _Ty denorm_min() _THROW0()
+		{	// return minimum denormalized value
+			return numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::denorm_min();
+		}
+		static constexpr _Ty infinity() _THROW0()
+		{	// return positive infinity
+			return numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::infinity();
+		}
+		static constexpr _Ty quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+			return numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::quiet_NaN();
+		}
+		static constexpr _Ty signaling_NaN() _THROW0()
+		{	// return signaling NaN
+			return numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::signaling_NaN();
+		}
+		_STCONS(float_denorm_style, has_denorm, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::has_denorm);
+		_STCONS(bool, has_denorm_loss, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::has_denorm_loss);
+		_STCONS(bool, has_infinity, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::has_infinity);
+		_STCONS(bool, has_quiet_NaN, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::has_quiet_NaN);
+		_STCONS(bool, has_signaling_NaN, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::has_signaling_NaN);
+		_STCONS(bool, is_bounded, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::is_bounded);
+		_STCONS(bool, is_exact, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::is_exact);
+		_STCONS(bool, is_iec559, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::is_iec559);
+		_STCONS(bool, is_integer, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::is_integer);
+		_STCONS(bool, is_modulo, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::is_modulo);
+		_STCONS(bool, is_signed, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::is_signed);
+		_STCONS(bool, is_specialized, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::is_specialized);
+		_STCONS(bool, tinyness_before, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::tinyness_before);
+		_STCONS(bool, traps, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::traps);
+		_STCONS(float_round_style, round_style, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::round_style);
+		_STCONS(int, digits, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::digits);
+		_STCONS(int, digits10, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::digits10);
+		_STCONS(int, max_digits10, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::max_digits10);
+		_STCONS(int, max_exponent, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::max_exponent);
+		_STCONS(int, max_exponent10, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::max_exponent10);
+		_STCONS(int, min_exponent, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::min_exponent);
+		_STCONS(int, min_exponent10, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::min_exponent10);
+		_STCONS(int, radix, numeric_limits<MSE_CINT_BASE_INTEGER_TYPE>::radix);
+	};
+}
+
+namespace mse {
+	class CSize_t;
+	static size_t as_a_size_t(CSize_t n);
+
+	/* Note that CSize_t does not have a default conversion to size_t. This is by design. Use the as_a_size_t() member
+	function to get a size_t when necessary. */
+	class CSize_t : public TIntBase1<size_t> {
+	public:
+		typedef size_t _Ty;
+		typedef int _T_signed_primitive_integer_type;
+		typedef TIntBase1<_Ty> _Myt;
+
+		// Constructs zero.
+		CSize_t() : _Myt() {}
+
+		// Copy constructor
+		CSize_t(const CSize_t &x) : _Myt(x) {};
+		CSize_t(const _Myt &x) : _Myt(x) {};
+
+		// Assignment operator
+		CSize_t& operator=(const CSize_t &x) { m_val = x.m_val; return (*this); }
+		//CSize_t& operator=(const _Ty &x) { m_val = x; return (*this); }
+
+		CSize_t& operator=(long long x) { assign_check_range<long long>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		CSize_t& operator=(long x) { assign_check_range<long>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		CSize_t& operator=(int x) { assign_check_range<int>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		CSize_t& operator=(short x) { assign_check_range<short>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		CSize_t& operator=(char x) { assign_check_range<char>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		CSize_t& operator=(size_t x) { assign_check_range<size_t>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		CSize_t& operator=(CInt x) { assign_check_range<MSE_CINT_BASE_INTEGER_TYPE>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		/* We would have liked to have assignment operators for the unsigned primitive integer types, but one of them could
+		potentially clash with the size_t assignment operator. */
+		//CSize_t& operator=(unsigned long long x) { assign_check_range<unsigned long long>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		//CSize_t& operator=(unsigned long x) { assign_check_range<unsigned long>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		//CSize_t& operator=(unsigned int x) { assign_check_range<unsigned int>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		//CSize_t& operator=(unsigned short x) { assign_check_range<unsigned short>(x); m_val = static_cast<_Ty>(x); return (*this); }
+		//CSize_t& operator=(unsigned char x) { assign_check_range<unsigned char>(x); m_val = static_cast<_Ty>(x); return (*this); }
+
+		// Constructors from primitive integer types
+		//explicit CSize_t(_Ty   x) { m_val = x; }
+		explicit CSize_t(long long  x) { assign_check_range<long long>(x); m_val = static_cast<_Ty>(x); }
+		explicit CSize_t(long  x) { assign_check_range< long>(x); m_val = static_cast<_Ty>(x); }
+		explicit CSize_t(int   x) { assign_check_range<int>(x); m_val = static_cast<_Ty>(x); }
+		explicit CSize_t(short x) { assign_check_range<short>(x); m_val = static_cast<_Ty>(x); }
+		explicit CSize_t(char x) { assign_check_range<char>(x); m_val = static_cast<_Ty>(x); }
+		CSize_t(size_t   x) { assign_check_range<size_t>(x); m_val = static_cast<_Ty>(x); }
+		/*explicit */CSize_t(CInt   x) { assign_check_range<MSE_CINT_BASE_INTEGER_TYPE>(x); m_val = static_cast<_Ty>(x); }
+		/* We would have liked to have constructors for the unsigned primitive integer types, but one of them could
+		potentially clash with the size_t constructor. */
+		//explicit CSize_t(unsigned long long  x) { assign_check_range<unsigned long long>(x); m_val = static_cast<_Ty>(x); }
+		//explicit CSize_t(unsigned long  x) { assign_check_range<unsigned long>(x); m_val = static_cast<_Ty>(x); }
+		//explicit CSize_t(unsigned int   x) { assign_check_range<unsigned int>(x); m_val = static_cast<_Ty>(x); }
+		//explicit CSize_t(unsigned short x) { assign_check_range<unsigned short>(x); m_val = static_cast<_Ty>(x); }
+		//explicit CSize_t(unsigned char x) { assign_check_range<unsigned char>(x); m_val = static_cast<_Ty>(x); }
+
+		// Casts to primitive integer types
+		operator CInt() const { (*this).assert_initialized(); return CInt(m_val); }
+#ifndef MSVC2010_COMPATIBLE
+		explicit operator size_t() const { (*this).assert_initialized(); return (m_val); }
+#endif /*MSVC2010_COMPATIBLE*/
+		//size_t as_a_size_t() const { (*this).assert_initialized(); return m_val; }
+
+		CSize_t operator ~() const { (*this).assert_initialized(); return (~m_val); }
+		CSize_t& operator |=(const CSize_t &x) { (*this).assert_initialized(); m_val |= x.m_val; return (*this); }
+		CSize_t& operator &=(const CSize_t &x) { (*this).assert_initialized(); m_val &= x.m_val; return (*this); }
+		CSize_t& operator ^=(const CSize_t &x) { (*this).assert_initialized(); m_val ^= x.m_val; return (*this); }
+
+		CInt operator -() const { (*this).assert_initialized(); /* Should unsigned types even support this opperator? */
+			return (-(CInt(m_val)));
+		}
+		CSize_t& operator +=(const CSize_t &x) { (*this).assert_initialized(); m_val += x.m_val; return (*this); }
+		CSize_t& operator -=(const CSize_t &x) {
+			(*this).assert_initialized();
+			//assert(0 <= std::numeric_limits<_Ty>::lowest());
+			if (x.m_val > m_val) {
+				MSE_THROW(primitives_range_error("range error - value to be assigned is out of range of the target (integer) type"));
+			}
+			m_val -= x.m_val; return (*this);
+		}
+		CSize_t& operator *=(const CSize_t &x) { (*this).assert_initialized(); m_val *= x.m_val; return (*this); }
+		CSize_t& operator /=(const CSize_t &x) { (*this).assert_initialized(); m_val /= x.m_val; return (*this); }
+		CSize_t& operator %=(const CSize_t &x) { (*this).assert_initialized(); m_val %= x.m_val; return (*this); }
+		CSize_t& operator >>=(const CSize_t &x) { (*this).assert_initialized(); m_val >>= x.m_val; return (*this); }
+		CSize_t& operator <<=(const CSize_t &x) { (*this).assert_initialized(); m_val <<= x.m_val; return (*this); }
+
+		CSize_t operator +(const CSize_t &x) const { (*this).assert_initialized(); return (m_val + x.m_val); }
+		CInt operator +(const CInt &x) const { (*this).assert_initialized(); return (CInt(m_val) + x); }
+		CInt operator +(long long x) const { (*this).assert_initialized(); return ((*this) + CInt(x)); }
+		CInt operator +(long x) const { (*this).assert_initialized(); return ((*this) + CInt(x)); }
+		CInt operator +(int x) const { (*this).assert_initialized(); return ((*this) + CInt(x)); }
+		CInt operator +(short x) const { (*this).assert_initialized(); return ((*this) + CInt(x)); }
+		CInt operator +(char x) const { (*this).assert_initialized(); return ((*this) + CInt(x)); }
+		CSize_t operator +(size_t x) const { (*this).assert_initialized(); return ((*this) + CSize_t(x)); }
+
+		CInt operator -(const CSize_t &x) const { (*this).assert_initialized(); return (CInt(m_val) - CInt(x.m_val)); }
+		CInt operator -(const CInt &x) const { (*this).assert_initialized(); return (CInt(m_val) - x); }
+		CInt operator -(long long x) const { (*this).assert_initialized(); return ((*this) - CInt(x)); }
+		CInt operator -(long x) const { (*this).assert_initialized(); return ((*this) - CInt(x)); }
+		CInt operator -(int x) const { (*this).assert_initialized(); return ((*this) - CInt(x)); }
+		CInt operator -(short x) const { (*this).assert_initialized(); return ((*this) - CInt(x)); }
+		CInt operator -(char x) const { (*this).assert_initialized(); return ((*this) - CInt(x)); }
+		CInt operator -(size_t x) const { (*this).assert_initialized(); return ((*this) - CSize_t(x)); }
+
+		CSize_t operator *(const CSize_t &x) const { (*this).assert_initialized(); return (m_val * x.m_val); }
+		CInt operator *(const CInt &x) const { (*this).assert_initialized(); return (CInt(m_val) * x); }
+		CInt operator *(long long x) const { (*this).assert_initialized(); return ((*this) * CInt(x)); }
+		CInt operator *(long x) const { (*this).assert_initialized(); return ((*this) * CInt(x)); }
+		CInt operator *(int x) const { (*this).assert_initialized(); return ((*this) * CInt(x)); }
+		CInt operator *(short x) const { (*this).assert_initialized(); return ((*this) * CInt(x)); }
+		CInt operator *(char x) const { (*this).assert_initialized(); return ((*this) * CInt(x)); }
+		CSize_t operator *(size_t x) const { (*this).assert_initialized(); return ((*this) * CSize_t(x)); }
+
+		CSize_t operator /(const CSize_t &x) const { (*this).assert_initialized(); return (m_val / x.m_val); }
+		CInt operator /(const CInt &x) const { (*this).assert_initialized(); return (CInt(m_val) / x); }
+		CInt operator /(long long x) const { (*this).assert_initialized(); return ((*this) / CInt(x)); }
+		CInt operator /(long x) const { (*this).assert_initialized(); return ((*this) / CInt(x)); }
+		CInt operator /(int x) const { (*this).assert_initialized(); return ((*this) / CInt(x)); }
+		CInt operator /(short x) const { (*this).assert_initialized(); return ((*this) / CInt(x)); }
+		CInt operator /(char x) const { (*this).assert_initialized(); return ((*this) / CInt(x)); }
+		CSize_t operator /(size_t x) const { (*this).assert_initialized(); return ((*this) / CSize_t(x)); }
+
+		bool operator <(const CSize_t &x) const { (*this).assert_initialized(); return (m_val < x.m_val); }
+		bool operator <(const CInt &x) const { (*this).assert_initialized(); return (CInt(m_val) < x); }
+		bool operator <(long long x) const { (*this).assert_initialized(); return ((*this) < CInt(x)); }
+		bool operator <(long x) const { (*this).assert_initialized(); return ((*this) < CInt(x)); }
+		bool operator <(int x) const { (*this).assert_initialized(); return ((*this) < CInt(x)); }
+		bool operator <(short x) const { (*this).assert_initialized(); return ((*this) < CInt(x)); }
+		bool operator <(char x) const { (*this).assert_initialized(); return ((*this) < CInt(x)); }
+		bool operator <(size_t x) const { (*this).assert_initialized(); return ((*this) < CSize_t(x)); }
+
+		bool operator >(const CSize_t &x) const { (*this).assert_initialized(); return (m_val > x.m_val); }
+		bool operator >(const CInt &x) const { (*this).assert_initialized(); return (CInt(m_val) > x); }
+		bool operator >(long long x) const { (*this).assert_initialized(); return ((*this) > CInt(x)); }
+		bool operator >(long x) const { (*this).assert_initialized(); return ((*this) > CInt(x)); }
+		bool operator >(int x) const { (*this).assert_initialized(); return ((*this) > CInt(x)); }
+		bool operator >(short x) const { (*this).assert_initialized(); return ((*this) > CInt(x)); }
+		bool operator >(char x) const { (*this).assert_initialized(); return ((*this) > CInt(x)); }
+		bool operator >(size_t x) const { (*this).assert_initialized(); return ((*this) > CSize_t(x)); }
+
+		bool operator <=(const CSize_t &x) const { (*this).assert_initialized(); return (m_val <= x.m_val); }
+		bool operator <=(const CInt &x) const { (*this).assert_initialized(); return (CInt(m_val) <= x); }
+		bool operator <=(long long x) const { (*this).assert_initialized(); return ((*this) <= CInt(x)); }
+		bool operator <=(long x) const { (*this).assert_initialized(); return ((*this) <= CInt(x)); }
+		bool operator <=(int x) const { (*this).assert_initialized(); return ((*this) <= CInt(x)); }
+		bool operator <=(short x) const { (*this).assert_initialized(); return ((*this) <= CInt(x)); }
+		bool operator <=(char x) const { (*this).assert_initialized(); return ((*this) <= CInt(x)); }
+		bool operator <=(size_t x) const { (*this).assert_initialized(); return ((*this) <= CSize_t(x)); }
+
+		bool operator >=(const CSize_t &x) const { (*this).assert_initialized(); return (m_val >= x.m_val); }
+		bool operator >=(const CInt &x) const { (*this).assert_initialized(); return (CInt(m_val) >= x); }
+		bool operator >=(long long x) const { (*this).assert_initialized(); return ((*this) >= CInt(x)); }
+		bool operator >=(long x) const { (*this).assert_initialized(); return ((*this) >= CInt(x)); }
+		bool operator >=(int x) const { (*this).assert_initialized(); return ((*this) >= CInt(x)); }
+		bool operator >=(short x) const { (*this).assert_initialized(); return ((*this) >= CInt(x)); }
+		bool operator >=(char x) const { (*this).assert_initialized(); return ((*this) >= CInt(x)); }
+		bool operator >=(size_t x) const { (*this).assert_initialized(); return ((*this) >= CSize_t(x)); }
+
+		bool operator ==(const CSize_t &x) const { (*this).assert_initialized(); return (m_val == x.m_val); }
+		bool operator ==(const CInt &x) const { (*this).assert_initialized(); return (CInt(m_val) == x); }
+		bool operator ==(long long x) const { (*this).assert_initialized(); return ((*this) == CInt(x)); }
+		bool operator ==(long x) const { (*this).assert_initialized(); return ((*this) == CInt(x)); }
+		bool operator ==(int x) const { (*this).assert_initialized(); return ((*this) == CInt(x)); }
+		bool operator ==(short x) const { (*this).assert_initialized(); return ((*this) == CInt(x)); }
+		bool operator ==(char x) const { (*this).assert_initialized(); return ((*this) == CInt(x)); }
+		bool operator ==(size_t x) const { (*this).assert_initialized(); return ((*this) == CSize_t(x)); }
+
+		bool operator !=(const CSize_t &x) const { (*this).assert_initialized(); return (m_val != x.m_val); }
+		bool operator !=(const CInt &x) const { (*this).assert_initialized(); return (CInt(m_val) != x); }
+		bool operator !=(long long x) const { (*this).assert_initialized(); return ((*this) != CInt(x)); }
+		bool operator !=(long x) const { (*this).assert_initialized(); return ((*this) != CInt(x)); }
+		bool operator !=(int x) const { (*this).assert_initialized(); return ((*this) != CInt(x)); }
+		bool operator !=(short x) const { (*this).assert_initialized(); return ((*this) != CInt(x)); }
+		bool operator !=(char x) const { (*this).assert_initialized(); return ((*this) != CInt(x)); }
+		bool operator !=(size_t x) const { (*this).assert_initialized(); return ((*this) != CSize_t(x)); }
+
+		// INCREMENT/DECREMENT OPERATORS
+		CSize_t& operator ++() { (*this).assert_initialized(); m_val++; return (*this); }
+		CSize_t operator ++(int) { (*this).assert_initialized();
+			CSize_t tmp(*this); // copy
+			operator++(); // pre-increment
+			return tmp;   // return old value
+		}
+		CSize_t& operator --() { (*this).assert_initialized();
+			if (0 <= std::numeric_limits<_Ty>::lowest()) { (*this).assert_initialized();
+				(*this) = (*this) - 1; return (*this);
+			}
+			else { (*this).assert_initialized();
+				m_val--; return (*this);
+			}
+		}
+		CSize_t operator --(int) { (*this).assert_initialized();
+			CSize_t tmp(*this); // copy
+			operator--(); // pre-decrement
+			return tmp;   // return old value
+		}
+
+		//_Ty m_val;
+
+		friend size_t as_a_size_t(CSize_t n);
+	};
+	size_t as_a_size_t(CSize_t n) { n.assert_initialized(); return n.m_val; }
+}
+
+namespace std {
+#ifndef _THROW0
+#define _THROW0()
+#endif // !_THROW0
+#ifndef _STCONS
+#define _STCONS(ty, name, val)	static constexpr ty name = (ty)(val)
+#endif // !_STCONS
+
+	template<> class numeric_limits<mse::CSize_t> {	// limits for type int
+	public:
+		typedef size_t _Ty;
+
+		static constexpr _Ty(min)() _THROW0()
+		{	// return minimum value
+			return numeric_limits<size_t>::min();
+		}
+		static constexpr _Ty(max)() _THROW0()
+		{	// return maximum value
+			return numeric_limits<size_t>::max();
+		}
+		static constexpr _Ty lowest() _THROW0()
+		{	// return most negative value
+			return numeric_limits<size_t>::lowest();
+		}
+		static constexpr _Ty epsilon() _THROW0()
+		{	// return smallest effective increment from 1.0
+			return numeric_limits<size_t>::epsilon();
+		}
+		static constexpr _Ty round_error() _THROW0()
+		{	// return largest rounding error
+			return numeric_limits<size_t>::round_error();
+		}
+		static constexpr _Ty denorm_min() _THROW0()
+		{	// return minimum denormalized value
+			return numeric_limits<size_t>::denorm_min();
+		}
+		static constexpr _Ty infinity() _THROW0()
+		{	// return positive infinity
+			return numeric_limits<size_t>::infinity();
+		}
+		static constexpr _Ty quiet_NaN() _THROW0()
+		{	// return non-signaling NaN
+			return numeric_limits<size_t>::quiet_NaN();
+		}
+		static constexpr _Ty signaling_NaN() _THROW0()
+		{	// return signaling NaN
+			return numeric_limits<size_t>::signaling_NaN();
+		}
+		_STCONS(float_denorm_style, has_denorm, numeric_limits<size_t>::has_denorm);
+		_STCONS(bool, has_denorm_loss, numeric_limits<size_t>::has_denorm_loss);
+		_STCONS(bool, has_infinity, numeric_limits<size_t>::has_infinity);
+		_STCONS(bool, has_quiet_NaN, numeric_limits<size_t>::has_quiet_NaN);
+		_STCONS(bool, has_signaling_NaN, numeric_limits<size_t>::has_signaling_NaN);
+		_STCONS(bool, is_bounded, numeric_limits<size_t>::is_bounded);
+		_STCONS(bool, is_exact, numeric_limits<size_t>::is_exact);
+		_STCONS(bool, is_iec559, numeric_limits<size_t>::is_iec559);
+		_STCONS(bool, is_integer, numeric_limits<size_t>::is_integer);
+		_STCONS(bool, is_modulo, numeric_limits<size_t>::is_modulo);
+		_STCONS(bool, is_signed, numeric_limits<size_t>::is_signed);
+		_STCONS(bool, is_specialized, numeric_limits<size_t>::is_specialized);
+		_STCONS(bool, tinyness_before, numeric_limits<size_t>::tinyness_before);
+		_STCONS(bool, traps, numeric_limits<size_t>::traps);
+		_STCONS(float_round_style, round_style, numeric_limits<size_t>::round_style);
+		_STCONS(int, digits, numeric_limits<size_t>::digits);
+		_STCONS(int, digits10, numeric_limits<size_t>::digits10);
+		_STCONS(int, max_digits10, numeric_limits<size_t>::max_digits10);
+		_STCONS(int, max_exponent, numeric_limits<size_t>::max_exponent);
+		_STCONS(int, max_exponent10, numeric_limits<size_t>::max_exponent10);
+		_STCONS(int, min_exponent, numeric_limits<size_t>::min_exponent);
+		_STCONS(int, min_exponent10, numeric_limits<size_t>::min_exponent10);
+		_STCONS(int, radix, numeric_limits<size_t>::radix);
+	};
+}
+
+namespace mse {
+
+	inline CInt operator+(size_t lhs, const CInt &rhs) { rhs.assert_initialized(); rhs.assert_initialized(); return CSize_t(lhs) + rhs; }
+	inline CSize_t operator+(size_t lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CSize_t(lhs) + rhs; }
+	inline CInt operator+(int lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) + rhs; }
+	inline CInt operator+(int lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) + as_a_size_t(rhs); }
+	inline CInt operator+(const CInt &lhs, const CSize_t &rhs) { rhs.assert_initialized(); return lhs + as_a_size_t(rhs); }
+	inline CInt operator-(size_t lhs, const CInt &rhs) { rhs.assert_initialized(); return CSize_t(lhs) - rhs; }
+	inline CInt operator-(size_t lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CSize_t(lhs) - rhs; }
+	inline CInt operator-(int lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) - rhs; }
+	inline CInt operator-(int lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) - as_a_size_t(rhs); }
+	inline CInt operator-(const CInt &lhs, const CSize_t &rhs) { rhs.assert_initialized(); return lhs - as_a_size_t(rhs); }
+	inline CInt operator*(size_t lhs, const CInt &rhs) { rhs.assert_initialized(); return CSize_t(lhs) * rhs; }
+	inline CSize_t operator*(size_t lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CSize_t(lhs) * rhs; }
+	inline CInt operator*(int lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) * rhs; }
+	inline CInt operator*(int lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) * as_a_size_t(rhs); }
+	inline CInt operator*(const CInt &lhs, const CSize_t &rhs) { rhs.assert_initialized(); return lhs * as_a_size_t(rhs); }
+	inline CInt operator/(size_t lhs, const CInt &rhs) { rhs.assert_initialized(); return CSize_t(lhs) / rhs; }
+	inline CSize_t operator/(size_t lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CSize_t(lhs) / rhs; }
+	inline CInt operator/(int lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) / rhs; }
+	inline CInt operator/(int lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) / as_a_size_t(rhs); }
+	inline CInt operator/(const CInt &lhs, const CSize_t &rhs) { rhs.assert_initialized(); return lhs / as_a_size_t(rhs); }
+
+	inline bool operator<(size_t lhs, const CInt &rhs) { rhs.assert_initialized(); return CSize_t(lhs) < rhs; }
+	inline bool operator<(size_t lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CSize_t(lhs) < rhs; }
+	inline bool operator<(int lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) < rhs; }
+	inline bool operator<(int lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) < as_a_size_t(rhs); }
+	inline bool operator<(long long lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) < rhs; }
+	inline bool operator<(long long lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) < as_a_size_t(rhs); }
+	inline bool operator<(const CInt &lhs, const CSize_t &rhs) { rhs.assert_initialized(); return lhs < as_a_size_t(rhs); }
+	inline bool operator>(size_t lhs, const CInt &rhs) { rhs.assert_initialized(); return CSize_t(lhs) > rhs; }
+	inline bool operator>(size_t lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CSize_t(lhs) > rhs; }
+	inline bool operator>(int lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) > rhs; }
+	inline bool operator>(int lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) > as_a_size_t(rhs); }
+	inline bool operator>(long long lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) > rhs; }
+	inline bool operator>(long long lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) > as_a_size_t(rhs); }
+	inline bool operator>(const CInt &lhs, const CSize_t &rhs) { rhs.assert_initialized(); return lhs > as_a_size_t(rhs); }
+	inline bool operator<=(size_t lhs, const CInt &rhs) { rhs.assert_initialized(); return CSize_t(lhs) <= rhs; }
+	inline bool operator<=(size_t lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CSize_t(lhs) <= rhs; }
+	inline bool operator<=(int lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) <= rhs; }
+	inline bool operator<=(int lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) <= as_a_size_t(rhs); }
+	inline bool operator<=(long long lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) <= rhs; }
+	inline bool operator<=(long long lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) <= as_a_size_t(rhs); }
+	inline bool operator<=(const CInt &lhs, const CSize_t &rhs) { rhs.assert_initialized(); return lhs <= as_a_size_t(rhs); }
+	inline bool operator>=(size_t lhs, const CInt &rhs) { rhs.assert_initialized(); return CSize_t(lhs) >= rhs; }
+	inline bool operator>=(size_t lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CSize_t(lhs) >= rhs; }
+	inline bool operator>=(int lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) >= rhs; }
+	inline bool operator>=(int lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) >= as_a_size_t(rhs); }
+	inline bool operator>=(long long lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) >= rhs; }
+	inline bool operator>=(long long lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) >= as_a_size_t(rhs); }
+	inline bool operator>=(const CInt &lhs, const CSize_t &rhs) { rhs.assert_initialized(); return lhs >= as_a_size_t(rhs); }
+	inline bool operator==(size_t lhs, const CInt &rhs) { rhs.assert_initialized(); return CSize_t(lhs) == rhs; }
+	inline bool operator==(size_t lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CSize_t(lhs) == rhs; }
+	inline bool operator==(int lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) == rhs; }
+	inline bool operator==(int lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) == as_a_size_t(rhs); }
+	inline bool operator==(long long lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) == rhs; }
+	inline bool operator==(long long lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) == as_a_size_t(rhs); }
+	inline bool operator==(const CInt &lhs, const CSize_t &rhs) { rhs.assert_initialized(); return lhs == as_a_size_t(rhs); }
+	inline bool operator!=(size_t lhs, const CInt &rhs) { rhs.assert_initialized(); return CSize_t(lhs) != rhs; }
+	inline bool operator!=(size_t lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CSize_t(lhs) != rhs; }
+	inline bool operator!=(int lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) != rhs; }
+	inline bool operator!=(int lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) != as_a_size_t(rhs); }
+	inline bool operator!=(long long lhs, const CInt &rhs) { rhs.assert_initialized(); return CInt(lhs) != rhs; }
+	inline bool operator!=(long long lhs, const CSize_t &rhs) { rhs.assert_initialized(); return CInt(lhs) != as_a_size_t(rhs); }
+	inline bool operator!=(const CInt &lhs, const CSize_t &rhs) { rhs.assert_initialized(); return lhs != as_a_size_t(rhs); }
+#endif /*MSE_PRIMITIVES_DISABLED*/
+
+	static void s_type_test1() {
+#ifdef MSE_SELF_TESTS
+		CInt i1(3);
+		CInt i2 = 5;
+		CInt i3;
+		i3 = 7;
+		CInt i4 = i1 + i2;
+		i4 = i1 + 17;
+		i4 = 19 + i1;
+		i4 += i2;
+		i4 -= 23;
+		i4++;
+		CBool b1 = (i1 < i2);
+		b1 = (i1 < 17);
+		b1 = (19 < i1);
+		b1 = (i1 == i2);
+		b1 = (i1 == 17);
+		b1 = (19 == i1);
+
+		CSize_t szt1(3);
+		CSize_t szt2 = 5;
+		CSize_t szt3;
+		szt3 = 7;
+		CSize_t szt4 = szt1 + szt2;
+		szt4 = szt1 + 17;
+		szt4 = 19 + szt1;
+		CInt i11 = 19 + szt1;
+		szt4 += szt2;
+		szt4 -= 23;
+		szt4++;
+#ifndef MSVC2010_COMPATIBLE
+		size_t szt5 = size_t(szt4);
+#endif /*MSVC2010_COMPATIBLE*/
+		bool b3 = (szt1 < szt2);
+		b3 = (szt1 < 17);
+		b3 = (19 < szt1);
+		CBool b2 = (19 < szt1);
+		b3 = (szt1 == szt2);
+		b3 = (szt1 == 17);
+		b3 = (19 == szt1);
+		CBool b4 = (b1 < b2);
+		b4 = (b1 == b2);
+		b4 = (b1 > b3);
+		b4 = (b3 >= b1);
+		b4 = (b3 == b1);
+		b4 = (b1 && b2);
+		b4 = (b1 || b3);
+		b4 = (b3 && b1);
+		b4 |= b1;
+		b4 &= b3;
+#endif // MSE_SELF_TESTS
+	}
+}
+
+#undef MSE_THROW
+
+#endif /*ndef MSEPRIMITIVES_H*/