@ladybugmem/icebug 0.1.0

package/vendor/include/ttmath/ttmathuint.h

@@ -0,0 +1,4190 @@
+/*
+ * This file is a part of TTMath Bignum Library
+ * and is distributed under the 3-Clause BSD Licence.
+ * Author: Tomasz Sowa <t.sowa@ttmath.org>
+ */
+
+/* 
+ * Copyright (c) 2006-2017, Tomasz Sowa
+ * All rights reserved.
+ * 
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ * 
+ *  * Redistributions of source code must retain the above copyright notice,
+ *    this list of conditions and the following disclaimer.
+ *    
+ *  * Redistributions in binary form must reproduce the above copyright
+ *    notice, this list of conditions and the following disclaimer in the
+ *    documentation and/or other materials provided with the distribution.
+ *    
+ *  * Neither the name Tomasz Sowa nor the names of contributors to this
+ *    project may be used to endorse or promote products derived
+ *    from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+ * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ * ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+ * LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+ * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+ * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+ * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+ * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
+ * THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+
+
+#ifndef headerfilettmathuint
+#define headerfilettmathuint
+
+
+/*!
+	\file ttmathuint.h
+    \brief template class UInt<uint>
+*/
+
+#include <iostream>
+#include <iomanip>
+
+
+#include "ttmathtypes.h"
+#include "ttmathmisc.h"
+
+
+
+/*!
+    \brief a namespace for the TTMath library
+*/
+namespace ttmath
+{
+
+/*! 
+	\brief UInt implements a big integer value without a sign
+
+	value_size - how many bytes specify our value
+	-  on 32bit platforms: value_size=1 -> 4 bytes -> 32 bits
+	-  on 64bit platforms: value_size=1 -> 8 bytes -> 64 bits
+	value_size = 1,2,3,4,5,6....
+*/
+template<uint value_size>
+class UInt
+{
+public:
+
+	/*!
+		buffer for the integer value
+		  table[0] - the lowest word of the value
+	*/
+	uint table[value_size];
+
+
+
+	/*!
+		some methods used for debugging purposes
+	*/
+
+
+	/*!
+		this method is only for debugging purposes or when we want to make
+		a table of a variable (constant) in ttmathbig.h
+
+		it prints the table in a nice form of several columns
+	*/
+	template<class ostream_type>
+	void PrintTable(ostream_type & output) const
+	{
+		// how many columns there'll be
+		const int columns = 8;
+
+		int c = 1;
+		for(int i=value_size-1 ; i>=0 ; --i)
+		{
+			output << "0x" << std::setfill('0');
+			
+			#ifdef TTMATH_PLATFORM32
+				output << std::setw(8);
+			#else
+				output << std::setw(16);
+			#endif
+				
+			output << std::hex << table[i];
+			
+			if( i>0 )
+			{
+				output << ", ";		
+			
+				if( ++c > columns )
+				{
+					output << std::endl;
+					c = 1;
+				}
+			}
+		}
+		
+		output << std::dec << std::endl;
+	}
+
+
+	/*!
+		this method is used when macro TTMATH_DEBUG_LOG is defined
+	*/
+	template<class char_type, class ostream_type>
+	static void PrintVectorLog(const char_type * msg, ostream_type & output, const uint * vector, uint vector_len)
+	{
+		output << msg << std::endl;
+
+		for(uint i=0 ; i<vector_len ; ++i)
+			output << " table[" << i << "]: " << vector[i] << std::endl;
+	}
+
+
+	/*!
+		this method is used when macro TTMATH_DEBUG_LOG is defined
+	*/
+	template<class char_type, class ostream_type>
+	static void PrintVectorLog(const char_type * msg, uint carry, ostream_type & output, const uint * vector, uint vector_len)
+	{
+		PrintVectorLog(msg, output, vector, vector_len);
+		output << " carry: " << carry << std::endl;
+	}
+
+
+	/*!
+		this method is used when macro TTMATH_DEBUG_LOG is defined
+	*/
+	template<class char_type, class ostream_type>
+	void PrintLog(const char_type * msg, ostream_type & output) const
+	{
+		PrintVectorLog(msg, output, table, value_size);
+	}
+
+
+	/*!
+		this method is used when macro TTMATH_DEBUG_LOG is defined
+	*/
+	template<class char_type, class ostream_type>
+	void PrintLog(const char_type * msg, uint carry, ostream_type & output) const
+	{
+		PrintVectorLog(msg, output, table, value_size);
+		output << " carry: " << carry << std::endl;
+	}
+
+
+	/*!
+		this method returns the size of the table
+	*/
+	uint Size() const
+	{
+		return value_size;
+	}
+
+
+	/*!
+		this method sets zero
+	*/
+	void SetZero()
+	{
+		// in the future here can be 'memset'
+
+		for(uint i=0 ; i<value_size ; ++i)
+			table[i] = 0;
+
+		TTMATH_LOG("UInt::SetZero")
+	}
+
+
+	/*!
+		this method sets one
+	*/
+	void SetOne()
+	{
+		SetZero();
+		table[0] = 1;
+
+		TTMATH_LOG("UInt::SetOne")
+	}
+
+
+	/*!
+		this method sets the max value which this class can hold
+		(all bits will be one)
+	*/
+	void SetMax()
+	{
+		for(uint i=0 ; i<value_size ; ++i)
+			table[i] = TTMATH_UINT_MAX_VALUE;
+
+		TTMATH_LOG("UInt::SetMax")
+	}
+
+
+	/*!
+		this method sets the min value which this class can hold
+		(for an unsigned integer value the zero is the smallest value)
+	*/
+	void SetMin()
+	{
+		SetZero();
+
+		TTMATH_LOG("UInt::SetMin")
+	}
+
+
+	/*!
+		this method swappes this for an argument
+	*/
+	void Swap(UInt<value_size> & ss2)
+	{
+		for(uint i=0 ; i<value_size ; ++i)
+		{
+			uint temp = table[i];
+			table[i] = ss2.table[i];
+			ss2.table[i] = temp;
+		}
+	}
+
+
+#ifdef TTMATH_PLATFORM32
+
+	/*!
+		this method copies the value stored in an another table
+		(warning: first values in temp_table are the highest words -- it's different
+		from our table)
+
+		we copy as many words as it is possible
+		
+		if temp_table_len is bigger than value_size we'll try to round 
+		the lowest word from table depending on the last not used bit in temp_table
+		(this rounding isn't a perfect rounding -- look at the description below)
+
+		and if temp_table_len is smaller than value_size we'll clear the rest words
+		in the table
+	*/
+	void SetFromTable(const uint * temp_table, uint temp_table_len)
+	{
+		uint temp_table_index = 0;
+		sint i; // 'i' with a sign
+
+		for(i=value_size-1 ; i>=0 && temp_table_index<temp_table_len; --i, ++temp_table_index)
+			table[i] = temp_table[ temp_table_index ];
+
+
+		// rounding mantissa
+		if( temp_table_index < temp_table_len )
+		{
+			if( (temp_table[temp_table_index] & TTMATH_UINT_HIGHEST_BIT) != 0 )
+			{
+				/*
+					very simply rounding
+					if the bit from not used last word from temp_table is set to one
+					we're rouding the lowest word in the table
+
+					in fact there should be a normal addition but
+					we don't use Add() or AddTwoInts() because these methods 
+					can set a carry and then there'll be a small problem
+					for optimization
+				*/
+				if( table[0] != TTMATH_UINT_MAX_VALUE )
+					++table[0];
+			}
+		}
+
+		// cleaning the rest of the mantissa
+		for( ; i>=0 ; --i)
+			table[i] = 0;
+
+
+		TTMATH_LOG("UInt::SetFromTable")
+	}
+
+#endif
+
+
+#ifdef TTMATH_PLATFORM64
+	/*!
+		this method copies the value stored in an another table
+		(warning: first values in temp_table are the highest words -- it's different
+		from our table)
+
+		***this method is created only on a 64bit platform***
+
+		we copy as many words as it is possible
+		
+		if temp_table_len is bigger than value_size we'll try to round 
+		the lowest word from table depending on the last not used bit in temp_table
+		(this rounding isn't a perfect rounding -- look at the description below)
+
+		and if temp_table_len is smaller than value_size we'll clear the rest words
+		in the table
+
+		warning: we're using 'temp_table' as a pointer at 32bit words
+	*/
+	void SetFromTable(const unsigned int * temp_table, uint temp_table_len)
+	{
+		uint temp_table_index = 0;
+		sint i; // 'i' with a sign
+
+		for(i=value_size-1 ; i>=0 && temp_table_index<temp_table_len; --i, ++temp_table_index)
+		{
+			table[i] = uint(temp_table[ temp_table_index ]) << 32;
+
+			++temp_table_index;
+
+			if( temp_table_index<temp_table_len )
+				table[i] |= temp_table[ temp_table_index ];
+		}
+
+
+		// rounding mantissa
+		if( temp_table_index < temp_table_len )
+		{
+			if( (temp_table[temp_table_index] & TTMATH_UINT_HIGHEST_BIT) != 0 )
+			{
+				/*
+					very simply rounding
+					if the bit from not used last word from temp_table is set to one
+					we're rouding the lowest word in the table
+
+					in fact there should be a normal addition but
+					we don't use Add() or AddTwoInts() because these methods 
+					can set a carry and then there'll be a small problem
+					for optimization
+				*/
+				if( table[0] != TTMATH_UINT_MAX_VALUE )
+					++table[0];
+			}
+		}
+
+		// cleaning the rest of the mantissa
+		for( ; i >= 0 ; --i)
+			table[i] = 0;
+
+		TTMATH_LOG("UInt::SetFromTable")
+	}
+
+#endif
+
+
+
+
+
+	/*!
+	*
+	*	basic mathematic functions
+	*
+	*/
+
+
+
+
+	/*!
+		this method adds one to the existing value
+	*/
+	uint AddOne()
+	{
+		return AddInt(1);
+	}
+
+
+	/*!
+		this method subtracts one from the existing value
+	*/
+	uint SubOne()
+	{
+		return SubInt(1);
+	}
+
+
+private:
+
+
+	/*!    
+		an auxiliary method for moving bits into the left hand side
+
+		this method moves only words
+	*/
+	void RclMoveAllWords(uint & rest_bits, uint & last_c, uint bits, uint c)
+	{
+		rest_bits      = bits % TTMATH_BITS_PER_UINT;
+		uint all_words = bits / TTMATH_BITS_PER_UINT;
+		uint mask      = ( c ) ? TTMATH_UINT_MAX_VALUE : 0;
+
+
+		if( all_words >= value_size )
+		{
+			if( all_words == value_size && rest_bits == 0 )
+				last_c = table[0] & 1;
+			// else: last_c is default set to 0
+
+			// clearing
+			for(uint i = 0 ; i<value_size ; ++i)
+				table[i] = mask;
+
+			rest_bits = 0;
+		}
+		else
+		if( all_words > 0 )  
+		{
+			// 0 < all_words < value_size
+	
+			sint first, second;
+			last_c = table[value_size - all_words] & 1; // all_words is greater than 0
+
+			// copying the first part of the value
+			for(first = value_size-1, second=first-all_words ; second>=0 ; --first, --second)
+				table[first] = table[second];
+
+			// setting the rest to 'c'
+			for( ; first>=0 ; --first )
+				table[first] = mask;
+		}
+
+		TTMATH_LOG("UInt::RclMoveAllWords")
+	}
+	
+public:
+
+	/*!
+		moving all bits into the left side 'bits' times
+		return value <- this <- C
+
+		bits is from a range of <0, man * TTMATH_BITS_PER_UINT>
+		or it can be even bigger then all bits will be set to 'c'
+
+		the value c will be set into the lowest bits
+		and the method returns state of the last moved bit
+	*/
+	uint Rcl(uint bits, uint c=0)
+	{
+	uint last_c    = 0;
+	uint rest_bits = bits;
+
+		if( bits == 0 )
+			return 0;
+
+		if( bits >= TTMATH_BITS_PER_UINT )
+			RclMoveAllWords(rest_bits, last_c, bits, c);
+
+		if( rest_bits == 0 )
+		{
+			TTMATH_LOG("UInt::Rcl")
+			return last_c;
+		}
+
+		// rest_bits is from 1 to TTMATH_BITS_PER_UINT-1 now
+		if( rest_bits == 1 )
+		{
+			last_c = Rcl2_one(c);
+		}
+		else if( rest_bits == 2 )
+		{
+			// performance tests showed that for rest_bits==2 it's better to use Rcl2_one twice instead of Rcl2(2,c)
+			Rcl2_one(c);
+			last_c = Rcl2_one(c);
+		}
+		else
+		{
+			last_c = Rcl2(rest_bits, c);
+		}
+
+		TTMATH_LOGC("UInt::Rcl", last_c)
+
+	return last_c;
+	}
+
+private:
+
+	/*!    
+		an auxiliary method for moving bits into the right hand side
+
+		this method moves only words
+	*/
+	void RcrMoveAllWords(uint & rest_bits, uint & last_c, uint bits, uint c)
+	{
+		rest_bits      = bits % TTMATH_BITS_PER_UINT;
+		uint all_words = bits / TTMATH_BITS_PER_UINT;
+		uint mask      = ( c ) ? TTMATH_UINT_MAX_VALUE : 0;
+
+
+		if( all_words >= value_size )
+		{
+			if( all_words == value_size && rest_bits == 0 )
+				last_c = (table[value_size-1] & TTMATH_UINT_HIGHEST_BIT) ? 1 : 0;
+			// else: last_c is default set to 0
+
+			// clearing
+			for(uint i = 0 ; i<value_size ; ++i)
+				table[i] = mask;
+
+			rest_bits = 0;
+		}
+		else if( all_words > 0 )
+		{
+			// 0 < all_words < value_size
+
+			uint first, second;
+			last_c = (table[all_words - 1] & TTMATH_UINT_HIGHEST_BIT) ? 1 : 0; // all_words is > 0
+
+			// copying the first part of the value
+			for(first=0, second=all_words ; second<value_size ; ++first, ++second)
+				table[first] = table[second];
+
+			// setting the rest to 'c'
+			for( ; first<value_size ; ++first )
+				table[first] = mask;
+		}
+
+		TTMATH_LOG("UInt::RcrMoveAllWords")
+	}
+
+public:
+
+	/*!
+		moving all bits into the right side 'bits' times
+		c -> this -> return value
+
+		bits is from a range of <0, man * TTMATH_BITS_PER_UINT>
+		or it can be even bigger then all bits will be set to 'c'
+
+		the value c will be set into the highest bits
+		and the method returns state of the last moved bit
+	*/
+	uint Rcr(uint bits, uint c=0)
+	{
+	uint last_c    = 0;
+	uint rest_bits = bits;
+	
+		if( bits == 0 )
+			return 0;
+
+		if( bits >= TTMATH_BITS_PER_UINT )
+			RcrMoveAllWords(rest_bits, last_c, bits, c);
+
+		if( rest_bits == 0 )
+		{
+			TTMATH_LOG("UInt::Rcr")
+			return last_c;
+		}
+
+		// rest_bits is from 1 to TTMATH_BITS_PER_UINT-1 now
+		if( rest_bits == 1 )
+		{
+			last_c = Rcr2_one(c);
+		}
+		else if( rest_bits == 2 )
+		{
+			// performance tests showed that for rest_bits==2 it's better to use Rcr2_one twice instead of Rcr2(2,c)
+			Rcr2_one(c);
+			last_c = Rcr2_one(c);
+		}
+		else
+		{
+			last_c = Rcr2(rest_bits, c);
+		}
+
+		TTMATH_LOGC("UInt::Rcr", last_c)
+
+	return last_c;
+	}
+
+
+	/*!
+		this method moves all bits into the left side
+		(it returns value how many bits have been moved)
+	*/
+	uint CompensationToLeft()
+	{
+		uint moving = 0;
+
+		// a - index a last word which is different from zero
+		sint a;
+		for(a=value_size-1 ; a>=0 && table[a]==0 ; --a);
+
+		if( a < 0 )
+			return moving; // all words in table have zero
+
+		if( a != value_size-1 )
+		{
+			moving += ( value_size-1 - a ) * TTMATH_BITS_PER_UINT;
+
+			// moving all words
+			sint i;
+			for(i=value_size-1 ; a>=0 ; --i, --a)
+				table[i] = table[a];
+
+			// setting the rest word to zero
+			for(; i>=0 ; --i)
+				table[i] = 0;
+		}
+
+		uint moving2 = FindLeadingBitInWord( table[value_size-1] );
+		// moving2 is different from -1 because the value table[value_size-1]
+		// is not zero
+
+		moving2 = TTMATH_BITS_PER_UINT - moving2 - 1;
+		Rcl(moving2);
+
+		TTMATH_LOG("UInt::CompensationToLeft")
+
+	return moving + moving2;
+	}
+
+
+	/*!
+		this method looks for the highest set bit
+		
+		result:
+		-  	if 'this' is not zero:
+				return value - true,
+				'table_id'   - the index of a word <0..value_size-1>,
+				'index'      - the index of this set bit in the word <0..TTMATH_BITS_PER_UINT)
+
+		-  	if 'this' is zero:
+				return value - false,
+				both 'table_id' and 'index' are zero
+	*/
+	bool FindLeadingBit(uint & table_id, uint & index) const
+	{
+		for(table_id=value_size-1 ; table_id!=0 && table[table_id]==0 ; --table_id);
+
+		if( table_id==0 && table[table_id]==0 )
+		{
+			// is zero
+			index = 0;
+
+		return false;
+		}
+		
+		// table[table_id] is different from 0
+		index = FindLeadingBitInWord( table[table_id] );
+
+	return true;
+	}
+
+
+	/*!
+		this method looks for the smallest set bit
+		
+		result:
+		-  	if 'this' is not zero:
+				return value - true,
+				'table_id'   - the index of a word <0..value_size-1>,
+				'index'      - the index of this set bit in the word <0..TTMATH_BITS_PER_UINT)
+
+		-  	if 'this' is zero:
+				return value - false,
+				both 'table_id' and 'index' are zero
+	*/
+	bool FindLowestBit(uint & table_id, uint & index) const
+	{
+		for(table_id=0 ; table_id<value_size && table[table_id]==0 ; ++table_id);
+
+		if( table_id >= value_size )
+		{
+			// is zero
+			index    = 0;
+			table_id = 0;
+
+		return false;
+		}
+		
+		// table[table_id] is different from 0
+		index = FindLowestBitInWord( table[table_id] );
+
+	return true;
+	}
+
+
+	/*!
+		getting the 'bit_index' bit
+
+		bit_index bigger or equal zero
+	*/
+	uint GetBit(uint bit_index) const
+	{
+		TTMATH_ASSERT( bit_index < value_size * TTMATH_BITS_PER_UINT )
+
+		uint index = bit_index / TTMATH_BITS_PER_UINT;
+		uint bit   = bit_index % TTMATH_BITS_PER_UINT;
+
+		uint temp = table[index];
+		uint res  = SetBitInWord(temp, bit);
+
+	return res;
+	}
+
+
+	/*!
+		setting the 'bit_index' bit
+		and returning the last state of the bit
+
+		bit_index bigger or equal zero
+	*/
+	uint SetBit(uint bit_index)
+	{
+		TTMATH_ASSERT( bit_index < value_size * TTMATH_BITS_PER_UINT )
+
+		uint index = bit_index / TTMATH_BITS_PER_UINT;
+		uint bit   = bit_index % TTMATH_BITS_PER_UINT;
+		uint res   = SetBitInWord(table[index], bit);
+
+		TTMATH_LOG("UInt::SetBit")
+
+	return res;
+	}
+
+
+	/*!
+		this method performs a bitwise operation AND 
+	*/
+	void BitAnd(const UInt<value_size> & ss2)
+	{
+		for(uint x=0 ; x<value_size ; ++x)
+			table[x] &= ss2.table[x];
+
+		TTMATH_LOG("UInt::BitAnd")
+	}
+
+
+	/*!
+		this method performs a bitwise operation OR 
+	*/
+	void BitOr(const UInt<value_size> & ss2)
+	{
+		for(uint x=0 ; x<value_size ; ++x)
+			table[x] |= ss2.table[x];
+
+		TTMATH_LOG("UInt::BitOr")
+	}
+
+
+	/*!
+		this method performs a bitwise operation XOR 
+	*/
+	void BitXor(const UInt<value_size> & ss2)
+	{
+		for(uint x=0 ; x<value_size ; ++x)
+			table[x] ^= ss2.table[x];
+
+		TTMATH_LOG("UInt::BitXor")
+	}
+
+
+	/*!
+		this method performs a bitwise operation NOT
+	*/
+	void BitNot()
+	{
+		for(uint x=0 ; x<value_size ; ++x)
+			table[x] = ~table[x];
+
+		TTMATH_LOG("UInt::BitNot")
+	}
+
+
+	/*!
+		this method performs a bitwise operation NOT but only
+		on the range of <0, leading_bit>
+
+		for example:
+			BitNot2(8) = BitNot2( 1000(bin) ) = 111(bin) = 7
+	*/
+	void BitNot2()
+	{
+	uint table_id, index;
+
+		if( FindLeadingBit(table_id, index) )
+		{
+			for(uint x=0 ; x<table_id ; ++x)
+				table[x] = ~table[x];
+
+			uint mask  = TTMATH_UINT_MAX_VALUE;
+			uint shift = TTMATH_BITS_PER_UINT - index - 1;
+
+			if(shift)
+				mask >>= shift;
+
+			table[table_id] ^= mask;
+		}
+		else
+			table[0] = 1;
+
+
+		TTMATH_LOG("UInt::BitNot2")
+	}
+
+
+
+	/*!
+	 *
+	 * Multiplication
+	 *
+	 *
+	*/
+
+public:
+
+	/*!
+		multiplication: this = this * ss2
+
+		it can return a carry
+	*/
+	uint MulInt(uint ss2)
+	{
+	uint r1, r2, x1;
+	uint c = 0;
+
+		UInt<value_size> u(*this);
+		SetZero();
+
+		if( ss2 == 0 )
+		{
+			TTMATH_LOGC("UInt::MulInt(uint)", 0)
+			return 0;
+		}
+
+		for(x1=0 ; x1<value_size-1 ; ++x1)
+		{
+			MulTwoWords(u.table[x1], ss2, &r2, &r1);
+			c += AddTwoInts(r2,r1,x1);
+		}
+
+		// x1 = value_size-1  (last word)
+		MulTwoWords(u.table[x1], ss2, &r2, &r1);
+		c += (r2!=0) ? 1 : 0;
+		c += AddInt(r1, x1);
+
+		TTMATH_LOGC("UInt::MulInt(uint)", c)
+
+	return (c==0)? 0 : 1;
+	}
+
+
+	/*!
+		multiplication: result = this * ss2
+
+		we're using this method only when result_size is greater than value_size
+		if so there will not be a carry
+	*/
+	template<uint result_size>
+	void MulInt(uint ss2, UInt<result_size> & result) const
+	{
+	TTMATH_ASSERT( result_size > value_size )
+
+	uint r2,r1;
+	uint x1size=value_size;
+	uint x1start=0;
+
+		result.SetZero();
+
+		if( ss2 == 0 )
+		{
+			TTMATH_VECTOR_LOG("UInt::MulInt(uint, UInt<>)", result.table, result_size)
+			return;
+		}
+
+		if( value_size > 2 )
+		{	
+			// if the value_size is smaller than or equal to 2
+			// there is no sense to set x1size and x1start to another values
+
+			for(x1size=value_size ; x1size>0 && table[x1size-1]==0 ; --x1size);
+
+			if( x1size == 0 )
+			{
+				TTMATH_VECTOR_LOG("UInt::MulInt(uint, UInt<>)", result.table, result_size)
+				return;
+			}
+
+			for(x1start=0 ; x1start<x1size && table[x1start]==0 ; ++x1start);
+		}
+
+		for(uint x1=x1start ; x1<x1size ; ++x1)
+		{
+			MulTwoWords(table[x1], ss2, &r2, &r1 );
+			result.AddTwoInts(r2,r1,x1);
+		}
+
+		TTMATH_VECTOR_LOG("UInt::MulInt(uint, UInt<>)", result.table, result_size)
+
+	return;
+	}
+
+
+
+	/*!
+		the multiplication 'this' = 'this' * ss2
+
+		algorithm: 100 - means automatically choose the fastest algorithm
+	*/
+	uint Mul(const UInt<value_size> & ss2, uint algorithm = 100)
+	{
+		switch( algorithm )
+		{
+		case 1:
+			return Mul1(ss2);
+
+		case 2:
+			return Mul2(ss2);
+
+		case 3:
+			return Mul3(ss2);
+
+		case 100:
+		default:
+			return MulFastest(ss2);
+		}
+	}
+
+
+	/*!
+		the multiplication 'result' = 'this' * ss2
+
+		since the 'result' is twice bigger than 'this' and 'ss2' 
+		this method never returns a carry
+
+		algorithm: 100 - means automatically choose the fastest algorithm
+	*/
+	void MulBig(const UInt<value_size> & ss2,
+				UInt<value_size*2> & result, 
+				uint algorithm = 100)
+	{
+		switch( algorithm )
+		{
+		case 1:
+			Mul1Big(ss2, result);
+			break;
+
+		case 2:
+			Mul2Big(ss2, result);
+			break;
+
+		case 3:
+			Mul3Big(ss2, result);
+			break;
+
+		case 100:
+		default:
+			MulFastestBig(ss2, result);
+		}
+	}
+
+
+
+	/*!
+		the first version of the multiplication algorithm
+	*/
+
+private:
+
+	/*!
+		multiplication: this = this * ss2
+
+		it returns carry if it has been
+	*/
+	uint Mul1Ref(const UInt<value_size> & ss2)
+	{
+	TTMATH_REFERENCE_ASSERT( ss2 )
+
+	UInt<value_size> ss1( *this );
+	SetZero();	
+
+		for(uint i=0; i < value_size*TTMATH_BITS_PER_UINT ; ++i)
+		{
+			if( Add(*this) )
+			{
+				TTMATH_LOGC("UInt::Mul1", 1)
+				return 1;
+			}
+
+			if( ss1.Rcl(1) )
+				if( Add(ss2) )
+				{
+					TTMATH_LOGC("UInt::Mul1", 1)
+					return 1;
+				}
+		}
+
+		TTMATH_LOGC("UInt::Mul1", 0)
+
+	return 0;
+	}
+
+
+public:
+
+	/*!
+		multiplication: this = this * ss2
+		can return carry
+	*/
+	uint Mul1(const UInt<value_size> & ss2)
+	{
+		if( this == &ss2 )
+		{
+			UInt<value_size> copy_ss2(ss2);
+			return Mul1Ref(copy_ss2);
+		}
+		else
+		{
+			return Mul1Ref(ss2);
+		}
+	}
+
+	
+	/*!
+		multiplication: result = this * ss2
+
+		result is twice bigger than 'this' and 'ss2'
+		this method never returns carry			
+	*/
+	void Mul1Big(const UInt<value_size> & ss2_, UInt<value_size*2> & result)
+	{
+	UInt<value_size*2> ss2;
+	uint i;
+
+		// copying *this into result and ss2_ into ss2
+		for(i=0 ; i<value_size ; ++i)
+		{
+			result.table[i] = table[i];
+			ss2.table[i]    = ss2_.table[i];
+		}
+
+		// cleaning the highest bytes in result and ss2
+		for( ; i < value_size*2 ; ++i)
+		{
+			result.table[i] = 0;
+			ss2.table[i]    = 0;
+		}
+
+		// multiply
+		// (there will not be a carry)
+		result.Mul1( ss2 );
+
+		TTMATH_LOG("UInt::Mul1Big")
+	}
+
+
+
+	/*!
+		the second version of the multiplication algorithm
+
+		this algorithm is similar to the 'schoolbook method' which is done by hand
+	*/
+
+	/*!
+		multiplication: this = this * ss2
+
+		it returns carry if it has been
+	*/
+	uint Mul2(const UInt<value_size> & ss2)
+	{
+	UInt<value_size*2> result;
+	uint i, c = 0;
+
+		Mul2Big(ss2, result);
+	
+		// copying result
+		for(i=0 ; i<value_size ; ++i)
+			table[i] = result.table[i];
+
+		// testing carry
+		for( ; i<value_size*2 ; ++i)
+			if( result.table[i] != 0 )
+			{
+				c = 1;
+				break;
+			}
+
+		TTMATH_LOGC("UInt::Mul2", c)
+
+	return c;
+	}
+
+
+	/*!
+		multiplication: result = this * ss2
+
+		result is twice bigger than this and ss2
+		this method never returns carry			
+	*/
+	void Mul2Big(const UInt<value_size> & ss2, UInt<value_size*2> & result)
+	{
+		Mul2Big2<value_size>(table, ss2.table, result);
+
+		TTMATH_LOG("UInt::Mul2Big")
+	}
+
+
+private:
+
+	/*!
+		an auxiliary method for calculating the multiplication 
+
+		arguments we're taking as pointers (this is to improve the Mul3Big2()- avoiding
+		unnecessary copying objects), the result should be taken as a pointer too,
+		but at the moment there is no method AddTwoInts() which can operate on pointers
+	*/
+	template<uint ss_size>
+	void Mul2Big2(const uint * ss1, const uint * ss2, UInt<ss_size*2> & result)
+	{
+	uint x1size  = ss_size, x2size  = ss_size;
+	uint x1start = 0,       x2start = 0;
+
+		if( ss_size > 2 )
+		{	
+			// if the ss_size is smaller than or equal to 2
+			// there is no sense to set x1size (and others) to another values
+
+			for(x1size=ss_size ; x1size>0 && ss1[x1size-1]==0 ; --x1size);
+			for(x2size=ss_size ; x2size>0 && ss2[x2size-1]==0 ; --x2size);
+
+			for(x1start=0 ; x1start<x1size && ss1[x1start]==0 ; ++x1start);
+			for(x2start=0 ; x2start<x2size && ss2[x2start]==0 ; ++x2start);
+		}
+
+		Mul2Big3<ss_size>(ss1, ss2, result, x1start, x1size, x2start, x2size);
+	}
+
+
+
+	/*!
+		an auxiliary method for calculating the multiplication 
+	*/
+	template<uint ss_size>
+	void Mul2Big3(const uint * ss1, const uint * ss2, UInt<ss_size*2> & result, uint x1start, uint x1size, uint x2start, uint x2size)
+	{
+	uint r2, r1;
+
+		result.SetZero();
+
+		if( x1size==0 || x2size==0 )
+			return;
+
+		for(uint x1=x1start ; x1<x1size ; ++x1)
+		{
+			for(uint x2=x2start ; x2<x2size ; ++x2)
+			{
+				MulTwoWords(ss1[x1], ss2[x2], &r2, &r1);
+				result.AddTwoInts(r2, r1, x2+x1);
+				// here will never be a carry
+			}
+		}
+	}
+
+
+public:
+
+
+	/*!
+		multiplication: this = this * ss2
+
+		This is Karatsuba Multiplication algorithm, we're using it when value_size is greater than
+		or equal to TTMATH_USE_KARATSUBA_MULTIPLICATION_FROM_SIZE macro (defined in ttmathuint.h).
+		If value_size is smaller then we're using Mul2Big() instead.
+
+		Karatsuba multiplication:
+		Assume we have:
+
+			this = x = x1*B^m + x0
+			ss2  = y = y1*B^m + y0
+
+		where x0 and y0 are less than B^m
+		the product from multiplication we can show as:
+	    x*y = (x1*B^m + x0)(y1*B^m + y0) = z2*B^(2m) + z1*B^m + z0
+		where
+
+		    z2 = x1*y1
+			z1 = x1*y0 + x0*y1
+			z0 = x0*y0
+
+		this is standard schoolbook algorithm with O(n^2), Karatsuba observed that z1 can be given in other form:
+
+			z1 = (x1 + x0)*(y1 + y0) - z2 - z0    / z1 = (x1*y1 + x1*y0 + x0*y1 + x0*y0) - x1*y1 - x0*y0 = x1*y0 + x0*y1 /
+
+		and to calculate the multiplication we need only three multiplications (with some additions and subtractions)			
+
+		Our objects 'this' and 'ss2' we divide into two parts and by using recurrence we calculate the multiplication.
+		Karatsuba multiplication has O( n^(ln(3)/ln(2)) )
+	*/
+	uint Mul3(const UInt<value_size> & ss2)
+	{
+	UInt<value_size*2> result;
+	uint i, c = 0;
+
+		Mul3Big(ss2, result);
+	
+		// copying result
+		for(i=0 ; i<value_size ; ++i)
+			table[i] = result.table[i];
+
+		// testing carry
+		for( ; i<value_size*2 ; ++i)
+			if( result.table[i] != 0 )
+			{
+				c = 1;
+				break;
+			}
+
+		TTMATH_LOGC("UInt::Mul3", c)
+
+	return c;
+	}
+
+
+
+	/*!
+		multiplication: result = this * ss2
+
+		result is twice bigger than this and ss2,
+		this method never returns carry,
+		(Karatsuba multiplication)
+	*/
+	void Mul3Big(const UInt<value_size> & ss2, UInt<value_size*2> & result)
+	{
+		Mul3Big2<value_size>(table, ss2.table, result.table);
+
+		TTMATH_LOG("UInt::Mul3Big")
+	}
+
+
+
+private:
+
+	/*!
+		an auxiliary method for calculating the Karatsuba multiplication
+
+		result_size is equal ss_size*2
+	*/
+	template<uint ss_size>
+	void Mul3Big2(const uint * ss1, const uint * ss2, uint * result)
+	{
+	const uint * x1, * x0, * y1, * y0;
+
+
+		if( ss_size>1 && ss_size<TTMATH_USE_KARATSUBA_MULTIPLICATION_FROM_SIZE )
+		{
+			UInt<ss_size*2> res;
+			Mul2Big2<ss_size>(ss1, ss2, res);
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
+
+			for(uint i=0 ; i<ss_size*2 ; ++i)
+				result[i] = res.table[i];
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+
+		return;
+		}
+		else
+		if( ss_size == 1 )
+		{
+			return MulTwoWords(*ss1, *ss2, &result[1], &result[0]);
+		}
+
+
+		if( (ss_size & 1) == 1 )
+		{
+			// ss_size is odd
+			x0 = ss1;
+			y0 = ss2;
+			x1 = ss1 + ss_size / 2 + 1;
+			y1 = ss2 + ss_size / 2 + 1;
+
+			// the second vectors (x1 and y1) are smaller about one from the first ones (x0 and y0)
+			Mul3Big3<ss_size/2 + 1, ss_size/2, ss_size*2>(x1, x0, y1, y0, result);
+		}
+		else
+		{
+			// ss_size is even
+			x0 = ss1;
+			y0 = ss2;
+			x1 = ss1 + ss_size / 2;
+			y1 = ss2 + ss_size / 2;
+			
+			// all four vectors (x0 x1 y0 y1) are equal in size
+			Mul3Big3<ss_size/2, ss_size/2, ss_size*2>(x1, x0, y1, y0, result);
+		}
+	}
+
+
+
+#ifdef _MSC_VER
+#pragma warning (disable : 4717)
+//warning C4717: recursive on all control paths, function will cause runtime stack overflow
+//we have the stop point in Mul3Big2() method
+#endif
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic push
+#pragma GCC diagnostic ignored "-Wunused-but-set-variable"
+#endif
+
+
+	/*!
+		an auxiliary method for calculating the Karatsuba multiplication
+
+			x = x1*B^m + x0
+			y = y1*B^m + y0
+
+			first_size  - is the size of vectors: x0 and y0
+			second_size - is the size of vectors: x1 and y1 (can be either equal first_size or smaller about one from first_size)
+
+			x*y = (x1*B^m + x0)(y1*B^m + y0) = z2*B^(2m) + z1*B^m + z0
+		      where
+			   z0 = x0*y0 
+			   z2 = x1*y1
+			   z1 = (x1 + x0)*(y1 + y0) - z2 - z0
+	*/
+	template<uint first_size, uint second_size, uint result_size>
+	uint Mul3Big3(const uint * x1, const uint * x0, const uint * y1, const uint * y0, uint * result)
+	{
+	uint i, c, xc, yc;
+
+		UInt<first_size>   temp, temp2;
+		UInt<first_size*3> z1;
+
+		// z0 and z2 we store directly in the result (we don't use any temporary variables)
+		Mul3Big2<first_size>(x0, y0, result);                  // z0
+		Mul3Big2<second_size>(x1, y1, result+first_size*2);    // z2
+
+		// now we calculate z1
+		// temp  = (x0 + x1)
+		// temp2 = (y0 + y1)
+		// we're using temp and temp2 with UInt<first_size>, although there can be a carry but 
+		// we simple remember it in xc and yc (xc and yc can be either 0 or 1),
+		// and (x0 + x1)*(y0 + y1) we calculate in this way (schoolbook algorithm):
+		// 
+		//                 xc     |     temp
+		//                 yc     |     temp2
+		//               --------------------
+		//               (temp    *   temp2)
+		//               xc*temp2 |
+		//               yc*temp  |
+		//       xc*yc |                     
+		//       ----------     z1     --------
+		//
+		// and the result is never larger in size than 3*first_size
+
+		xc = AddVector(x0, x1, first_size, second_size, temp.table);
+		yc = AddVector(y0, y1, first_size, second_size, temp2.table);
+
+		Mul3Big2<first_size>(temp.table, temp2.table, z1.table);
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
+
+		// clearing the rest of z1
+		for(i=first_size*2 ; i<first_size*3 ; ++i)
+			z1.table[i] = 0;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+		
+		if( xc )
+		{
+			c = AddVector(z1.table+first_size, temp2.table, first_size*3-first_size, first_size, z1.table+first_size);
+			TTMATH_ASSERT( c==0 )
+		}
+
+		if( yc )
+		{
+			c = AddVector(z1.table+first_size, temp.table, first_size*3-first_size, first_size, z1.table+first_size);
+			TTMATH_ASSERT( c==0 )
+		}
+
+
+		if( xc && yc )
+		{
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
+
+			for( i=first_size*2 ; i<first_size*3 ; ++i )
+				if( ++z1.table[i] != 0 )
+ 					break;  // break if there was no carry 
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+		}
+
+		// z1 = z1 - z2
+		c = SubVector(z1.table, result+first_size*2, first_size*3, second_size*2, z1.table);
+		TTMATH_ASSERT(c==0)
+
+		// z1 = z1 - z0
+		c = SubVector(z1.table, result, first_size*3, first_size*2, z1.table);
+		TTMATH_ASSERT(c==0)
+
+		// here we've calculated the z1
+		// now we're adding it to the result
+
+		if( first_size > second_size )
+		{
+			uint z1_size = result_size - first_size;
+			TTMATH_ASSERT( z1_size <= first_size*3 )
+
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
+
+			for(i=z1_size ; i<first_size*3 ; ++i)
+			{
+				TTMATH_ASSERT( z1.table[i] == 0 )
+			}
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+ 			
+			c = AddVector(result+first_size, z1.table, result_size-first_size, z1_size, result+first_size);
+			TTMATH_ASSERT(c==0)
+		}
+		else
+		{
+			c = AddVector(result+first_size, z1.table, result_size-first_size, first_size*3, result+first_size);
+			TTMATH_ASSERT(c==0)
+		}
+	return c;
+	}
+
+
+#if defined(__GNUC__) && !defined(__clang__)
+#pragma GCC diagnostic pop
+#endif
+
+#ifdef _MSC_VER
+#pragma warning (default : 4717)
+#endif
+
+
+public:
+
+
+	/*!
+		multiplication this = this * ss2
+	*/
+	uint MulFastest(const UInt<value_size> & ss2)
+	{
+	UInt<value_size*2> result;
+	uint i, c = 0;
+
+		MulFastestBig(ss2, result);
+	
+		// copying result
+		for(i=0 ; i<value_size ; ++i)
+			table[i] = result.table[i];
+
+		// testing carry
+		for( ; i<value_size*2 ; ++i)
+			if( result.table[i] != 0 )
+			{
+				c = 1;
+				break;
+			}
+
+		TTMATH_LOGC("UInt::MulFastest", c)
+
+	return c;
+	}
+
+
+	/*!
+		multiplication result = this * ss2
+
+		this method is trying to select the fastest algorithm
+		(in the future this method can be improved)
+	*/
+	void MulFastestBig(const UInt<value_size> & ss2, UInt<value_size*2> & result)
+	{
+		if( value_size < TTMATH_USE_KARATSUBA_MULTIPLICATION_FROM_SIZE )
+		{
+			Mul2Big(ss2, result);
+			return;
+		}
+
+		uint x1size  = value_size, x2size  = value_size;
+		uint x1start = 0,          x2start = 0;
+
+		for(x1size=value_size ; x1size>0 && table[x1size-1]==0 ; --x1size);
+		for(x2size=value_size ; x2size>0 && ss2.table[x2size-1]==0 ; --x2size);
+
+		if( x1size==0 || x2size==0 )
+		{
+			// either 'this' or 'ss2' is equal zero - the result is zero too
+			result.SetZero();
+			return;
+		}
+
+		for(x1start=0 ; x1start<x1size && table[x1start]==0 ; ++x1start);
+		for(x2start=0 ; x2start<x2size && ss2.table[x2start]==0 ; ++x2start);
+
+		uint distancex1 = x1size - x1start;
+		uint distancex2 = x2size - x2start;
+
+		if( distancex1 < 3 || distancex2 < 3 )
+		{
+			// either 'this' or 'ss2' have only 2 (or 1) items different from zero (side by side)
+			// (this condition in the future can be improved)
+			Mul2Big3<value_size>(table, ss2.table, result, x1start, x1size, x2start, x2size);
+			return;
+		}
+
+
+		// Karatsuba multiplication
+		Mul3Big(ss2, result);
+
+		TTMATH_LOG("UInt::MulFastestBig")
+	}
+
+
+	/*!
+	 *
+	 * Division
+	 *
+	 *
+	*/
+	
+public:
+
+
+	/*!
+		division by one unsigned word
+
+		returns 1 when divisor is zero
+	*/
+	uint DivInt(uint divisor, uint * remainder = 0)
+	{
+		if( divisor == 0 )
+		{
+			if( remainder )
+				*remainder = 0; // this is for convenience, without it the compiler can report that 'remainder' is uninitialized
+
+			TTMATH_LOG("UInt::DivInt")
+
+		return 1;
+		}
+
+		if( divisor == 1 )
+		{
+			if( remainder )
+				*remainder = 0;
+
+			TTMATH_LOG("UInt::DivInt")
+
+		return 0;
+		}
+
+		UInt<value_size> dividend(*this);
+		SetZero();
+		
+		sint i;  // i must be with a sign
+		uint r = 0;
+
+		// we're looking for the last word in ss1
+		for(i=value_size-1 ; i>0 && dividend.table[i]==0 ; --i);
+
+		for( ; i>=0 ; --i)
+			DivTwoWords(r, dividend.table[i], divisor, &table[i], &r);
+
+		if( remainder )
+			*remainder = r;
+
+		TTMATH_LOG("UInt::DivInt")
+
+	return 0;
+	}
+
+	uint DivInt(uint divisor, uint & remainder)
+	{
+		return DivInt(divisor, &remainder);
+	}
+
+
+
+	/*!
+		division this = this / ss2
+		
+		return values:
+		-  0 - ok
+		-  1 - division by zero
+		-  'this' will be the quotient
+		-  'remainder' - remainder
+	*/
+	uint Div(	const UInt<value_size> & divisor,
+				UInt<value_size> * remainder = 0,
+				uint algorithm = 3)
+	{
+		switch( algorithm )
+		{
+		case 1:
+			return Div1(divisor, remainder);
+
+		case 2:
+			return Div2(divisor, remainder);
+
+		case 3:
+		default:
+			return Div3(divisor, remainder);
+		}
+	}
+
+	uint Div(const UInt<value_size> & divisor, UInt<value_size> & remainder, uint algorithm = 3)
+	{
+		return Div(divisor, &remainder, algorithm);
+	}
+
+
+
+private:
+
+	/*!
+		return values:
+		-  0 - none has to be done
+		-  1 - division by zero
+		-  2 - division should be made
+	*/
+	uint Div_StandardTest(	const UInt<value_size> & v,
+							uint & m, uint & n,
+							UInt<value_size> * remainder = 0)
+	{
+		switch( Div_CalculatingSize(v, m, n) )
+		{
+		case 4: // 'this' is equal v
+			if( remainder )
+				remainder->SetZero();
+
+			SetOne();
+			TTMATH_LOG("UInt::Div_StandardTest")
+			return 0;
+
+		case 3: // 'this' is smaller than v
+			if( remainder )
+				*remainder = *this;
+
+			SetZero();
+			TTMATH_LOG("UInt::Div_StandardTest")
+			return 0;
+
+		case 2: // 'this' is zero
+			if( remainder )
+				remainder->SetZero();
+
+			SetZero();
+			TTMATH_LOG("UInt::Div_StandardTest")
+			return 0;
+
+		case 1: // v is zero
+			TTMATH_LOG("UInt::Div_StandardTest")
+			return 1;
+		}
+
+		TTMATH_LOG("UInt::Div_StandardTest")
+
+	return 2;
+	}
+
+
+
+	/*!
+		return values:
+		-  0 - ok
+			-  'm' - is the index (from 0) of last non-zero word in table ('this')
+			-  'n' - is the index (from 0) of last non-zero word in v.table
+		-  1 - v is zero
+		-  2 - 'this' is zero
+		-  3 - 'this' is smaller than v
+		-  4 - 'this' is equal v
+
+		if the return value is different than zero the 'm' and 'n' are undefined
+	*/
+	uint Div_CalculatingSize(const UInt<value_size> & v, uint & m, uint & n)
+	{
+		m = n = value_size-1;
+
+		for( ; n!=0 && v.table[n]==0 ; --n);
+
+		if( n==0 && v.table[n]==0 )
+			return 1;
+
+		for( ; m!=0 && table[m]==0 ; --m);
+
+		if( m==0 && table[m]==0 )
+			return 2;
+
+		if( m < n )
+			return 3;
+		else
+		if( m == n )
+		{
+			uint i;
+			for(i = n ; i!=0 && table[i]==v.table[i] ; --i);
+			
+			if( table[i] < v.table[i] )
+				return 3;
+			else
+			if (table[i] == v.table[i] )
+				return 4;
+		}
+
+	return 0;
+	}
+
+
+public:
+
+	/*!
+		the first division algorithm
+		(radix 2)
+	*/
+	uint Div1(const UInt<value_size> & divisor, UInt<value_size> * remainder = 0)
+	{
+	uint m,n, test;
+
+		test = Div_StandardTest(divisor, m, n, remainder);
+		if( test < 2 )
+			return test;
+
+		if( !remainder )
+		{
+			UInt<value_size> rem;
+	
+		return Div1_Calculate(divisor, rem);
+		}
+
+	return Div1_Calculate(divisor, *remainder);
+	}
+
+
+	/*!
+		the first division algorithm
+		(radix 2)
+	*/
+	uint Div1(const UInt<value_size> & divisor, UInt<value_size> & remainder)
+	{
+		return Div1(divisor, &remainder);
+	}
+
+
+private:
+
+	uint Div1_Calculate(const UInt<value_size> & divisor, UInt<value_size> & rest)
+	{
+		if( this == &divisor )
+		{
+			UInt<value_size> divisor_copy(divisor);
+			return Div1_CalculateRef(divisor_copy, rest);
+		}
+		else
+		{
+			return Div1_CalculateRef(divisor, rest);
+		}
+	}
+
+
+	uint Div1_CalculateRef(const UInt<value_size> & divisor, UInt<value_size> & rest)
+	{
+	TTMATH_REFERENCE_ASSERT( divisor )
+	
+	sint loop;
+	sint c;
+
+		rest.SetZero();
+		loop = value_size * TTMATH_BITS_PER_UINT;
+		c = 0;
+
+		
+	div_a:
+		c = Rcl(1, c);
+		c = rest.Add(rest,c);
+		c = rest.Sub(divisor,c);
+
+		c = !c;
+
+		if(!c)
+			goto div_d;
+
+
+	div_b:
+		--loop;
+		if(loop)
+			goto div_a;
+
+		c = Rcl(1, c);
+		TTMATH_LOG("UInt::Div1_Calculate")
+		return 0;
+
+
+	div_c:
+		c = Rcl(1, c);
+		c = rest.Add(rest,c);
+		c = rest.Add(divisor);
+
+		if(c)
+			goto div_b;
+
+
+	div_d:
+		--loop;
+		if(loop)
+			goto div_c;
+
+		c = Rcl(1, c);
+		c = rest.Add(divisor);
+
+		TTMATH_LOG("UInt::Div1_Calculate")
+
+	return 0;
+	}
+	
+
+public:
+
+	/*!
+		the second division algorithm
+
+		return values:
+		-  0 - ok
+		-  1 - division by zero
+	*/
+	uint Div2(const UInt<value_size> & divisor, UInt<value_size> * remainder = 0)
+	{
+		if( this == &divisor )
+		{
+			UInt<value_size> divisor_copy(divisor);
+			return Div2Ref(divisor_copy, remainder);
+		}
+		else
+		{
+			return Div2Ref(divisor, remainder);
+		}
+	}
+
+
+	/*!
+		the second division algorithm
+
+		return values:
+		-  0 - ok
+		-  1 - division by zero
+	*/
+	uint Div2(const UInt<value_size> & divisor, UInt<value_size> & remainder)
+	{
+		return Div2(divisor, &remainder);
+	}
+
+
+private:
+
+	/*!
+		the second division algorithm
+
+		return values:
+		-  0 - ok
+		-  1 - division by zero
+	*/
+	uint Div2Ref(const UInt<value_size> & divisor, UInt<value_size> * remainder = 0)
+	{
+		uint bits_diff;
+		uint status = Div2_Calculate(divisor, remainder, bits_diff);
+		if( status < 2 )
+			return status;
+
+		if( CmpBiggerEqual(divisor) )
+		{
+			Div2(divisor, remainder);
+			SetBit(bits_diff);
+		}
+		else
+		{
+			if( remainder )
+				*remainder = *this;
+
+			SetZero();
+			SetBit(bits_diff);
+		}
+
+		TTMATH_LOG("UInt::Div2")
+
+	return 0;
+	}
+
+
+	/*!
+		return values:
+		-  0 - we've calculated the division
+		-  1 - division by zero
+		-  2 - we have to still calculate
+
+	*/
+	uint Div2_Calculate(const UInt<value_size> & divisor, UInt<value_size> * remainder,
+															uint & bits_diff)
+	{
+	uint table_id, index;
+	uint divisor_table_id, divisor_index;
+
+		uint status = Div2_FindLeadingBitsAndCheck(	divisor, remainder,
+													table_id, index,
+													divisor_table_id, divisor_index);
+
+		if( status < 2 )
+		{
+			TTMATH_LOG("UInt::Div2_Calculate")
+			return status;
+		}
+		
+		// here we know that 'this' is greater than divisor
+		// then 'index' is greater or equal 'divisor_index'
+		bits_diff = index - divisor_index;
+
+		UInt<value_size> divisor_copy(divisor);
+		divisor_copy.Rcl(bits_diff, 0);
+
+		if( CmpSmaller(divisor_copy, table_id) )
+		{
+			divisor_copy.Rcr(1);
+			--bits_diff;
+		}
+
+		Sub(divisor_copy, 0);
+
+		TTMATH_LOG("UInt::Div2_Calculate")
+
+	return 2;
+	}
+
+
+	/*!
+		return values:
+		-  0 - we've calculated the division
+		-  1 - division by zero
+		-  2 - we have to still calculate
+	*/
+	uint Div2_FindLeadingBitsAndCheck(	const UInt<value_size> & divisor,
+										UInt<value_size> * remainder,
+										uint & table_id, uint & index,
+										uint & divisor_table_id, uint & divisor_index)
+	{
+		if( !divisor.FindLeadingBit(divisor_table_id, divisor_index) )
+		{
+			// division by zero
+			TTMATH_LOG("UInt::Div2_FindLeadingBitsAndCheck")
+			return 1;
+		}
+
+		if(	!FindLeadingBit(table_id, index) )
+		{
+			// zero is divided by something
+			
+			SetZero();
+
+			if( remainder )
+				remainder->SetZero();
+
+			TTMATH_LOG("UInt::Div2_FindLeadingBitsAndCheck")
+
+		return 0;
+		}
+	
+		divisor_index += divisor_table_id * TTMATH_BITS_PER_UINT;
+		index         += table_id         * TTMATH_BITS_PER_UINT;
+
+		if( divisor_table_id == 0 )
+		{
+			// dividor has only one 32-bit word
+
+			uint r;
+			DivInt(divisor.table[0], &r);
+
+			if( remainder )
+			{
+				remainder->SetZero();
+				remainder->table[0] = r;
+			}
+
+			TTMATH_LOG("UInt::Div2_FindLeadingBitsAndCheck")
+
+		return 0;
+		}
+	
+
+		if( Div2_DivisorGreaterOrEqual(	divisor, remainder,
+										table_id, index,
+										divisor_index) )
+		{
+			TTMATH_LOG("UInt::Div2_FindLeadingBitsAndCheck")
+			return 0;
+		}
+
+
+		TTMATH_LOG("UInt::Div2_FindLeadingBitsAndCheck")
+
+	return 2;
+	}
+
+
+	/*!
+		return values:
+		-  true if divisor is equal or greater than 'this'
+	*/
+	bool Div2_DivisorGreaterOrEqual(	const UInt<value_size> & divisor,
+										UInt<value_size> * remainder, 
+										uint table_id, uint index,
+										uint divisor_index  )
+	{
+		if( divisor_index > index )
+		{
+			// divisor is greater than this
+
+			if( remainder )
+				*remainder = *this;
+
+			SetZero();
+
+			TTMATH_LOG("UInt::Div2_DivisorGreaterOrEqual")
+
+		return true;
+		}
+
+		if( divisor_index == index )
+		{
+			// table_id == divisor_table_id as well
+
+			uint i;
+			for(i = table_id ; i!=0 && table[i]==divisor.table[i] ; --i);
+			
+			if( table[i] < divisor.table[i] )
+			{
+				// divisor is greater than 'this'
+
+				if( remainder )
+					*remainder = *this;
+
+				SetZero();
+
+				TTMATH_LOG("UInt::Div2_DivisorGreaterOrEqual")
+
+			return true;
+			}
+			else
+			if( table[i] == divisor.table[i] )
+			{
+				// divisor is equal 'this'
+
+				if( remainder )
+					remainder->SetZero();
+
+				SetOne();
+
+				TTMATH_LOG("UInt::Div2_DivisorGreaterOrEqual")
+
+			return true;
+			}
+		}
+
+		TTMATH_LOG("UInt::Div2_DivisorGreaterOrEqual")
+
+	return false;
+	}
+
+
+public:
+
+	/*!
+		the third division algorithm
+	*/
+	uint Div3(const UInt<value_size> & ss2, UInt<value_size> * remainder = 0)
+	{
+		if( this == &ss2 )
+		{
+			UInt<value_size> copy_ss2(ss2);
+			return Div3Ref(copy_ss2, remainder);
+		}
+		else
+		{
+			return Div3Ref(ss2, remainder);
+		}
+	}
+
+
+	/*!
+		the third division algorithm
+	*/
+	uint Div3(const UInt<value_size> & ss2, UInt<value_size> & remainder)
+	{
+		return Div3(ss2, &remainder);
+	}
+
+
+private:
+
+	/*!
+		the third division algorithm
+
+		this algorithm is described in the following book:
+			"The art of computer programming 2" (4.3.1 page 272)
+			Donald E. Knuth 
+		!! give the description here (from the book)
+	*/
+	uint Div3Ref(const UInt<value_size> & v, UInt<value_size> * remainder = 0)
+	{
+	uint m,n, test;
+
+		test = Div_StandardTest(v, m, n, remainder);
+		if( test < 2 )
+			return test;
+
+		if( n == 0 )
+		{
+			uint r;
+			DivInt( v.table[0], &r );
+
+			if( remainder )
+			{
+				remainder->SetZero();
+				remainder->table[0] = r;
+			}
+
+			TTMATH_LOG("UInt::Div3")
+
+		return 0;
+		}
+
+
+		// we can only use the third division algorithm when 
+		// the divisor is greater or equal 2^32 (has more than one 32-bit word)
+		++m;
+		++n;
+		m = m - n; 
+		Div3_Division(v, remainder, m, n);
+
+		TTMATH_LOG("UInt::Div3")
+
+	return 0;
+	}
+
+
+
+private:
+
+
+	void Div3_Division(UInt<value_size> v, UInt<value_size> * remainder, uint m, uint n)
+	{
+	TTMATH_ASSERT( n>=2 && n<=value_size && m<=value_size && m+n<=value_size )
+
+	UInt<value_size+1> uu, vv;
+	UInt<value_size> q;
+	uint d, u_value_size, u0, u1, u2, v1, v0, j=m;	
+	
+		u_value_size = Div3_Normalize(v, n, d);
+
+		if( j+n == value_size )
+			u2 = u_value_size;
+		else
+			u2 = table[j+n];
+
+		Div3_MakeBiggerV(v, vv);
+
+		for(uint i = j+1 ; i<value_size ; ++i)
+			q.table[i] = 0;
+
+		while( true )
+		{
+			u1 = table[j+n-1];
+			u0 = table[j+n-2];
+			v1 = v.table[n-1];
+			v0 = v.table[n-2];
+
+			uint qp = Div3_Calculate(u2,u1,u0, v1,v0);
+
+			Div3_MakeNewU(uu, j, n, u2);
+			Div3_MultiplySubtract(uu, vv, qp);
+			Div3_CopyNewU(uu, j, n);
+
+			q.table[j] = qp;
+
+			// the next loop
+			if( j-- == 0 )
+				break;
+
+			u2 = table[j+n];
+		}
+
+		if( remainder )
+			Div3_Unnormalize(remainder, n, d);
+
+	*this = q;
+
+	TTMATH_LOG("UInt::Div3_Division")
+	}
+
+
+	void Div3_MakeNewU(UInt<value_size+1> & uu, uint j, uint n, uint u_max)
+	{
+	uint i;
+
+		for(i=0 ; i<n ; ++i, ++j)
+			uu.table[i] = table[j];
+
+		// 'n' is from <1..value_size> so and 'i' is from <0..value_size>
+		// then table[i] is always correct (look at the declaration of 'uu')
+		uu.table[i] = u_max;
+
+		for( ++i ; i<value_size+1 ; ++i)
+			uu.table[i] = 0;
+
+		TTMATH_LOG("UInt::Div3_MakeNewU")
+	}
+
+
+	void Div3_CopyNewU(const UInt<value_size+1> & uu, uint j, uint n)
+	{
+	uint i;
+
+		for(i=0 ; i<n ; ++i)
+			table[i+j] = uu.table[i];
+
+		if( i+j < value_size )
+			table[i+j] = uu.table[i];
+
+		TTMATH_LOG("UInt::Div3_CopyNewU")
+	}
+
+
+	/*!
+		we're making the new 'vv' 
+		the value is actually the same but the 'table' is bigger (value_size+1)
+	*/
+	void Div3_MakeBiggerV(const UInt<value_size> & v, UInt<value_size+1> & vv)
+	{
+		for(uint i=0 ; i<value_size ; ++i)
+			vv.table[i] = v.table[i];
+
+		vv.table[value_size] = 0;
+
+		TTMATH_LOG("UInt::Div3_MakeBiggerV")
+	}
+	
+
+	/*!
+		we're moving all bits from 'v' into the left side of the n-1 word
+		(the highest bit at v.table[n-1] will be equal one,
+		the bits from 'this' we're moving the same times as 'v')
+
+		return values:
+		-  d - how many times we've moved
+		-  return - the next-left value from 'this' (that after table[value_size-1])
+	*/
+	uint Div3_Normalize(UInt<value_size> & v, uint n, uint & d)
+	{
+		// v.table[n-1] is != 0
+
+		uint bit  = (uint)FindLeadingBitInWord(v.table[n-1]);
+		uint move = (TTMATH_BITS_PER_UINT - bit - 1);
+		uint res  = table[value_size-1];
+		d         = move;
+
+		if( move > 0 )
+		{
+			v.Rcl(move, 0);
+			Rcl(move, 0);
+			res = res >> (bit + 1);
+		}
+		else
+		{
+			res = 0;
+		}
+
+		TTMATH_LOG("UInt::Div3_Normalize")
+
+	return res;
+	}
+
+
+	void Div3_Unnormalize(UInt<value_size> * remainder, uint n, uint d)
+	{
+		for(uint i=n ; i<value_size ; ++i)
+			table[i] = 0;
+
+		Rcr(d,0);
+
+		*remainder = *this;
+
+		TTMATH_LOG("UInt::Div3_Unnormalize")
+	}
+
+
+	uint Div3_Calculate(uint u2, uint u1, uint u0, uint v1, uint v0)
+	{	
+	UInt<2> u_temp;
+	uint rp;
+	bool next_test;
+
+		TTMATH_ASSERT( v1 != 0 )
+
+		u_temp.table[1] = u2;
+		u_temp.table[0] = u1;
+		u_temp.DivInt(v1, &rp);
+
+		TTMATH_ASSERT( u_temp.table[1]==0 || u_temp.table[1]==1 )
+
+		do
+		{
+			bool decrease = false;
+
+			if( u_temp.table[1] == 1 )
+				decrease = true;
+			else
+			{
+				UInt<2> temp1, temp2;
+
+				UInt<2>::MulTwoWords(u_temp.table[0], v0, temp1.table+1, temp1.table);
+				temp2.table[1] = rp;
+				temp2.table[0] = u0;
+
+				if( temp1 > temp2 )
+					decrease = true;
+			}
+
+			next_test = false;
+
+			if( decrease )
+			{
+				u_temp.SubOne();
+
+				rp += v1;
+
+				if( rp >= v1 ) // it means that there wasn't a carry (r<b from the book)
+					next_test = true;
+			}
+		}
+		while( next_test );
+
+		TTMATH_LOG("UInt::Div3_Calculate")
+
+	return u_temp.table[0];
+	}
+
+
+
+	void Div3_MultiplySubtract(	UInt<value_size+1> & uu,
+								const UInt<value_size+1> & vv, uint & qp)
+	{
+		// D4 (in the book)
+
+		UInt<value_size+1> vv_temp(vv);
+		vv_temp.MulInt(qp);
+
+		if( uu.Sub(vv_temp) )  
+		{
+			// there was a carry
+			
+			//
+			// !!! this part of code was not tested
+			//
+
+			--qp;
+			uu.Add(vv);
+
+			// can be a carry from this additions but it should be ignored 
+			// because it cancels with the borrow from uu.Sub(vv_temp)
+		}
+
+		TTMATH_LOG("UInt::Div3_MultiplySubtract")
+	}
+
+
+
+
+
+
+public:
+
+
+	/*!
+		power this = this ^ pow
+		binary algorithm (r-to-l)
+
+		return values:
+		-  0 - ok
+		-  1 - carry
+		-  2 - incorrect argument (0^0)
+	*/
+	uint Pow(UInt<value_size> pow)
+	{
+		if(pow.IsZero() && IsZero())
+			// we don't define zero^zero
+			return 2;
+
+		UInt<value_size> start(*this);
+		UInt<value_size> result;
+		result.SetOne();
+		uint c = 0;
+
+		while( !c )
+		{
+			if( pow.table[0] & 1 )
+				c += result.Mul(start);
+
+			pow.Rcr2_one(0);
+			if( pow.IsZero() )
+				break;
+
+			c += start.Mul(start);
+		}
+
+		*this = result;
+
+		TTMATH_LOGC("UInt::Pow(UInt<>)", c)
+
+	return (c==0)? 0 : 1;
+	}
+
+
+	/*!
+		square root
+		e.g. Sqrt(9) = 3
+		('digit-by-digit' algorithm)
+	*/
+	void Sqrt()
+	{
+	UInt<value_size> bit, temp;
+
+		if( IsZero() )
+			return;
+
+		UInt<value_size> value(*this);
+
+		SetZero();
+		bit.SetZero();
+		bit.table[value_size-1] = (TTMATH_UINT_HIGHEST_BIT >> 1);
+		
+		while( bit > value )
+			bit.Rcr(2);
+
+		while( !bit.IsZero() )
+		{
+			temp = *this;
+			temp.Add(bit);
+
+			if( value >= temp )
+			{
+				value.Sub(temp);
+				Rcr(1);
+				Add(bit);
+			}
+			else
+			{
+				Rcr(1);
+			}
+
+			bit.Rcr(2);
+		}
+
+		TTMATH_LOG("UInt::Sqrt")
+	}
+
+
+
+
+	/*!
+		this method sets n first bits to value zero
+
+		For example:
+		let n=2 then if there's a value 111 (bin) there'll be '100' (bin)
+	*/
+	void ClearFirstBits(uint n)
+	{
+		if( n >= value_size*TTMATH_BITS_PER_UINT )
+		{
+			SetZero();
+			TTMATH_LOG("UInt::ClearFirstBits")
+			return;
+		}
+
+		uint * p = table;
+
+		// first we're clearing the whole words
+		while( n >= TTMATH_BITS_PER_UINT )
+		{
+			*p++ = 0;
+			n   -= TTMATH_BITS_PER_UINT;
+		}
+
+		if( n == 0 )
+		{
+			TTMATH_LOG("UInt::ClearFirstBits")
+			return;
+		}
+
+		// and then we're clearing one word which has left
+		// mask -- all bits are set to one
+		uint mask = TTMATH_UINT_MAX_VALUE;
+
+		mask = mask << n;
+
+		(*p) &= mask;
+
+		TTMATH_LOG("UInt::ClearFirstBits")
+	}
+
+
+	/*!
+		this method returns true if the highest bit of the value is set
+	*/
+	bool IsTheHighestBitSet() const
+	{
+		return (table[value_size-1] & TTMATH_UINT_HIGHEST_BIT) != 0;
+	}
+
+
+	/*!
+		this method returns true if the lowest bit of the value is set
+	*/
+	bool IsTheLowestBitSet() const
+	{
+		return (*table & 1) != 0;
+	}
+
+
+	/*!
+		returning true if only the highest bit is set
+	*/
+	bool IsOnlyTheHighestBitSet() const
+	{
+#ifdef __clang__
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Wtautological-compare"
+#endif
+
+		for(uint i=0 ; i<value_size-1 ; ++i)
+			if( table[i] != 0 )
+				return false;
+
+#ifdef __clang__
+#pragma clang diagnostic pop
+#endif
+		if( table[value_size-1] != TTMATH_UINT_HIGHEST_BIT )
+			return false;
+
+	return true;
+	}
+
+
+	/*!
+		returning true if only the lowest bit is set
+	*/
+	bool IsOnlyTheLowestBitSet() const
+	{
+		if( table[0] != 1 )
+			return false;
+
+		for(uint i=1 ; i<value_size ; ++i)
+			if( table[i] != 0 )
+				return false;
+
+	return true;
+	}
+
+
+	/*!
+		this method returns true if the value is equal zero
+	*/
+	bool IsZero() const
+	{
+		for(uint i=0 ; i<value_size ; ++i)
+			if(table[i] != 0)
+				return false;
+
+	return true;
+	}
+
+
+	/*!
+		returning true if first 'bits' bits are equal zero
+	*/
+	bool AreFirstBitsZero(uint bits) const
+	{
+		TTMATH_ASSERT( bits <= value_size * TTMATH_BITS_PER_UINT )
+
+		uint index = bits / TTMATH_BITS_PER_UINT;
+		uint rest  = bits % TTMATH_BITS_PER_UINT;
+		uint i;
+
+		for(i=0 ; i<index ; ++i)
+			if(table[i] != 0 )
+				return false;
+
+		if( rest == 0 )
+			return true;
+
+		uint mask = TTMATH_UINT_MAX_VALUE >> (TTMATH_BITS_PER_UINT - rest);
+
+	return (table[i] & mask) == 0;
+	}
+
+
+
+	/*!
+	*
+	*	conversion methods
+	*
+	*/
+
+
+
+	/*!
+		this method converts an UInt<another_size> type to this class
+
+		this operation has mainly sense if the value from p is 
+		equal or smaller than that one which is returned from UInt<value_size>::SetMax()
+
+		it returns a carry if the value 'p' is too big
+	*/
+	template<uint argument_size>
+	uint FromUInt(const UInt<argument_size> & p)
+	{
+		uint min_size = (value_size < argument_size)? value_size : argument_size;
+		uint i;
+
+		for(i=0 ; i<min_size ; ++i)
+			table[i] = p.table[i];
+
+
+		if( value_size > argument_size )
+		{	
+			// 'this' is longer than 'p'
+
+			for( ; i<value_size ; ++i)
+				table[i] = 0;
+		}
+		else
+		{
+			for( ; i<argument_size ; ++i)
+				if( p.table[i] != 0 )
+				{
+					TTMATH_LOGC("UInt::FromUInt(UInt<>)", 1)
+					return 1;
+				}
+		}
+
+		TTMATH_LOGC("UInt::FromUInt(UInt<>)", 0)
+
+	return 0;
+	}
+
+
+	/*!
+		this method converts an UInt<another_size> type to this class
+
+		this operation has mainly sense if the value from p is 
+		equal or smaller than that one which is returned from UInt<value_size>::SetMax()
+
+		it returns a carry if the value 'p' is too big
+	*/
+	template<uint argument_size>
+	uint FromInt(const UInt<argument_size> & p)
+	{
+		return FromUInt(p);
+	}
+
+
+	/*!
+		this method converts the uint type to this class
+	*/
+	uint FromUInt(uint value)
+	{
+		for(uint i=1 ; i<value_size ; ++i)
+			table[i] = 0;
+
+		table[0] = value;
+
+		TTMATH_LOG("UInt::FromUInt(uint)")
+
+		// there'll never be a carry here
+	return 0;
+	}
+
+
+	/*!
+		this method converts the uint type to this class
+	*/
+	uint FromInt(uint value)
+	{
+		return FromUInt(value);
+	}
+
+
+	/*!
+		this method converts the sint type to this class
+	*/
+	uint FromInt(sint value)
+	{
+		uint c = FromUInt(uint(value));
+
+		if( c || value < 0 )
+			return 1;
+
+	return 0;
+	}
+
+
+	/*!
+		this operator converts an UInt<another_size> type to this class
+
+		it doesn't return a carry
+	*/
+	template<uint argument_size>
+	UInt<value_size> & operator=(const UInt<argument_size> & p)
+	{
+		FromUInt(p);
+
+	return *this;
+	}
+
+
+	/*!
+		the assignment operator
+	*/
+	UInt<value_size> & operator=(const UInt<value_size> & p)
+	{
+		for(uint i=0 ; i<value_size ; ++i)
+			table[i] = p.table[i];
+
+		TTMATH_LOG("UInt::operator=(UInt<>)")
+
+		return *this;
+	}
+
+
+	/*!
+		this method converts the uint type to this class
+	*/
+	UInt<value_size> & operator=(uint i)
+	{
+		FromUInt(i);
+
+	return *this;
+	}
+
+
+	/*!
+		a constructor for converting the uint to this class
+	*/
+	UInt(uint i)
+	{
+		FromUInt(i);
+	}
+
+
+	/*!
+		this method converts the sint type to this class
+	*/
+	UInt<value_size> & operator=(sint i)
+	{
+		FromInt(i);
+
+	return *this;
+	}
+
+
+	/*!
+		a constructor for converting the sint to this class
+
+		look at the description of UInt::operator=(sint)
+	*/
+	UInt(sint i)
+	{
+		FromInt(i);
+	}
+
+
+#ifdef TTMATH_PLATFORM32
+
+
+	/*!
+		this method converts unsigned 64 bit int type to this class
+		***this method is created only on a 32bit platform***
+	*/
+	uint FromUInt(ulint n)
+	{
+		table[0] = (uint)n;
+
+		if( value_size == 1 )
+		{
+			uint c = ((n >> TTMATH_BITS_PER_UINT) == 0) ? 0 : 1;
+
+			TTMATH_LOGC("UInt::FromUInt(ulint)", c)
+			return c;
+		}
+
+		table[1] = (uint)(n >> TTMATH_BITS_PER_UINT);
+
+		for(uint i=2 ; i<value_size ; ++i)
+			table[i] = 0;
+
+		TTMATH_LOG("UInt::FromUInt(ulint)")
+
+	return 0;
+	}
+
+
+	/*!
+		this method converts unsigned 64 bit int type to this class
+		***this method is created only on a 32bit platform***
+	*/
+	uint FromInt(ulint n)
+	{
+		return FromUInt(n);
+	}
+
+
+	/*!
+		this method converts signed 64 bit int type to this class
+		***this method is created only on a 32bit platform***
+	*/
+	uint FromInt(slint n)
+	{
+		uint c = FromUInt(ulint(n));
+
+		if( c || n < 0 )
+			return 1;
+
+	return 0;
+	}
+
+
+	/*!
+		this operator converts unsigned 64 bit int type to this class
+		***this operator is created only on a 32bit platform***
+	*/
+	UInt<value_size> & operator=(ulint n)
+	{
+		FromUInt(n);
+
+	return *this;
+	}
+
+
+	/*!
+		a constructor for converting unsigned 64 bit int to this class
+		***this constructor is created only on a 32bit platform***
+	*/
+	UInt(ulint n)
+	{
+		FromUInt(n);
+	}
+
+
+	/*!
+		this operator converts signed 64 bit int type to this class
+		***this operator is created only on a 32bit platform***
+	*/
+	UInt<value_size> & operator=(slint n)
+	{
+		FromInt(n);
+
+	return *this;
+	}
+
+
+	/*!
+		a constructor for converting signed 64 bit int to this class
+		***this constructor is created only on a 32bit platform***
+	*/
+	UInt(slint n)
+	{
+		FromInt(n);
+	}
+
+#endif
+
+
+
+#ifdef TTMATH_PLATFORM64
+
+
+	/*!
+		this method converts 32 bit unsigned int type to this class
+		***this operator is created only on a 64bit platform***
+	*/
+	uint FromUInt(unsigned int i)
+	{
+		return FromUInt(uint(i));
+	}
+
+	/*!
+		this method converts 32 bit unsigned int type to this class
+		***this operator is created only on a 64bit platform***
+	*/
+	uint FromInt(unsigned int i)
+	{
+		return FromUInt(uint(i));
+	}
+
+
+	/*!
+		this method converts 32 bit signed int type to this class
+		***this operator is created only on a 64bit platform***
+	*/
+	uint FromInt(signed int i)
+	{
+		return FromInt(sint(i));
+	}
+
+
+	/*!
+		this operator converts 32 bit unsigned int type to this class
+		***this operator is created only on a 64bit platform***
+	*/
+	UInt<value_size> & operator=(unsigned int i)
+	{
+		FromUInt(i);
+
+	return *this;
+	}
+
+
+	/*!
+		a constructor for converting 32 bit unsigned int to this class
+		***this constructor is created only on a 64bit platform***
+	*/
+	UInt(unsigned int i)
+	{
+		FromUInt(i);
+	}
+
+
+	/*!
+		an operator for converting 32 bit signed int to this class
+		***this constructor is created only on a 64bit platform***
+	*/
+	UInt<value_size> & operator=(signed int i)
+	{
+		FromInt(i);
+
+	return *this;
+	}
+
+
+	/*!
+		a constructor for converting 32 bit signed int to this class
+		***this constructor is created only on a 64bit platform***
+	*/
+	UInt(signed int i)
+	{
+		FromInt(i);
+	}
+
+
+#endif
+
+
+
+
+
+	/*!
+		a constructor for converting a string to this class (with the base=10)
+	*/
+	UInt(const char * s)
+	{
+		FromString(s);
+	}
+
+
+	/*!
+		a constructor for converting a string to this class (with the base=10)
+	*/
+	UInt(const std::string & s)
+	{
+		FromString( s.c_str() );
+	}
+
+
+#ifndef TTMATH_DONT_USE_WCHAR
+
+	/*!
+		a constructor for converting a string to this class (with the base=10)
+	*/
+	UInt(const wchar_t * s)
+	{
+		FromString(s);
+	}
+
+
+	/*!
+		a constructor for converting a string to this class (with the base=10)
+	*/
+	UInt(const std::wstring & s)
+	{
+		FromString( s.c_str() );
+	}
+
+#endif
+
+
+
+
+	/*!
+		a default constructor
+
+		we don't clear the table
+	*/
+	UInt()
+	{
+	// when macro TTMATH_DEBUG_LOG is defined
+	// we set special values to the table
+	// in order to be everywhere the same value of the UInt object
+	// without this it would be difficult to analyse the log file
+	#ifdef TTMATH_DEBUG_LOG
+		#ifdef TTMATH_PLATFORM32
+				for(uint i=0 ; i<value_size ; ++i)
+					table[i] = 0xc1c1c1c1;
+		#else
+				for(uint i=0 ; i<value_size ; ++i)
+					table[i] = 0xc1c1c1c1c1c1c1c1;
+		#endif
+	#endif
+	}
+
+
+	/*!
+		a copy constructor
+	*/
+	UInt(const UInt<value_size> & u)
+	{
+		for(uint i=0 ; i<value_size ; ++i)
+			table[i] = u.table[i];
+
+		TTMATH_LOG("UInt::UInt(UInt<>)")
+	}
+
+
+
+	/*!
+		a template for producting constructors for copying from another types
+	*/
+	template<uint argument_size>
+	UInt(const UInt<argument_size> & u)
+	{
+		// look that 'size' we still set as 'value_size' and not as u.value_size
+		FromUInt(u);
+	}
+
+
+
+
+	/*!
+		a destructor
+	*/
+	~UInt()
+	{
+	}
+
+
+	/*!
+		this method returns the lowest value from table
+
+		we must be sure when we using this method whether the value
+		will hold in an uint type or not (the rest value from the table must be zero)
+	*/
+	uint ToUInt() const
+	{
+		return table[0];
+	}
+
+
+	/*!
+		this method converts the value to uint type
+		can return a carry if the value is too long to store it in uint type
+	*/
+	uint ToUInt(uint & result) const
+	{
+		result = table[0];
+
+		for(uint i=1 ; i<value_size ; ++i)
+			if( table[i] != 0 )
+				return 1;
+
+	return 0;
+	}
+
+
+	/*!
+		this method converts the value to uint type
+		can return a carry if the value is too long to store it in uint type
+	*/
+	uint ToInt(uint & result) const
+	{
+		return ToUInt(result);
+	}
+
+
+	/*!
+		this method converts the value to sint type (signed integer)
+		can return a carry if the value is too long to store it in sint type
+	*/
+	uint ToInt(sint & result) const
+	{
+		result = sint(table[0]);
+
+		if( (result & TTMATH_UINT_HIGHEST_BIT) != 0 )
+			return 1;
+
+		for(uint i=1 ; i<value_size ; ++i)
+			if( table[i] != 0 )
+				return 1;
+
+	return 0;
+	}
+
+
+#ifdef TTMATH_PLATFORM32
+
+	/*!
+		this method converts the value to ulint type (64 bit unsigned integer)
+		can return a carry if the value is too long to store it in ulint type
+		*** this method is created only on a 32 bit platform ***
+	*/
+	uint ToUInt(ulint & result) const
+	{
+		if( value_size == 1 )
+		{
+			result = table[0];
+		}
+		else
+		{
+			uint low  = table[0];
+			uint high = table[1];
+
+			result = low;
+			result |= (ulint(high) << TTMATH_BITS_PER_UINT);
+
+			for(uint i=2 ; i<value_size ; ++i)
+				if( table[i] != 0 )
+					return 1;
+		}
+
+	return 0;
+	}
+
+
+	/*!
+		this method converts the value to ulint type (64 bit unsigned integer)
+		can return a carry if the value is too long to store it in ulint type
+		*** this method is created only on a 32 bit platform ***
+	*/
+	uint ToInt(ulint & result) const
+	{
+		return ToUInt(result);
+	}
+
+
+	/*!
+		this method converts the value to slint type (64 bit signed integer)
+		can return a carry if the value is too long to store it in slint type
+		*** this method is created only on a 32 bit platform ***
+	*/
+	uint ToInt(slint & result) const
+	{
+	ulint temp;
+
+		uint c = ToUInt(temp);
+		result = slint(temp);
+
+		if( c || result < 0 )
+			return 1;
+
+	return 0;
+	}
+
+#endif
+
+
+
+#ifdef TTMATH_PLATFORM64
+
+	/*!
+		this method converts the value to a 32 unsigned integer
+		can return a carry if the value is too long to store it in this type
+		*** this method is created only on a 64 bit platform ***
+	*/
+	uint ToUInt(unsigned int & result) const
+	{
+		result = (unsigned int)table[0];
+
+		if( (table[0] >> 32) != 0 )
+			return 1;
+
+		for(uint i=1 ; i<value_size ; ++i)
+			if( table[i] != 0 )
+				return 1;
+
+	return 0;
+	}
+
+
+	/*!
+		this method converts the value to a 32 unsigned integer
+		can return a carry if the value is too long to store it in this type
+		*** this method is created only on a 64 bit platform ***
+	*/
+	uint ToInt(unsigned int & result) const
+	{
+		return ToUInt(result);
+	}
+
+
+	/*!
+		this method converts the value to a 32 signed integer
+		can return a carry if the value is too long to store it in this type
+		*** this method is created only on a 64 bit platform ***
+	*/
+	uint ToInt(int & result) const
+	{
+	unsigned int temp;
+
+		uint c = ToUInt(temp);
+		result = int(temp);
+
+		if( c || result < 0 )
+			return 1;
+
+	return 0;
+	}
+
+
+#endif
+
+
+
+
+protected:
+
+	/*!
+		an auxiliary method for converting into the string
+		it returns the log (with the base 2) from x
+		where x is in <2;16>
+	*/
+	double ToStringLog2(uint x) const
+	{
+		static double log_tab[] = {
+			1.000000000000000000,
+			0.630929753571457437,
+			0.500000000000000000,
+			0.430676558073393050,
+			0.386852807234541586,
+			0.356207187108022176,
+			0.333333333333333333,
+			0.315464876785728718,
+			0.301029995663981195,
+			0.289064826317887859,
+			0.278942945651129843,
+			0.270238154427319741,
+			0.262649535037193547,
+			0.255958024809815489,
+			0.250000000000000000
+		};
+
+		if( x<2 || x>16 )
+			return 0;
+
+	return log_tab[x-2];
+	}
+
+
+public:
+
+
+	/*!	
+		an auxiliary method for converting to a string
+		it's used from Int::ToString() too (negative is set true then)
+	*/
+	template<class string_type>
+	void ToStringBase(string_type & result, uint b = 10, bool negative = false) const
+	{
+	UInt<value_size> temp(*this);
+	uint rest, table_id, index, digits;
+	double digits_d;
+	char character;
+
+		result.clear();
+
+		if( b<2 || b>16 )
+			return;
+
+		if( !FindLeadingBit(table_id, index) )
+		{
+			result = '0';
+			return;
+		}
+
+		if( negative )
+			result = '-';
+
+		digits_d  = static_cast<double>(table_id); // for not making an overflow in uint type
+		digits_d *= TTMATH_BITS_PER_UINT;
+		digits_d += index + 1;
+		digits_d *= ToStringLog2(b);
+		digits = static_cast<uint>(digits_d) + 3; // plus some epsilon
+
+		if( result.capacity() < digits )
+			result.reserve(digits);
+
+		do
+		{
+			temp.DivInt(b, &rest);
+			character = static_cast<char>(Misc::DigitToChar(rest));
+			result.insert(result.end(), character);
+		}
+		while( !temp.IsZero() );
+
+		size_t i1 = negative ? 1 : 0; // the first is a hyphen (when negative is true)
+		size_t i2 = result.size() - 1;
+
+		for( ; i1 < i2 ; ++i1, --i2 )
+		{
+			char tempc = static_cast<char>(result[i1]);
+			result[i1] = result[i2];
+			result[i2] = tempc;
+		}
+	}
+
+
+
+	/*!	
+		this method converts the value to a string with a base equal 'b'
+	*/
+	void ToString(std::string & result, uint b = 10) const
+	{
+		return ToStringBase(result, b);
+	}
+
+
+	std::string ToString(uint b = 10) const
+	{
+		std::string result;
+		ToStringBase(result, b);
+	
+	return result;
+	}
+
+
+#ifndef TTMATH_DONT_USE_WCHAR
+
+	void ToString(std::wstring & result, uint b = 10) const
+	{
+		return ToStringBase(result, b);
+	}
+
+	std::wstring ToWString(uint b = 10) const
+	{
+		std::wstring result;
+		ToStringBase(result, b);
+	
+	return result;
+	}
+
+#endif
+
+
+
+private:
+
+	/*!
+		an auxiliary method for converting from a string
+	*/
+	template<class char_type>
+	uint FromStringBase(const char_type * s, uint b = 10, const char_type ** after_source = 0, bool * value_read = 0)
+	{
+	UInt<value_size> base( b );
+	UInt<value_size> temp;
+	sint z;
+	uint c = 0;
+
+		SetZero();
+		temp.SetZero();
+		Misc::SkipWhiteCharacters(s);
+
+		if( after_source )
+			*after_source = s;
+
+		if( value_read )
+			*value_read = false;
+
+		if( b<2 || b>16 )
+			return 1;
+
+
+		for( ; (z=Misc::CharToDigit(*s, b)) != -1 ; ++s)
+		{
+			if( value_read )
+				*value_read = true;
+
+			if( c == 0 )
+			{
+				temp.table[0] = z;
+
+				c += Mul(base); // !! IMPROVE ME: there can be used MulInt here
+				c += Add(temp);
+			}
+		}		
+
+		if( after_source )
+			*after_source = s;
+
+		TTMATH_LOGC("UInt::FromString", c)
+
+	return (c==0)? 0 : 1;
+	}
+
+
+public:
+
+
+	/*!
+		this method converts a string into its value
+		it returns carry=1 if the value will be too big or an incorrect base 'b' is given
+
+		string is ended with a non-digit value, for example:
+			"12" will be translated to 12
+			as well as:
+			"12foo" will be translated to 12 too
+
+		existing first white characters will be ommited
+
+		if the value from s is too large the rest digits will be skipped
+
+		after_source (if exists) is pointing at the end of the parsed string
+
+		value_read (if exists) tells whether something has actually been read (at least one digit)
+	*/
+	uint FromString(const char * s, uint b = 10, const char ** after_source = 0, bool * value_read = 0)
+	{
+		return FromStringBase(s, b, after_source, value_read);
+	}
+
+
+	/*!
+		this method converts a string into its value
+
+		(it returns carry=1 if the value will be too big or an incorrect base 'b' is given)
+	*/
+	uint FromString(const std::string & s, uint b = 10)
+	{
+		return FromString( s.c_str(), b );
+	}
+
+
+	/*!
+		this operator converts a string into its value (with base = 10)
+	*/
+	UInt<value_size> & operator=(const char * s)
+	{
+		FromString(s);
+
+	return *this;
+	}
+
+
+	/*!
+		this operator converts a string into its value (with base = 10)
+	*/
+	UInt<value_size> & operator=(const std::string & s)
+	{
+		FromString( s.c_str() );
+
+	return *this;
+	}
+
+
+
+#ifndef TTMATH_DONT_USE_WCHAR
+
+	/*!
+		this method converts a string into its value
+	*/
+	uint FromString(const wchar_t * s, uint b = 10, const wchar_t ** after_source = 0, bool * value_read = 0)
+	{
+		return FromStringBase(s, b, after_source, value_read);
+	}
+
+
+	/*!
+		this method converts a string into its value
+
+		(it returns carry=1 if the value will be too big or an incorrect base 'b' is given)
+	*/
+	uint FromString(const std::wstring & s, uint b = 10)
+	{
+		return FromString( s.c_str(), b );
+	}
+
+
+	/*!
+		this operator converts a string into its value (with base = 10)
+	*/
+	UInt<value_size> & operator=(const wchar_t * s)
+	{
+		FromString(s);
+
+	return *this;
+	}
+
+
+	/*!
+		this operator converts a string into its value (with base = 10)
+	*/
+	UInt<value_size> & operator=(const std::wstring & s)
+	{
+		FromString( s.c_str() );
+
+	return *this;
+	}
+
+#endif
+
+
+	/*!
+	*
+	*	methods for comparing
+	*
+	*/
+
+
+	/*!
+		this method returns true if 'this' is smaller than 'l'
+
+		'index' is an index of the first word from will be the comparison performed
+		(note: we start the comparison from back - from the last word, when index is -1 /default/
+		it is automatically set into the last word)
+		I introduced it for some kind of optimization made in the second division algorithm (Div2)
+	*/
+	bool CmpSmaller(const UInt<value_size> & l, sint index = -1) const
+	{
+	sint i;
+
+		if( index==-1 || index>=sint(value_size) )
+			i = value_size - 1;
+		else
+			i = index;
+
+
+		for( ; i>=0 ; --i)
+		{
+			if( table[i] != l.table[i] )
+				return table[i] < l.table[i];
+		}
+
+	// they're equal
+	return false;
+	}
+
+
+
+	/*!
+		this method returns true if 'this' is bigger than 'l'
+
+		'index' is an index of the first word from will be the comparison performed
+		(note: we start the comparison from back - from the last word, when index is -1 /default/
+		it is automatically set into the last word)
+
+		I introduced it for some kind of optimization made in the second division algorithm (Div2)
+	*/
+	bool CmpBigger(const UInt<value_size> & l, sint index = -1) const
+	{
+	sint i;
+
+		if( index==-1 || index>=sint(value_size) )
+			i = value_size - 1;
+		else
+			i = index;
+
+
+		for( ; i>=0 ; --i)
+		{
+			if( table[i] != l.table[i] )
+				return table[i] > l.table[i];
+		}
+
+	// they're equal
+	return false;
+	}
+
+
+	/*!
+		this method returns true if 'this' is equal 'l'
+
+		'index' is an index of the first word from will be the comparison performed
+		(note: we start the comparison from back - from the last word, when index is -1 /default/
+		it is automatically set into the last word)
+	*/
+	bool CmpEqual(const UInt<value_size> & l, sint index = -1) const
+	{
+	sint i;
+
+		if( index==-1 || index>=sint(value_size) )
+			i = value_size - 1;
+		else
+			i = index;
+
+
+		for( ; i>=0 ; --i)
+			if( table[i] != l.table[i] )
+				return false;
+
+	return true;
+	}
+
+
+
+	/*!
+		this method returns true if 'this' is smaller than or equal 'l'
+
+		'index' is an index of the first word from will be the comparison performed
+		(note: we start the comparison from back - from the last word, when index is -1 /default/
+		it is automatically set into the last word)
+	*/
+	bool CmpSmallerEqual(const UInt<value_size> & l, sint index=-1) const
+	{
+	sint i;
+
+		if( index==-1 || index>=sint(value_size) )
+			i = value_size - 1;
+		else
+			i = index;
+
+
+		for( ; i>=0 ; --i)
+		{
+			if( table[i] != l.table[i] )
+				return table[i] < l.table[i];
+		}
+
+	// they're equal
+	return true;
+	}
+
+
+
+	/*!
+		this method returns true if 'this' is bigger than or equal 'l'
+
+		'index' is an index of the first word from will be the comparison performed
+		(note: we start the comparison from back - from the last word, when index is -1 /default/
+		it is automatically set into the last word)
+	*/
+	bool CmpBiggerEqual(const UInt<value_size> & l, sint index=-1) const
+	{
+	sint i;
+
+		if( index==-1 || index>=sint(value_size) )
+			i = value_size - 1;
+		else
+			i = index;
+
+
+		for( ; i>=0 ; --i)
+		{
+			if( table[i] != l.table[i] )
+				return table[i] > l.table[i];
+		}
+
+	// they're equal
+	return true;
+	}
+
+
+	/*
+		operators for comparising
+	*/
+
+	bool operator<(const UInt<value_size> & l) const
+	{
+		return CmpSmaller(l);
+	}
+
+
+	bool operator>(const UInt<value_size> & l) const
+	{
+		return CmpBigger(l);
+	}
+
+
+	bool operator==(const UInt<value_size> & l) const
+	{
+		return CmpEqual(l);
+	}
+
+
+	bool operator!=(const UInt<value_size> & l) const
+	{
+		return !operator==(l);
+	}
+
+
+	bool operator<=(const UInt<value_size> & l) const
+	{
+		return CmpSmallerEqual(l);
+	}
+
+	bool operator>=(const UInt<value_size> & l) const
+	{
+		return CmpBiggerEqual(l);
+	}
+
+
+	/*!
+	*
+	*	standard mathematical operators 
+	*
+	*/
+
+	UInt<value_size> operator-(const UInt<value_size> & p2) const
+	{
+	UInt<value_size> temp(*this);
+
+		temp.Sub(p2);
+
+	return temp;
+	}
+
+	UInt<value_size> & operator-=(const UInt<value_size> & p2)
+	{
+		Sub(p2);
+
+	return *this;
+	}
+
+	UInt<value_size> operator+(const UInt<value_size> & p2) const
+	{
+	UInt<value_size> temp(*this);
+
+		temp.Add(p2);
+
+	return temp;
+	}
+
+	UInt<value_size> & operator+=(const UInt<value_size> & p2)
+	{
+		Add(p2);
+
+	return *this;
+	}
+
+
+	UInt<value_size> operator*(const UInt<value_size> & p2) const
+	{
+	UInt<value_size> temp(*this);
+
+		temp.Mul(p2);
+
+	return temp;
+	}
+
+
+	UInt<value_size> & operator*=(const UInt<value_size> & p2)
+	{
+		Mul(p2);
+
+	return *this;
+	}
+
+
+	UInt<value_size> operator/(const UInt<value_size> & p2) const
+	{
+	UInt<value_size> temp(*this);
+
+		temp.Div(p2);
+
+	return temp;
+	}
+
+
+	UInt<value_size> & operator/=(const UInt<value_size> & p2)
+	{
+		Div(p2);
+
+	return *this;
+	}
+
+
+	UInt<value_size> operator%(const UInt<value_size> & p2) const
+	{
+	UInt<value_size> temp(*this);
+	UInt<value_size> remainder;
+	
+		temp.Div( p2, remainder );
+
+	return remainder;
+	}
+
+
+	UInt<value_size> & operator%=(const UInt<value_size> & p2)
+	{
+	UInt<value_size> remainder;
+	
+		Div( p2, remainder );
+		operator=(remainder);
+
+	return *this;
+	}
+
+
+	/*!
+		Prefix operator e.g ++variable
+	*/
+	UInt<value_size> & operator++()
+	{
+		AddOne();
+
+	return *this;
+	}
+
+
+	/*!
+		Postfix operator e.g variable++
+	*/
+	UInt<value_size> operator++(int)
+	{
+	UInt<value_size> temp( *this );
+
+		AddOne();
+
+	return temp;
+	}
+
+
+	UInt<value_size> & operator--()
+	{
+		SubOne();
+
+	return *this;
+	}
+
+
+	UInt<value_size> operator--(int)
+	{
+	UInt<value_size> temp( *this );
+
+		SubOne();
+
+	return temp;
+	}
+
+
+
+	/*!
+	*
+	*	bitwise operators
+	*
+	*/
+
+	UInt<value_size> operator~() const
+	{
+		UInt<value_size> temp( *this );
+
+		temp.BitNot();
+
+	return temp;
+	}
+
+
+	UInt<value_size> operator&(const UInt<value_size> & p2) const
+	{
+		UInt<value_size> temp( *this );
+
+		temp.BitAnd(p2);
+
+	return temp;
+	}
+
+
+	UInt<value_size> & operator&=(const UInt<value_size> & p2)
+	{
+		BitAnd(p2);
+
+	return *this;
+	}
+
+
+	UInt<value_size> operator|(const UInt<value_size> & p2) const
+	{
+		UInt<value_size> temp( *this );
+
+		temp.BitOr(p2);
+
+	return temp;
+	}
+
+
+	UInt<value_size> & operator|=(const UInt<value_size> & p2)
+	{
+		BitOr(p2);
+
+	return *this;
+	}
+
+
+	UInt<value_size> operator^(const UInt<value_size> & p2) const
+	{
+		UInt<value_size> temp( *this );
+
+		temp.BitXor(p2);
+
+	return temp;
+	}
+
+
+	UInt<value_size> & operator^=(const UInt<value_size> & p2)
+	{
+		BitXor(p2);
+
+	return *this;
+	}
+
+
+	UInt<value_size> operator>>(int move) const
+	{
+	UInt<value_size> temp( *this );
+
+		temp.Rcr(move);
+
+	return temp;
+	}
+
+
+	UInt<value_size> & operator>>=(int move)
+	{
+		Rcr(move);
+
+	return *this;
+	}
+
+
+	UInt<value_size> operator<<(int move) const
+	{
+	UInt<value_size> temp( *this );
+
+		temp.Rcl(move);
+
+	return temp;
+	}
+
+
+	UInt<value_size> & operator<<=(int move)
+	{
+		Rcl(move);
+
+	return *this;
+	}
+
+
+	/*!
+	*
+	*	input/output operators for standard streams
+	*	
+	*	(they are very simple, in the future they should be changed)
+	*
+	*/
+
+
+private:
+
+
+	/*!
+		an auxiliary method for outputing to standard streams
+	*/
+	template<class ostream_type, class string_type>
+	static ostream_type & OutputToStream(ostream_type & s, const UInt<value_size> & l)
+	{
+	string_type ss;
+
+		l.ToString(ss);
+		s << ss;
+
+	return s;
+	}
+
+
+public:
+
+
+	/*!
+		output to standard streams
+	*/
+	friend std::ostream & operator<<(std::ostream & s, const UInt<value_size> & l)
+	{
+		return OutputToStream<std::ostream, std::string>(s, l);
+	}
+
+
+#ifndef TTMATH_DONT_USE_WCHAR
+
+	/*!
+		output to standard streams
+	*/
+	friend std::wostream & operator<<(std::wostream & s, const UInt<value_size> & l)
+	{
+		return OutputToStream<std::wostream, std::wstring>(s, l);
+	}
+
+#endif
+
+
+
+private:
+
+	/*!
+		an auxiliary method for reading from standard streams
+	*/
+	template<class istream_type, class string_type, class char_type>
+	static istream_type & InputFromStream(istream_type & s, UInt<value_size> & l)
+	{
+	string_type ss;
+	
+	// char or wchar_t for operator>>
+	char_type z;
+	
+		// operator>> omits white characters if they're set for ommiting
+		s >> z;
+
+		// we're reading only digits (base=10)
+		while( s.good() && Misc::CharToDigit(z, 10)>=0 )
+		{
+			ss += z;
+			z = static_cast<char_type>(s.get());
+		}
+
+		// we're leaving the last read character
+		// (it's not belonging to the value)
+		s.unget();
+
+		l.FromString(ss);
+
+	return s;
+	}
+
+public:
+
+
+	/*!
+		input from standard streams
+	*/
+	friend std::istream & operator>>(std::istream & s, UInt<value_size> & l)
+	{
+		return InputFromStream<std::istream, std::string, char>(s, l);
+	}
+
+
+#ifndef TTMATH_DONT_USE_WCHAR
+
+	/*!
+		input from standard streams
+	*/
+	friend std::wistream & operator>>(std::wistream & s, UInt<value_size> & l)
+	{
+		return InputFromStream<std::wistream, std::wstring, wchar_t>(s, l);
+	}
+
+#endif
+
+
+	/*
+		Following methods are defined in:
+			ttmathuint_x86.h
+			ttmathuint_x86_64.h
+			ttmathuint_noasm.h
+	*/
+
+#ifdef TTMATH_NOASM
+	static uint AddTwoWords(uint a, uint b, uint carry, uint * result);
+	static uint SubTwoWords(uint a, uint b, uint carry, uint * result);
+
+#ifdef TTMATH_PLATFORM64
+
+	union uint_
+	{
+		struct 
+		{
+			unsigned int low;  // 32 bit 
+			unsigned int high; // 32 bit
+		} u_;
+
+		uint u;                // 64 bit
+	};
+
+
+	static void DivTwoWords2(uint a,uint b, uint c, uint * r, uint * rest);
+	static uint DivTwoWordsNormalize(uint_ & a_, uint_ & b_, uint_ & c_);
+	static uint DivTwoWordsUnnormalize(uint u, uint d);
+	static unsigned int DivTwoWordsCalculate(uint_ u_, unsigned int u3, uint_ v_);
+	static void MultiplySubtract(uint_ & u_, unsigned int & u3, unsigned int & q, uint_ v_);
+
+#endif // TTMATH_PLATFORM64
+#endif // TTMATH_NOASM
+
+
+private:
+	uint Rcl2_one(uint c);
+	uint Rcr2_one(uint c);
+	uint Rcl2(uint bits, uint c);
+	uint Rcr2(uint bits, uint c);
+
+public:
+	static const char * LibTypeStr();
+	static LibTypeCode LibType();
+	uint Add(const UInt<value_size> & ss2, uint c=0);
+	uint AddInt(uint value, uint index = 0);
+	uint AddTwoInts(uint x2, uint x1, uint index);
+	static uint AddVector(const uint * ss1, const uint * ss2, uint ss1_size, uint ss2_size, uint * result);
+	uint Sub(const UInt<value_size> & ss2, uint c=0);
+	uint SubInt(uint value, uint index = 0);
+	static uint SubVector(const uint * ss1, const uint * ss2, uint ss1_size, uint ss2_size, uint * result);
+	static sint FindLeadingBitInWord(uint x);
+	static sint FindLowestBitInWord(uint x);
+	static uint SetBitInWord(uint & value, uint bit);
+	static void MulTwoWords(uint a, uint b, uint * result_high, uint * result_low);
+	static void DivTwoWords(uint a,uint b, uint c, uint * r, uint * rest);
+
+};
+
+
+
+/*!
+	this specialization is needed in order to not confuse the compiler "error: ISO C++ forbids zero-size array"
+	when compiling Mul3Big2() method
+*/
+template<>
+class UInt<0>
+{
+public:
+	uint table[1];
+
+	void Mul2Big(const UInt<0> &, UInt<0> &) { TTMATH_ASSERT(false) };
+	void SetZero() { TTMATH_ASSERT(false) };
+	uint AddTwoInts(uint, uint, uint) { TTMATH_ASSERT(false) return 0; };
+};
+
+
+} //namespace
+
+
+#include "ttmathuint_x86.h"
+#include "ttmathuint_x86_64.h"
+#include "ttmathuint_noasm.h"
+
+#endif