CODE:

pragma once
#include 
#include 
#include 
#include 
#include 
#include 
#include 
#include 

namespace Numeric
{
	//numeric_limitが constexprに対応していないので、それに対処する
	template
	struct Max;
	//最大値を計算する
	template 
	struct Max
	{
		static const unsigned long value = ULONG_MAX;
	};

	template 
	struct Max
	{
		static const unsigned long long value = ULLONG_MAX;
	};

	template
	struct Max
	{
		static const unsigned short value = USHRT_MAX;
	};


	//Typeのビット数を求める
	template
	struct Bit{
		//Bitすうを求めるコア関数
		template
		struct CalculateBit
		{
			enum
			{
				value = ( CalculateBit> 1) >::value ) + 1
			};
		};
		template 
		struct CalculateBit
		{
			enum{ value = 0 };
		};

		//ビット数
		enum{ 
			value = CalculateBit::value>::value, 
		};

		//最大の桁のビットのみがONの時の値
		static const Type leftMost = ( static_cast(1) 
	class basic_BigInteger;

	template
	const basic_BigInteger operator  lhs, typename basic_BigInteger::SizeType rhs );

	template
	const basic_BigInteger operator >> ( basic_BigInteger lhs, typename basic_BigInteger::SizeType rhs );



	template
	class basic_BigInteger:
		boost::operators>
	{
	public:
		typedef typename ContainerType::value_type ValueType;
		typedef typename ContainerType::size_type SizeType;

		enum InternalStatus
		{
			Status		= 0,								//ステータスを格納する配列番号
			ValueOffset,									//実際に値が格納される配列番号
			NumOfBits	= Bit::value,			//ValueTypeのビット数
			Plus		= 0x008,							//正の数を表す（Status上では反映されない）
			Minus		= 0x001,							//負の数を表すビット数
			Infinity	= 0x002,							//無限大を表すビット数
			Null		= 0x004,							//数が無効になっているときのビット数
			Invalid		= Infinity | Null,					//何らかの不正な値を保持している
		};
		static const ValueType GreatestBit = Bit::leftMost;


		ContainerType value_;

	public:

		/*
		constructors
		*/
		basic_BigInteger()
			:value_( SizeAtFirst, 0)
		{
			value_[0] = Null;
		}

		basic_BigInteger( const basic_BigInteger& other )
		{
			value_ = other.value_;
		}

		/*basic_BigInteger( const basic_BigInteger &&  other )
		{
		value_ = other.value_;
		}*/

		basic_BigInteger& operator = ( const basic_BigInteger & other )
		{
			value_ = other.value_;
		}

		/*basic_BigInteger& operator = ( const basic_BigInteger&& other )
		{
			value_ = other.value_;

		}*/

		explicit basic_BigInteger( long long value )
			:value_( SizeAtFirst, 0)
		{
			value_[Status] = (value value_[Status]^= Minus;
			}
			else
			{
				if(IsSameSigns( other ) )
					AbsSub( other );
				else
					AbsAdd( other );
			}
			return *this;
		}

		/*ビット演算*/
		basic_BigInteger& operator > ( NumOfBits - shift );
				*itr >= ( SizeType value )
		{
			SizeType remove	= value / NumOfBits;
			SizeType shift	= value % NumOfBits;
			if( remove )
			{
				auto vbegin = value_.begin() + ValueOffset;
				value_.erase( vbegin, vbegin + remove );
			}

			ValueType next = 0;
			for( auto itr = value_.rbegin(); itr != value_.rend() - ValueOffset; ++itr )
			{
				
				ValueType nextTemp = next;
				next = *itr >= shift;
				(*itr) += nextTemp;
			}
			return *this;
		}

		basic_BigInteger& operator &= ( const basic_BigInteger& other )
		{
			if( value_.size() > other.value_.size() )
			{
				std::fill(value_.begin() + other.value_.size(), value_.end(), 0 );
				std::transform( 
					other.value_.begin() + ValueOffset,
					other.value_.end(),
					value_.begin() + ValueOffset,
					value_.begin() + ValueOffset,
					[]( ValueType lhs, ValueType rhs )
					{
						return lhs & rhs;
					}
				);

				auto ritr = value_.rbegin();
				return *this;
			}
			std::transform( 
				value_.begin() + ValueOffset,
				value_.end(),
				other.value_.begin() + ValueOffset,
				value_.begin() + ValueOffset,
				[]( ValueType lhs, ValueType rhs )
				{
					return lhs & rhs;
				}
			);
			return *this;
		}

		basic_BigInteger& operator |= ( const basic_BigInteger& other )
		{

			if( value_.size() = ten*/ !value.IsAbsSmallerThan( ten ) )
			{
				basic_BigInteger temp(0);
				value.GetQuotientAndRemainder( ten, temp );
				ss  basic_BigInteger(0) )
			{
				if( (*this & value) != basic_BigInteger(0) )
					returnValue += "1";
				else 
					returnValue += "0";
				value >>= 1;
			}
			return returnValue;
		}
		
		//以下ロジック
	private:
		bool IsAbsSmallerThan( const basic_BigInteger& other ) const
		{
			using std::swap;
			if( *this == Infinity) return false;
			if( other == Infinity) return true;

			
			auto itr  = value_.rbegin();
			auto oitr = other.value_.rbegin();

			if( value_.size() ::max() )
					{
						++value_[i];
						return;
					}
					value_[i] = 0;
					++i;
				}
				value_.push_back(1);
				return;
			};

			for( SizeType i = ValueOffset; i ::max();
					++it;
				}
				*it -= 1;
			};
			
			auto oitr = other.value_.begin() + ValueOffset;
			auto itr =  value_.begin() + ValueOffset;
			for( ;oitr != other.value_.end() && itr != value_.end(); ++oitr, ++itr )
			{
				if( *itr >= *oitr )
				{
					*itr -= *oitr;
					continue;
				}

				//oitrはconst_iteratorなので、内部の変数をバッファ
				ValueType o = (~*oitr) + 1; //*oitrのビットを反転
				*itr += o;
				DecreaseInDigit( itr );
			}

		}

		SizeType GetGreatestBit() const
		{
			auto itr = value_.rbegin();
			SizeType size = value_.size();
			while( *itr == 0 && itr != value_.rend() ) --size, ++itr;

			SizeType i = 0;
			ValueType v = *itr;
			for( ; v > 0; ++i )
			{
				v >>= 1;
			}
			if( size  0 )
				{
					temp >>= 1;
					*this -= temp;
					quotient += ( basic_BigInteger(1) 
	const basic_BigInteger operator  lhs, typename basic_BigInteger::SizeType rhs )
	{
		return (lhs 
	const basic_BigInteger operator >> ( basic_BigInteger lhs, typename basic_BigInteger::SizeType rhs )
	{
		return (lhs >>= rhs );
	}

	template
	std::ostream&  operator & rhs )
	{
		lhs  > BigInteger;
}