diff --git a/include/rexy/cx/array.hpp b/include/rexy/cx/array.hpp
index 1972c5a..1f30c59 100644
--- a/include/rexy/cx/array.hpp
+++ b/include/rexy/cx/array.hpp
@@ -176,25 +176,25 @@ namespace rexy::cx{
 		}
 
 		constexpr iterator begin(void)noexcept{
-			return bool_iter{m_elements[0].data(), 0};
+			return bool_iter{m_elements[0], 0};
 		}
 		constexpr const_iterator begin(void)const noexcept{
-			return const_bool_iter{m_elements[0].data(), 0};
+			return const_bool_iter{m_elements[0], 0};
 		}
 		constexpr const_iterator cbegin(void)const noexcept{
-			return const_bool_iter{m_elements[0].data(), 0};
+			return const_bool_iter{m_elements[0], 0};
 		}
 		constexpr iterator end(void)noexcept{
 			auto [byte_count,bits_count] = convert_to_byte_bit_pair(max_elements);
-			return bool_iter{m_elements[byte_count].data(), bits_count};
+			return bool_iter{m_elements[byte_count], bits_count};
 		}
 		constexpr const_iterator end(void)const noexcept{
 			auto [byte_count,bits_count] = convert_to_byte_bit_pair(max_elements);
-			return const_bool_iter{m_elements[byte_count].data(), bits_count};
+			return const_bool_iter{m_elements[byte_count], bits_count};
 		}
 		constexpr const_iterator cend(void)const noexcept{
 			auto [byte_count,bits_count] = convert_to_byte_bit_pair(max_elements);
-			return const_bool_iter{m_elements[byte_count].data(), bits_count};
+			return const_bool_iter{m_elements[byte_count], bits_count};
 		}
 		constexpr bool empty(void)const noexcept{
 			if constexpr(max_elements == 0){
diff --git a/include/rexy/cx/detail/bool_specialize_base.hpp b/include/rexy/cx/detail/bool_specialize_base.hpp
index 2cdb4ef..e599fa7 100644
--- a/include/rexy/cx/detail/bool_specialize_base.hpp
+++ b/include/rexy/cx/detail/bool_specialize_base.hpp
@@ -36,6 +36,15 @@ namespace rexy::cx::detail{
 		static constexpr std::pair<size_type,size_type> convert_to_byte_bit_pair(size_type s){
 			return {s / bits_per_byte, s % bits_per_byte};
 		}
+		static constexpr std::pair<size_type,size_type> convert_to_position(size_type s){
+			size_type bits = s % bits_per_byte;
+			size_type bytes = s / bits_per_byte;
+			if(bits == 0){
+				bits = bits_per_byte-1;
+				bytes -= 1;
+			}
+			return {bytes, bits};
+		}
 	public:
 		struct boolean
 		{
@@ -66,17 +75,48 @@ namespace rexy::cx::detail{
 				return (*m_value) & static_cast<uchar>(uchar{1} << m_offset);
 			}
 		};
+	protected:
+		struct booleans
+		{
+		private:
+			using uchar = unsigned char;
+			uchar m_value = 0;
+
+		public:
+			constexpr booleans(void)noexcept = default;
+			constexpr booleans(const booleans&)noexcept = default;
+			constexpr booleans(booleans&&)noexcept = default;
+			~booleans(void)noexcept = default;
+
+			constexpr booleans& operator=(const booleans&)noexcept = default;
+			constexpr booleans& operator=(booleans&&)noexcept = default;
+
+			constexpr boolean operator[](size_t i){
+				return boolean{m_value, i};
+			}
+			constexpr boolean operator[](size_t i)const{
+				return boolean{const_cast<uchar&>(m_value), i};
+			}
+			constexpr uchar& data(void){
+				return m_value;
+			}
+			constexpr const uchar& data(void)const{
+				return m_value;
+			}
+		};
+
+	public:
 		struct const_bool_iter;
 		struct bool_iter
 		{
 		friend class const_bool_iter;
 		private:
 			using uchar = unsigned char;
-			uchar* m_value;
+			booleans* m_value;
 			size_type m_offset;
 
 		public:
-			constexpr bool_iter(uchar& val, size_type offset)noexcept:
+			constexpr bool_iter(booleans& val, size_type offset)noexcept:
 				m_value(&val),
 				m_offset(offset){}
 			constexpr bool_iter(const bool_iter&)noexcept = default;
@@ -87,7 +127,7 @@ namespace rexy::cx::detail{
 			constexpr bool_iter& operator=(bool_iter&&)noexcept = default;
 
 			constexpr boolean operator*(void)const noexcept{
-				return boolean(*m_value, m_offset);
+				return boolean(m_value->data(), m_offset);
 			}
 			constexpr bool_iter& operator++(void)noexcept{
 				if(m_offset < (bits_per_byte-1)){
@@ -157,11 +197,11 @@ namespace rexy::cx::detail{
 		friend class bool_iter;
 		private:
 			using uchar = unsigned char;
-			const uchar* m_value;
+			const booleans* m_value;
 			size_type m_offset;
 
 		public:
-			constexpr const_bool_iter(const uchar& val, size_type offset)noexcept:
+			constexpr const_bool_iter(const booleans& val, size_type offset)noexcept:
 				m_value(&val),
 				m_offset(offset){}
 			constexpr const_bool_iter(const bool_iter& b)noexcept:
@@ -175,7 +215,7 @@ namespace rexy::cx::detail{
 			constexpr const_bool_iter& operator=(const_bool_iter&&)noexcept = default;
 
 			constexpr boolean operator*(void)const noexcept{
-				return boolean(const_cast<uchar&>(*m_value), m_offset);
+				return boolean(const_cast<uchar&>(m_value->data()), m_offset);
 			}
 			constexpr const_bool_iter& operator++(void)noexcept{
 				if(m_offset < (bits_per_byte-1)){
@@ -242,36 +282,6 @@ namespace rexy::cx::detail{
 
 		};
 
-	private:
-		struct booleans
-		{
-		private:
-			using uchar = unsigned char;
-			uchar m_value = 0;
-
-		public:
-			constexpr booleans(void)noexcept = default;
-			constexpr booleans(const booleans&)noexcept = default;
-			constexpr booleans(booleans&&)noexcept = default;
-			~booleans(void)noexcept = default;
-
-			constexpr booleans& operator=(const booleans&)noexcept = default;
-			constexpr booleans& operator=(booleans&&)noexcept = default;
-
-			constexpr boolean operator[](size_t i){
-				return boolean{m_value, i};
-			}
-			constexpr boolean operator[](size_t i)const{
-				return boolean{const_cast<uchar&>(m_value), i};
-			}
-			constexpr uchar& data(void){
-				return m_value;
-			}
-			constexpr const uchar& data(void)const{
-				return m_value;
-			}
-		};
-
 	};
 }
 
diff --git a/include/rexy/cx/vector.hpp b/include/rexy/cx/vector.hpp
index 481b020..70dff95 100644
--- a/include/rexy/cx/vector.hpp
+++ b/include/rexy/cx/vector.hpp
@@ -331,25 +331,25 @@ namespace rexy::cx{
 			return m_elements[byte_count][bits_count];
 		}
 		constexpr iterator begin(void)noexcept{
-			return bool_iter{m_elements[0].data(), 0};
+			return bool_iter{m_elements[0], 0};
 		}
 		constexpr const_iterator begin(void)const noexcept{
-			return const_bool_iter{m_elements[0].data(), 0};
+			return const_bool_iter{m_elements[0], 0};
 		}
 		constexpr const_iterator cbegin(void)const noexcept{
-			return const_bool_iter{m_elements[0].data(), 0};
+			return const_bool_iter{m_elements[0], 0};
 		}
 		constexpr iterator end(void)noexcept{
 			auto [byte_count,bits_count] = convert_to_byte_bit_pair(m_size);
-			return bool_iter{m_elements[byte_count].data(), bits_count};
+			return bool_iter{m_elements[byte_count], bits_count};
 		}
 		constexpr const_iterator end(void)const noexcept{
 			auto [byte_count,bits_count] = convert_to_byte_bit_pair(m_size);
-			return const_bool_iter{m_elements[byte_count].data(), bits_count};
+			return const_bool_iter{m_elements[byte_count], bits_count};
 		}
 		constexpr const_iterator cend(void)const noexcept{
 			auto [byte_count,bits_count] = convert_to_byte_bit_pair(m_size);
-			return const_bool_iter{m_elements[byte_count].data(), bits_count};
+			return const_bool_iter{m_elements[byte_count], bits_count};
 		}
 
 		constexpr bool empty(void)const noexcept{