/*
	Bigint::core
*/


__BIGINT_THIS_FILE_IS( "core.js", "v0.5 beta 9", "2003-12-28" );


//////////////////////////////////////////////////////////////////////////////////////
var __BIGINT_SAFE_MODE = true;

var __BIGINT_BIG_POWER = 7;
var __BIGINT_BIG_RADIX = 10;
var __BIGINT_BIG_UNIT = Math.pow( __BIGINT_BIG_RADIX, __BIGINT_BIG_POWER );
var __BIGINT_HALF_UNIT = __BIGINT_BIG_UNIT / 2;
var __BIGINT_BIGGER_POWER = 15;
var __BIGINT_BIGGER_UNIT = Math.pow( __BIGINT_BIG_RADIX, __BIGINT_BIGGER_POWER );
var __BIGINT_2E16 = Math.pow( 2, 16 );
var __BIGINT_2E32 = Math.pow( 2, 32 );
var __BIGINT_JS_INT_MAX = Math.pow(2, 53);// 9007199254740992
	
var __BIGINT_E10 = Math.pow( 10, 10 );
var __BIGINT_E12 = Math.pow( 10, 12 );
var __BIGINT_E13 = Math.pow( 10, 13 );
var __BIGINT_E14 = Math.pow( 10, 14 );

//////////////////////////////////////////////////////////////////////////////////////


function Bigint( input ) {
	this.isBigint = true;
	this.table = new Array();

	if( !input ) {
		this.table[0] = 0;
		this.sign = 0;
	} else if( input.isBigint ) {
		Bigint._debug( "constructor: " + input + " is already Bigint." );
		for(var i=0; i<input.table.length; i++) this.table[i] = x.table[i];
		this.sign = input.sign;
	} else {
		if( typeof input === "number" ) {
			if( isNaN( input ) || input === Infinity || input === -Infinity ) return new Bigint(0);
			var strInput = ( input + "" ).toLowerCase();
			if( strInput.indexOf( "e" ) > -1 ) return Bigint._fromFloat( strInput );
		} else {
			var strInput = ( input + "" ).replace( /\s/g, "" );
			strInput = strInput.toLowerCase();
			if( strInput.charAt(1) === "x" ) return Bigint._fromHex( strInput );
			if( strInput.indexOf( "e" ) > -1 ) return Bigint._fromFloat( strInput );
		}

		var nPaddingLength = 0;

		switch( strInput.charAt(0) ) {
			case "+":
				this.sign = (+1);
				nPaddingLength = 1;
				break;

			case "-":
				this.sign = (-1);
				nPaddingLength = 1;
				break;

			default:
				this.sign = (+1);
				nPaddingLength = 0;
				break;
		}

		for( var i = nPaddingLength; i < strInput.length; i++ ) {
			if( strInput.charAt( i ) !== "0" ) break;
			nPaddingLength++;
		}

		var pos = nPaddingLength;
		for( ; pos < strInput.length; pos++ ) {
			if( isNaN( strInput.charAt(pos) ) ) break;
		}

		strInput = strInput.substring( nPaddingLength, pos );

		if( !strInput ) return new Bigint(0);

		var tableSize = Math.ceil( strInput.length / __BIGINT_BIG_POWER );

		var lastItemLength = strInput.length % __BIGINT_BIG_POWER;
		if( lastItemLength === 0 ) lastItemLength = __BIGINT_BIG_POWER;

		this.table[ tableSize-1 ] = strInput.substr( 0, lastItemLength ) - 0;
		var pos = lastItemLength;

		for( var i = tableSize-2; i >= 0; i-- ) {
			this.table[i] = strInput.substr( pos , __BIGINT_BIG_POWER ) - 0;
			pos += __BIGINT_BIG_POWER;
		}
	}
}

Bigint.number = function( input ) {
	return ( new Bigint( input ) );
}

Bigint.prototype.setNaB = function() {
	this.table.length = 0;
	delete this.table;
}

Bigint.prototype.isNaB = function() {
	return ( this.table === void 0 );
}

Bigint._fromFloat = function( f ) {
	var strFloat = ( f + "" ).toLowerCase();
	var posE = strFloat.indexOf("e");
	if( posE === -1 ) return new Bigint( Math.floor(f) );
	
	if( strFloat.charAt( posE + 1 ) === "-" ) {
		return Bigint._error("_fromFloat" , "Parse error: \'+\' expected: " + f );
	}
	
	var strPower = strFloat.substr( posE + 1 );
	if( strPower === "" ) {
		return Bigint._error("_fromFloat" , "Parse error: power expected: " + f );
	}
	var nPower = parseInt( strPower - 0 );
	if( isNaN( nPower ) || nPower < 1 ){
		return Bigint._error("_fromFloat" , "Parse error: malformed power: " + f );
	}
	
	var strInteger, strFractional;
	
	var posPoint = strFloat.indexOf(".");
	if( posPoint === -1 ) {
		strInteger = strFloat.substring( 0, posE );
		strFractional = "";
	} else {
		strInteger = strFloat.substring( 0, posPoint );
		strFractional = strFloat.substring( posPoint+1 , posE );
		if( strFractional.length >= nPower ) {
			return new Bigint( strInteger + strFractional.substr( 0 , nPower ) );
		}
	}
	var nZeros = nPower - strFractional.length;
	
	_debug("_fromFloat",strInteger + strFractional + Bigint._getStringZeros( nZeros ));
	
	return new Bigint( strInteger + strFractional + Bigint._getStringZeros( nZeros ) );
	
//"1.8450472606113795e+22"	
	//1e+100
}

Bigint._fromHex = function( strHex ) {
	strHex = strHex.toLowerCase();
	if( strHex.substr( 0 , 2 ) !== "0x" ) {
		return Bigint._error("_fromHex" , "malformed input: " + strHex );
	}

	strHex = strHex.substr( 2 );

	var bigResult = new Bigint( 0 );

	var bigUnit = new Bigint( 1 );

	for( var pos = strHex.length - 12; ; pos -= 12 ) {
		var tmpstr = "0x" + strHex.substring( pos, pos+12 );
		var n = tmpstr - 0;

		if( isNaN( n ) ) {
			return Bigint._error("_fromHex" , "malformed input: " + tmpstr + " in " + strHex );
		}

		var bigTmp = Bigint.mul( n, bigUnit );
		bigResult = Bigint._add( bigTmp, bigResult );

		if( pos <= 0 ) return bigResult;

		bigUnit = Bigint.mul( bigUnit, Bigint.pow( 2 , 48 ) )
	}
}


Bigint.serio = function( x ) {
	if( x.isBigint ) return x.copy();
	else return new Bigint( x );
}

Bigint.prototype.copy = function() {
	bigNewObject = new Bigint();
	for( var i=0; i<this.table.length; i++ ) {
		bigNewObject.table[i] = this.table[i];
	}
	bigNewObject.sign = this.sign;
	return bigNewObject;
}


Bigint.prototype.toString = function( arg ) {
	if( this.table === void 0 ) return "NaB";

	if( arg === void 0 ) {
		var lastIndex = this.table.length - 1;
		var strResult = this.table[ lastIndex ] + "";

		var digits = strResult.length;

		if(this.sign < 0) strResult =  "- " + strResult;

		var tmpstr;
		for( var i = lastIndex - 1; i >= 0; i-- ) {
			if( tmpstr = Bigint._DEFAULT_PADDING( this.table[i] ) ) {
				strResult += " " + tmpstr;
				digits += __BIGINT_BIG_POWER;
			} else { // PADDING is called with bad argument (probably internal error)
				this.table.reverse();
				tmpstr = this.table.join(" ");
				this.setNaB();
				return "NaB (malformed) " + tmpstr;
			}
		}
		return strResult + " (" + digits + "-digit)";	
	} else {
		var nRadix = Math.floor( arg );
		if( isNaN( nRadix ) || nRadix < 2 || nRadix > 36 ) {
			return Bigint._error( "toString" , "illegal radix: " + arg );
		}

		if( __BIGINT_SAFE_MODE && nRadix !== 10 ) {
			var digits = this.getLength();
			if( digits > 300 ) {
				var message = "[SAFE_MODE] toString(" + nRadix + "): " + digits + "-digit input. May be time-consuming. Continue?"
				if( !confirm( message ) ) return void 0;
			}
		}

		switch( nRadix = Math.floor( nRadix ) ) {
			case  2: return this.toBinaryString( true );
			case 10: return this.toDecimalString( true );
			default: return this._toString( nRadix );
		}
	}
}

Bigint.prototype.toDecimalString = function( bWithSign ) {
	var lastIndex = this.table.length-1;
	var strResult = "";
	if( bWithSign && this.sign<0 ) strResult = "-";
	strResult += this.table[ lastIndex ];

	for( var i = lastIndex - 1; i >= 0; i-- ) {
		strResult += Bigint._DEFAULT_PADDING( this.table[i] );
	}

	return strResult;
}


Bigint.prototype.toBinaryString_v1 = function( bWithSign ) {
	var decimalString = this.toDecimalString();

	var tableSize = Math.ceil( decimalString.length / __BIGINT_BIGGER_POWER );
	var biggerTable = new Array( tableSize );

	var lastItemLength = decimalString.length % __BIGINT_BIGGER_POWER;
	if( lastItemLength === 0 ) lastItemLength = __BIGINT_BIGGER_POWER;

	biggerTable[ tableSize - 1 ] = decimalString.substr( 0, lastItemLength ) - 0;
	var pos = lastItemLength;

	for( var i = tableSize - 2; i >= 0; i-- ) {
		biggerTable[i] = decimalString.substr( pos , __BIGINT_BIGGER_POWER ) - 0;
		pos += __BIGINT_BIGGER_POWER;
	}

	var strResult = "";

	for( var dummy=0; dummy<5000; dummy++ ) {
		var tmpstr = biggerTable[ 0 ] + "";

		var nLastDigit = tmpstr.charAt( tmpstr.length - 1 ) - 0;

		if( nLastDigit % 2 === 1 ) {
			strResult = "1" + strResult
			biggerTable = Bigint._decrementBiggerTable( biggerTable );
		} else {
			strResult = "0" + strResult;
		} 

		if( biggerTable.length === 1 && biggerTable[0] === 0 ) {

			if( bWithSign && this.sign<0 ) return "-" + strResult;
			else return strResult;
		} else biggerTable = Bigint._halfBiggerTable( biggerTable );
	}
	Bigint._error("toBinaryString: too many loops");
	return void 0;
}

Bigint.prototype.toBinaryString = function( bWithSign ) {
	var bigWork = this.copy();
	var strResult = "";

	do {
		if( bigWork.half() ) {
			strResult = "1" + strResult;
		} else {
			strResult = "0" + strResult;
		}
	} while( !bigWork.isZero() );

	if( bWithSign && this.sign < 0 ) return "-" + strResult;
	else return strResult;
}


Bigint.prototype._toString =  function( nRadix ) {
	var strDividend = this.toDecimalString();
	var strResult = "";
	do {
		var strQR = Bigint._qr_typeN( strDividend, nRadix );
		strResult = ( strQR[1] - 0 ).toString( nRadix ) + strResult;
		strDividend = strQR[0];
	} while( strDividend !== "0" )
	if( this.sign < 0 ) return "-" + strResult;
	else return strResult;
}

Bigint.prototype.toNumber = function() {
	return this.toDecimalString(true) - 0;
}

Bigint.prototype.comparedWith = function( n ) {
	var bigNumber = Bigint.serio( n );
	if( this.sign >= 0 && bigNumber.sign >= 0 ) {
		return Bigint._tablecmp( this.table, bigNumber.table );
	}
}

Bigint._abscmp = function( bigNumber1, bigNumber2 ) {
	return Bigint._tablecmp( bigNumber1.table, bigNumber2.table );
}

Bigint._tablecmp = function( table1, table2 ) {
	var len1 = table1.length;
	var len2 = table2.length;
	if( len1 > len2 ) return 3;
	else if( len1 < len2 ) return -3;
	
	for( var i = len1-1; i >=0; i-- ) {
		if( table1[i] > table2[i] ) return 3;
		else if(table1[i] < table2[i] ) return -3;
	}
	
	return 0;
}


Bigint._strcmp = function( strNumber1, strNumber2 ) {
	if( strNumber1.length > strNumber2.length ) {
		return 3;
	} else if( strNumber1.length < strNumber2.length ) {
		return -3;
	}

	for( var i=0; i < strNumber1.length; i+=15 ) {
		var a = strNumber1.substr( i, 15 ) - 0;
		var b = strNumber2.substr( i, 15 ) - 0;
		if( a > b ) return 2;
		if( a < b ) return -2;
	}

	return 0;
}

Bigint.strcmp = Bigint._strcmp;

Bigint.prototype.isZero = function() {
	return ( this.table.length === 1 && this.table[0] === 0 );
}

Bigint.prototype.isEven = function() {
	return (this.table[0] % 2 === 0)? true : false;
}
Bigint.prototype.isOdd = function() {
	return (this.table[0] % 2 === 1)? true : false;
}



// input should be even >= 2
Bigint._halfBiggerTable = function( biggerTable ) {
	var result = new Array();
	var flag = false;

	for( var i=biggerTable.length-1; i>=0; i-- ) {
		var tmpstr = biggerTable[ i ] + "";
		var nLastDigit = tmpstr.charAt( tmpstr.length - 1 ) - 0;

		if( flag ) biggerTable[ i ] += __BIGINT_BIGGER_UNIT;

		if( nLastDigit % 2 === 1 ) {
			result[i] = ( biggerTable[i] - 1 ) / 2;
			flag = true;
		} else {
			result[i] = biggerTable[i] / 2;
			flag = false;
		}
	}

	var lastIndex = result.length - 1;

	if( result[ lastIndex ] === 0 ) result.length--;

	return result;
}

Bigint._decrementBiggerTable = function( biggerTable ) {
	for( var i=0; i<biggerTable.length; i++ ) {
		if( biggerTable[i] > 0 ) {
			biggerTable[i]--;
			return biggerTable;
		} else {
			biggerTable[i] = __BIGINT__BIGGER_UNIT - 1;
		}
	}
}



Bigint.prototype.getLength = function() {
	var lastIndex = this.table.length - 1;
	var lastItemLength = ( this.table[ lastIndex ] + "" ).length;
	return __BIGINT_BIG_POWER * lastIndex + lastItemLength;
}


Bigint.prototype.isEqualTo = function( compared ) {
	var bigNumber = Bigint.serio(compared);

	if( this.table.length !== bigNumber.table.length ) return false;

	for( var i=0; i<this.table.length; i++ ) {
		if( this.table[i] !== bigNumber.table[i] ) return false;
	}

	return true;
}



Bigint.log10 = function( input ) {
	var x;
	if( input.isBigint ) x = input.toDecimalString();
	else x = input - 0;

	return Math.log( x ) / Math.log( 10 );
}

Bigint.prototype.getBitWidth = function( d ) {
	return this.getBitWidthS( d ) - 0;
}

Bigint.prototype.getBitWidthS = function( d ) {
	var strLog2 = Math.log( this.toDecimalString() ) / Math.log( 2 ) + "";
	if( typeof d === "number" && d >= 1 ) {
		if( d > 16 ) d = 16;
		else d = Math.floor( d );

		if( strLog2.indexOf(".") === -1 ) strLog2 += ".0000000000000000";
		else strLog2 += "0000000000000000";

		var pos = strLog2.indexOf(".") + 1;
		return strLog2.substring( 0 , pos + d );
	} else {
		return Math.ceil( strLog2 - 0 ) + "";
	}
}


Bigint._log2 = function( bigNumber ) {
	var tmp = Math.log( bigNumber.toDecimalString() ) / Math.log( 2 );
	return tmp.toString().substr(0,5);
}

if( typeof _log2 === "undefined" ) _log2 = Bigint._log2;

Bigint.setIO = function( objForm ) {
	__BIGINT_IO = objForm; // global
}

Bigint._debug = function(str1, str2) {
	var strMessage = "DEBUG: ";
	if( str2 === void 0 ) {
		strMessage += str1;
	} else {
		strMessage += str1 + " = " + str2;
	}

	if( typeof document !== "undefined" &&  typeof document.__BIGINT_HTML_FORM !== "undefined"  ) {
		if( str1 === void 0 && str2 === void 0 ) document.__BIGINT_HTML_FORM.debug.value = "";
		else
		document.__BIGINT_HTML_FORM.debug.value += strMessage + "\n";
	} else {
		document.write( "<p>" + strMessage + "<\/p>" );
	}


}

if( typeof _debug === "undefined" ) _debug = Bigint._debug;
if( typeof _bold === "undefined" ) _bold = Bigint._debug;

Bigint._error = function ( strFunctionName, strDescription ) {
	var strMessage = "ERROR ( " + strFunctionName + " ): " + strDescription;
	if( typeof document !== "undefined"
		&& typeof document.__BIGINT_HTML_FORM !== "undefined"
		&& typeof document.__BIGINT_HTML_FORM.output !== "undefined" ) {
			document.__BIGINT_HTML_FORM.output.value = strMessage;
	} else {
		alert( strMessage );
	}
	return void 0;
}

if( typeof _error === "undefined" ) _error = Bigint._error;

Bigint._progress = function( str ) {
	if( typeof document !== "undefined"
		&& typeof document.__BIGINT_HTML_FORM !== "undefined"
		&& typeof document.__BIGINT_HTML_FORM.output !== "undefined" ) {
	
		var p = document.__BIGINT_HTML_FORM.output;
		if( str === void 0 ) p.value = "";
		else {
			p.value += str;
			if( p.value.length % 60 === 59 ) p.value += "\n";
			if( typeof defaultStatus !== "undefined" ) {
				var pos = p.value.lastIndexOf("\n");
				defaultStatus = p.value.substr( pos );
			}
		}
	}
}
if( typeof _progress === "undefined" ) _progress = Bigint._progress;



function _timing( argument ) {
	var objDate = new Date();
	var t = objDate.getTime();

	if( _timing.t0 === void 0 || argument === 0 ) {
		_timing.t0 = t;
		return true;
	} else {
		var cost = t - _timing.t0;
		_timing.t0 = t;
		_timing.totalCost += cost;

		if( argument === void 0 ) {
			Bigint._debug( "* Cost: " + cost + " ms");
			return cost;
		} else if( argument === "total" ) {
			var total = _timing.totalCost;
			Bigint._debug( "** Total Cost: " + total + " ms");
			_timing.totalCost = 0;
			_timing.t0 = void 0;
			return total;
		} else {
			Bigint._debug( "*Cost ( " + argument + " ): " + cost + " ms");
			return cost;
		}
	}
}

_timing.t0 = void 0;
_timing.totalCost = 0;


///////////////////////////////////////////////////////////////////
//
// Padding ( number -> string )
//
///////////////////////////////////////////////////////////////////

Bigint._padding1 = function( n ) {
	return n + "";
}

Bigint._padding2 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case 2: return       strNumber;
		case 1: return "0" + strNumber;
	}
}

Bigint._padding3 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case 3: return        strNumber;
		case 2: return "0"  + strNumber;
		case 1: return "00" + strNumber;
	}
}

Bigint._padding4 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case 4: return         strNumber;
		case 3: return "0"   + strNumber;
		case 2: return "00"  + strNumber;
		case 1: return "000" + strNumber;
	}
}

Bigint._padding5 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case 5: return            strNumber;
		case 4: return "0"    + strNumber;
		case 3: return "00"   + strNumber;
		case 2: return "000"  + strNumber;
		case 1: return "0000" + strNumber;
	}
}

Bigint._padding6 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case 6: return           strNumber;
		case 5: return "0"     + strNumber;
		case 4: return "00"    + strNumber;
		case 3: return "000"   + strNumber;
		case 2: return "0000"  + strNumber;
		case 1: return "00000" + strNumber;
	}
}

Bigint._padding7 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case 7: return            strNumber;
		case 6: return "0"      + strNumber;
		case 5: return "00"     + strNumber;
		case 4: return "000"    + strNumber;
		case 3: return "0000"   + strNumber;
		case 2: return "00000"  + strNumber;
		case 1: return "000000" + strNumber;
	}
}

Bigint._padding8 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case  8: return             strNumber;
		case  7: return "0"       + strNumber;
		case  6: return "00"      + strNumber;
		case  5: return "000"     + strNumber;
		case  4: return "0000"    + strNumber;
		case  3: return "00000"   + strNumber;
		case  2: return "000000"  + strNumber;
		case  1: return "0000000" + strNumber;
	}
}
Bigint._padding9 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case  9: return              strNumber;
		case  8: return "0"        + strNumber;
		case  7: return "00"       + strNumber;
		case  6: return "000"      + strNumber;
		case  5: return "0000"     + strNumber;
		case  4: return "00000"    + strNumber;
		case  3: return "000000"   + strNumber;
		case  2: return "0000000"  + strNumber;
		case  1: return "00000000" + strNumber;
	}
}
Bigint._padding10 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case 10: return               strNumber;
		case  9: return "0"         + strNumber;
		case  8: return "00"        + strNumber;
		case  7: return "000"       + strNumber;
		case  6: return "0000"      + strNumber;
		case  5: return "00000"     + strNumber;
		case  4: return "000000"    + strNumber;
		case  3: return "0000000"   + strNumber;
		case  2: return "00000000"  + strNumber;
		case  1: return "000000000" + strNumber;
	}
}

Bigint._padding11 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case 11: return                strNumber;
		case 10: return "0"          + strNumber;
		case  9: return "00"         + strNumber;
		case  8: return "000"        + strNumber;
		case  7: return "0000"       + strNumber;
		case  6: return "00000"      + strNumber;
		case  5: return "000000"     + strNumber;
		case  4: return "0000000"    + strNumber;
		case  3: return "00000000"   + strNumber;
		case  2: return "000000000"  + strNumber;
		case  1: return "0000000000" + strNumber;
	}
}

Bigint._padding12 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case 12: return                 strNumber;
		case 11: return "0"           + strNumber;
		case 10: return "00"          + strNumber;
		case  9: return "000"         + strNumber;
		case  8: return "0000"        + strNumber;
		case  7: return "00000"       + strNumber;
		case  6: return "000000"      + strNumber;
		case  5: return "0000000"     + strNumber;
		case  4: return "00000000"    + strNumber;
		case  3: return "000000000"   + strNumber;
		case  2: return "0000000000"  + strNumber;
		case  1: return "00000000000" + strNumber;
	}
}

Bigint._padding13 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case 13: return                  strNumber;
		case 12: return "0"            + strNumber;
		case 11: return "00"           + strNumber;
		case 10: return "000"          + strNumber;
		case  9: return "0000"         + strNumber;
		case  8: return "00000"        + strNumber;
		case  7: return "000000"       + strNumber;
		case  6: return "0000000"      + strNumber;
		case  5: return "00000000"     + strNumber;
		case  4: return "000000000"    + strNumber;
		case  3: return "0000000000"   + strNumber;
		case  2: return "00000000000"  + strNumber;
		case  1: return "000000000000" + strNumber;
	}
}

Bigint._padding14 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case 14: return                   strNumber;
		case 13: return "0"             + strNumber;
		case 12: return "00"            + strNumber;
		case 11: return "000"           + strNumber;
		case 10: return "0000"          + strNumber;
		case  9: return "00000"         + strNumber;
		case  8: return "000000"        + strNumber;
		case  7: return "0000000"       + strNumber;
		case  6: return "00000000"      + strNumber;
		case  5: return "000000000"     + strNumber;
		case  4: return "0000000000"    + strNumber;
		case  3: return "00000000000"   + strNumber;
		case  2: return "000000000000"  + strNumber;
		case  1: return "0000000000000" + strNumber;
	}
}

Bigint._padding15 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case 15: return                    strNumber;
		case 14: return "0"              + strNumber;
		case 13: return "00"             + strNumber;
		case 12: return "000"            + strNumber;
		case 11: return "0000"           + strNumber;
		case 10: return "00000"          + strNumber;
		case  9: return "000000"         + strNumber;
		case  8: return "0000000"        + strNumber;
		case  7: return "00000000"       + strNumber;
		case  6: return "000000000"      + strNumber;
		case  5: return "0000000000"     + strNumber;
		case  4: return "00000000000"    + strNumber;
		case  3: return "000000000000"   + strNumber;
		case  2: return "0000000000000"  + strNumber;
		case  1: return "00000000000000" + strNumber;
	}
}

Bigint._padding16 = function( n ) {
	var strNumber = n + "";
	switch( strNumber.length ) {
		case 16: return                     strNumber;
		case 15: return "0"               + strNumber;
		case 14: return "00"              + strNumber;
		case 13: return "000"             + strNumber;
		case 12: return "0000"            + strNumber;
		case 11: return "00000"           + strNumber;
		case 10: return "000000"          + strNumber;
		case  9: return "0000000"         + strNumber;
		case  8: return "00000000"        + strNumber;
		case  7: return "000000000"       + strNumber;
		case  6: return "0000000000"      + strNumber;
		case  5: return "00000000000"     + strNumber;
		case  4: return "000000000000"    + strNumber;
		case  3: return "0000000000000"   + strNumber;
		case  2: return "00000000000000"  + strNumber;
		case  1: return "000000000000000" + strNumber;
	}
}

Bigint._padding = [
	void 0,
	Bigint._padding1 ,
	Bigint._padding2 ,
	Bigint._padding3 ,
	Bigint._padding4 ,
	Bigint._padding5 ,
	Bigint._padding6 ,
	Bigint._padding7 ,
	Bigint._padding8 ,
	Bigint._padding9 ,
	Bigint._padding10 ,
	Bigint._padding11 ,
	Bigint._padding12 ,
	Bigint._padding13 ,
	Bigint._padding14 ,
	Bigint._padding15 ,
	Bigint._padding16
];

Bigint._DEFAULT_PADDING = Bigint._padding7;
Bigint._paddingBigger = Bigint._padding15;


Bigint._getStringZeros = function( n ) {
	if( n < 1 ) return "";

	var low = n % 10;
	var high = ( n - low ) / 10;
	var strResult = "";
	var i;
	for( i=0; i<low; i++ ) strResult += "0";
	for( i=0; i<high; i++ ) strResult += "0000000000";
	
	return strResult;
}