// TODO: strip out parts of this we do not need

//======= begin closure i64 code =======

// Copyright 2009 The Closure Library Authors. All Rights Reserved.

//

// Licensed under the Apache License, Version 2.0 (the "License");

// you may not use this file except in compliance with the License.

// You may obtain a copy of the License at

//

// http://www.apache.org/licenses/LICENSE-2.0

//

// Unless required by applicable law or agreed to in writing, software

// distributed under the License is distributed on an "AS-IS" BASIS,

// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

// See the License for the specific language governing permissions and

// limitations under the License.

/**

* @fileoverview Defines a Long class for representing a 64-bit two's-complement

* integer value, which faithfully simulates the behavior of a Java "long". This

* implementation is derived from LongLib in GWT.

*

*/

var i64Math = (function() { // Emscripten wrapper

var goog = { math: {} };

/**

* Constructs a 64-bit two's-complement integer, given its low and high 32-bit

* values as *signed* integers. See the from* functions below for more

* convenient ways of constructing Longs.

*

* The internal representation of a long is the two given signed, 32-bit values.

* We use 32-bit pieces because these are the size of integers on which

* Javascript performs bit-operations. For operations like addition and

* multiplication, we split each number into 16-bit pieces, which can easily be

* multiplied within Javascript's floating-point representation without overflow

* or change in sign.

*

* In the algorithms below, we frequently reduce the negative case to the

* positive case by negating the input(s) and then post-processing the result.

* Note that we must ALWAYS check specially whether those values are MIN_VALUE

* (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as

* a positive number, it overflows back into a negative). Not handling this

* case would often result in infinite recursion.

*

* @param {number} low The low (signed) 32 bits of the long.

* @param {number} high The high (signed) 32 bits of the long.

* @constructor

*/

goog.math.Long = function(low, high) {

/**

* @type {number}

* @private

*/

this.low_ = low | 0; // force into 32 signed bits.

/**

* @type {number}

* @private

*/

this.high_ = high | 0; // force into 32 signed bits.

};

// NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the

// from* methods on which they depend.

/**

* A cache of the Long representations of small integer values.

* @type {!Object}

* @private

*/

goog.math.Long.IntCache_ = {};

/**

* Returns a Long representing the given (32-bit) integer value.

* @param {number} value The 32-bit integer in question.

* @return {!goog.math.Long} The corresponding Long value.

*/

goog.math.Long.fromInt = function(value) {

if (-128 <= value && value < 128) {

var cachedObj = goog.math.Long.IntCache_[value];

if (cachedObj) {

return cachedObj;

}

}

var obj = new goog.math.Long(value | 0, value < 0 ? -1 : 0);

if (-128 <= value && value < 128) {

goog.math.Long.IntCache_[value] = obj;

}

return obj;

};

/**

* Returns a Long representing the given value, provided that it is a finite

* number. Otherwise, zero is returned.

* @param {number} value The number in question.

* @return {!goog.math.Long} The corresponding Long value.

*/

goog.math.Long.fromNumber = function(value) {

if (isNaN(value) || !isFinite(value)) {

return goog.math.Long.ZERO;

} else if (value <= -goog.math.Long.TWO_PWR_63_DBL_) {

return goog.math.Long.MIN_VALUE;

} else if (value + 1 >= goog.math.Long.TWO_PWR_63_DBL_) {

return goog.math.Long.MAX_VALUE;

} else if (value < 0) {

return goog.math.Long.fromNumber(-value).negate();

} else {

return new goog.math.Long(

(value % goog.math.Long.TWO_PWR_32_DBL_) | 0,

(value / goog.math.Long.TWO_PWR_32_DBL_) | 0);

}

};

/**

* Returns a Long representing the 64-bit integer that comes by concatenating

* the given high and low bits. Each is assumed to use 32 bits.

* @param {number} lowBits The low 32-bits.

* @param {number} highBits The high 32-bits.

* @return {!goog.math.Long} The corresponding Long value.

*/

goog.math.Long.fromBits = function(lowBits, highBits) {

return new goog.math.Long(lowBits, highBits);

};

/**

* Returns a Long representation of the given string, written using the given

* radix.

* @param {string} str The textual representation of the Long.

* @param {number=} opt_radix The radix in which the text is written.

* @return {!goog.math.Long} The corresponding Long value.

*/

goog.math.Long.fromString = function(str, opt_radix) {

if (str.length == 0) {

throw Error('number format error: empty string');

}

var radix = opt_radix || 10;

if (radix < 2 || 36 < radix) {

throw Error('radix out of range: ' + radix);

}

if (str.charAt(0) == '-') {

return goog.math.Long.fromString(str.substring(1), radix).negate();

} else if (str.indexOf('-') >= 0) {

throw Error('number format error: interior "-" character: ' + str);

}

// Do several (8) digits each time through the loop, so as to

// minimize the calls to the very expensive emulated div.

var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 8));

var result = goog.math.Long.ZERO;

for (var i = 0; i < str.length; i += 8) {

var size = Math.min(8, str.length - i);

var value = parseInt(str.substring(i, i + size), radix);

if (size < 8) {

var power = goog.math.Long.fromNumber(Math.pow(radix, size));

result = result.multiply(power).add(goog.math.Long.fromNumber(value));

} else {

result = result.multiply(radixToPower);

result = result.add(goog.math.Long.fromNumber(value));

}

}

return result;

};

// NOTE: the compiler should inline these constant values below and then remove

// these variables, so there should be no runtime penalty for these.

/**

* Number used repeated below in calculations. This must appear before the

* first call to any from* function below.

* @type {number}

* @private

*/

goog.math.Long.TWO_PWR_16_DBL_ = 1 << 16;

/**

* @type {number}

* @private

*/

goog.math.Long.TWO_PWR_24_DBL_ = 1 << 24;

/**

* @type {number}

* @private

*/

goog.math.Long.TWO_PWR_32_DBL_ =

goog.math.Long.TWO_PWR_16_DBL_ * goog.math.Long.TWO_PWR_16_DBL_;

/**

* @type {number}

* @private

*/

goog.math.Long.TWO_PWR_31_DBL_ =

goog.math.Long.TWO_PWR_32_DBL_ / 2;

/**

* @type {number}

* @private

*/

goog.math.Long.TWO_PWR_48_DBL_ =

goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_16_DBL_;

/**

* @type {number}

* @private

*/

goog.math.Long.TWO_PWR_64_DBL_ =

goog.math.Long.TWO_PWR_32_DBL_ * goog.math.Long.TWO_PWR_32_DBL_;

/**

* @type {number}

* @private

*/

goog.math.Long.TWO_PWR_63_DBL_ =

goog.math.Long.TWO_PWR_64_DBL_ / 2;

/** @type {!goog.math.Long} */

goog.math.Long.ZERO = goog.math.Long.fromInt(0);

/** @type {!goog.math.Long} */

goog.math.Long.ONE = goog.math.Long.fromInt(1);

/** @type {!goog.math.Long} */

goog.math.Long.NEG_ONE = goog.math.Long.fromInt(-1);

/** @type {!goog.math.Long} */

goog.math.Long.MAX_VALUE =

goog.math.Long.fromBits(0xFFFFFFFF | 0, 0x7FFFFFFF | 0);

/** @type {!goog.math.Long} */

goog.math.Long.MIN_VALUE = goog.math.Long.fromBits(0, 0x80000000 | 0);

/**

* @type {!goog.math.Long}

* @private

*/

goog.math.Long.TWO_PWR_24_ = goog.math.Long.fromInt(1 << 24);

/** @return {number} The value, assuming it is a 32-bit integer. */

goog.math.Long.prototype.toInt = function() {

return this.low_;

};

/** @return {number} The closest floating-point representation to this value. */

goog.math.Long.prototype.toNumber = function() {

return this.high_ * goog.math.Long.TWO_PWR_32_DBL_ +

this.getLowBitsUnsigned();

};

/**

* @param {number=} opt_radix The radix in which the text should be written.

* @return {string} The textual representation of this value.

*/

goog.math.Long.prototype.toString = function(opt_radix) {

var radix = opt_radix || 10;

if (radix < 2 || 36 < radix) {

throw Error('radix out of range: ' + radix);

}

if (this.isZero()) {

return '0';

}

if (this.isNegative()) {

if (this.equals(goog.math.Long.MIN_VALUE)) {

// We need to change the Long value before it can be negated, so we remove

// the bottom-most digit in this base and then recurse to do the rest.

var radixLong = goog.math.Long.fromNumber(radix);

var div = this.div(radixLong);

var rem = div.multiply(radixLong).subtract(this);

return div.toString(radix) + rem.toInt().toString(radix);

} else {

return '-' + this.negate().toString(radix);

}

}

// Do several (6) digits each time through the loop, so as to

// minimize the calls to the very expensive emulated div.

var radixToPower = goog.math.Long.fromNumber(Math.pow(radix, 6));

var rem = this;

var result = '';

while (true) {

var remDiv = rem.div(radixToPower);

var intval = rem.subtract(remDiv.multiply(radixToPower)).toInt();

var digits = intval.toString(radix);

rem = remDiv;

if (rem.isZero()) {

return digits + result;

} else {

while (digits.length < 6) {

digits = '0' + digits;

}

result = '' + digits + result;

}

}

};

/** @return {number} The high 32-bits as a signed value. */

goog.math.Long.prototype.getHighBits = function() {

return this.high_;

};

/** @return {number} The low 32-bits as a signed value. */

goog.math.Long.prototype.getLowBits = function() {

return this.low_;

};

/** @return {number} The low 32-bits as an unsigned value. */

goog.math.Long.prototype.getLowBitsUnsigned = function() {

return (this.low_ >= 0) ?

this.low_ : goog.math.Long.TWO_PWR_32_DBL_ + this.low_;

};

/**

* @return {number} Returns the number of bits needed to represent the absolute

* value of this Long.

*/

goog.math.Long.prototype.getNumBitsAbs = function() {

if (this.isNegative()) {

if (this.equals(goog.math.Long.MIN_VALUE)) {

return 64;

} else {

return this.negate().getNumBitsAbs();

}

} else {

var val = this.high_ != 0 ? this.high_ : this.low_;

for (var bit = 31; bit > 0; bit--) {

if ((val & (1 << bit)) != 0) {

break;

}

}

return this.high_ != 0 ? bit + 33 : bit + 1;

}

};

/** @return {boolean} Whether this value is zero. */

goog.math.Long.prototype.isZero = function() {

return this.high_ == 0 && this.low_ == 0;

};

/** @return {boolean} Whether this value is negative. */

goog.math.Long.prototype.isNegative = function() {

return this.high_ < 0;

};

/** @return {boolean} Whether this value is odd. */

goog.math.Long.prototype.isOdd = function() {

return (this.low_ & 1) == 1;

};

/**

* @param {goog.math.Long} other Long to compare against.

* @return {boolean} Whether this Long equals the other.

*/

goog.math.Long.prototype.equals = function(other) {

return (this.high_ == other.high_) && (this.low_ == other.low_);

};

/**

* @param {goog.math.Long} other Long to compare against.

* @return {boolean} Whether this Long does not equal the other.

*/

goog.math.Long.prototype.notEquals = function(other) {

return (this.high_ != other.high_) || (this.low_ != other.low_);

};

/**

* @param {goog.math.Long} other Long to compare against.

* @return {boolean} Whether this Long is less than the other.

*/

goog.math.Long.prototype.lessThan = function(other) {

return this.compare(other) < 0;

};

/**

* @param {goog.math.Long} other Long to compare against.

* @return {boolean} Whether this Long is less than or equal to the other.

*/

goog.math.Long.prototype.lessThanOrEqual = function(other) {

return this.compare(other) <= 0;

};

/**

* @param {goog.math.Long} other Long to compare against.

* @return {boolean} Whether this Long is greater than the other.

*/

goog.math.Long.prototype.greaterThan = function(other) {

return this.compare(other) > 0;

};

/**

* @param {goog.math.Long} other Long to compare against.

* @return {boolean} Whether this Long is greater than or equal to the other.

*/

goog.math.Long.prototype.greaterThanOrEqual = function(other) {

return this.compare(other) >= 0;

};

/**

* Compares this Long with the given one.

* @param {goog.math.Long} other Long to compare against.

* @return {number} 0 if they are the same, 1 if the this is greater, and -1

* if the given one is greater.

*/

goog.math.Long.prototype.compare = function(other) {

if (this.equals(other)) {

return 0;

}

var thisNeg = this.isNegative();

var otherNeg = other.isNegative();

if (thisNeg && !otherNeg) {

return -1;

}

if (!thisNeg && otherNeg) {

return 1;

}

// at this point, the signs are the same, so subtraction will not overflow

if (this.subtract(other).isNegative()) {

return -1;

} else {

return 1;

}

};

/** @return {!goog.math.Long} The negation of this value. */

goog.math.Long.prototype.negate = function() {

if (this.equals(goog.math.Long.MIN_VALUE)) {

return goog.math.Long.MIN_VALUE;

} else {

return this.not().add(goog.math.Long.ONE);

}

};

/**

* Returns the sum of this and the given Long.

* @param {goog.math.Long} other Long to add to this one.

* @return {!goog.math.Long} The sum of this and the given Long.

*/

goog.math.Long.prototype.add = function(other) {

// Divide each number into 4 chunks of 16 bits, and then sum the chunks.

var a48 = this.high_ >>> 16;

var a32 = this.high_ & 0xFFFF;

var a16 = this.low_ >>> 16;

var a00 = this.low_ & 0xFFFF;

var b48 = other.high_ >>> 16;

var b32 = other.high_ & 0xFFFF;

var b16 = other.low_ >>> 16;

var b00 = other.low_ & 0xFFFF;

var c48 = 0, c32 = 0, c16 = 0, c00 = 0;

c00 += a00 + b00;

c16 += c00 >>> 16;

c00 &= 0xFFFF;

c16 += a16 + b16;

c32 += c16 >>> 16;

c16 &= 0xFFFF;

c32 += a32 + b32;

c48 += c32 >>> 16;

c32 &= 0xFFFF;

c48 += a48 + b48;

c48 &= 0xFFFF;

return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);

};

/**

* Returns the difference of this and the given Long.

* @param {goog.math.Long} other Long to subtract from this.

* @return {!goog.math.Long} The difference of this and the given Long.

*/

goog.math.Long.prototype.subtract = function(other) {

return this.add(other.negate());

};

/**

* Returns the product of this and the given long.

* @param {goog.math.Long} other Long to multiply with this.

* @return {!goog.math.Long} The product of this and the other.

*/

goog.math.Long.prototype.multiply = function(other) {

if (this.isZero()) {

return goog.math.Long.ZERO;

} else if (other.isZero()) {

return goog.math.Long.ZERO;

}

if (this.equals(goog.math.Long.MIN_VALUE)) {

return other.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO;

} else if (other.equals(goog.math.Long.MIN_VALUE)) {

return this.isOdd() ? goog.math.Long.MIN_VALUE : goog.math.Long.ZERO;

}

if (this.isNegative()) {

if (other.isNegative()) {

return this.negate().multiply(other.negate());

} else {

return this.negate().multiply(other).negate();

}

} else if (other.isNegative()) {

return this.multiply(other.negate()).negate();

}

// If both longs are small, use float multiplication

if (this.lessThan(goog.math.Long.TWO_PWR_24_) &&

other.lessThan(goog.math.Long.TWO_PWR_24_)) {

return goog.math.Long.fromNumber(this.toNumber() * other.toNumber());

}

// Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.

// We can skip products that would overflow.

var a48 = this.high_ >>> 16;

var a32 = this.high_ & 0xFFFF;

var a16 = this.low_ >>> 16;

var a00 = this.low_ & 0xFFFF;

var b48 = other.high_ >>> 16;

var b32 = other.high_ & 0xFFFF;

var b16 = other.low_ >>> 16;

var b00 = other.low_ & 0xFFFF;

var c48 = 0, c32 = 0, c16 = 0, c00 = 0;

c00 += a00 * b00;

c16 += c00 >>> 16;

c00 &= 0xFFFF;

c16 += a16 * b00;

c32 += c16 >>> 16;

c16 &= 0xFFFF;

c16 += a00 * b16;

c32 += c16 >>> 16;

c16 &= 0xFFFF;

c32 += a32 * b00;

c48 += c32 >>> 16;

c32 &= 0xFFFF;

c32 += a16 * b16;

c48 += c32 >>> 16;

c32 &= 0xFFFF;

c32 += a00 * b32;

c48 += c32 >>> 16;

c32 &= 0xFFFF;

c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;

c48 &= 0xFFFF;

return goog.math.Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);

};

/**

* Returns this Long divided by the given one.

* @param {goog.math.Long} other Long by which to divide.

* @return {!goog.math.Long} This Long divided by the given one.

*/

goog.math.Long.prototype.div = function(other) {

if (other.isZero()) {

throw Error('division by zero');

} else if (this.isZero()) {

return goog.math.Long.ZERO;

}

if (this.equals(goog.math.Long.MIN_VALUE)) {

if (other.equals(goog.math.Long.ONE) ||

other.equals(goog.math.Long.NEG_ONE)) {

return goog.math.Long.MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE

} else if (other.equals(goog.math.Long.MIN_VALUE)) {

return goog.math.Long.ONE;

} else {

// At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.

var halfThis = this.shiftRight(1);

var approx = halfThis.div(other).shiftLeft(1);

if (approx.equals(goog.math.Long.ZERO)) {

return other.isNegative() ? goog.math.Long.ONE : goog.math.Long.NEG_ONE;

} else {

var rem = this.subtract(other.multiply(approx));

var result = approx.add(rem.div(other));

return result;

}

}

} else if (other.equals(goog.math.Long.MIN_VALUE)) {

return goog.math.Long.ZERO;

}

if (this.isNegative()) {

if (other.isNegative()) {

return this.negate().div(other.negate());

} else {

return this.negate().div(other).negate();

}

} else if (other.isNegative()) {

return this.div(other.negate()).negate();

}

// Repeat the following until the remainder is less than other: find a

// floating-point that approximates remainder / other *from below*, add this

// into the result, and subtract it from the remainder. It is critical that

// the approximate value is less than or equal to the real value so that the

// remainder never becomes negative.

var res = goog.math.Long.ZERO;

var rem = this;

while (rem.greaterThanOrEqual(other)) {

// Approximate the result of division. This may be a little greater or

// smaller than the actual value.

var approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));

// We will tweak the approximate result by changing it in the 48-th digit or

// the smallest non-fractional digit, whichever is larger.

var log2 = Math.ceil(Math.log(approx) / Math.LN2);

var delta = (log2 <= 48) ? 1 : Math.pow(2, log2 - 48);

// Decrease the approximation until it is smaller than the remainder. Note

// that if it is too large, the product overflows and is negative.

var approxRes = goog.math.Long.fromNumber(approx);

var approxRem = approxRes.multiply(other);

while (approxRem.isNegative() || approxRem.greaterThan(rem)) {

approx -= delta;

approxRes = goog.math.Long.fromNumber(approx);

approxRem = approxRes.multiply(other);

}

// We know the answer can't be zero... and actually, zero would cause

// infinite recursion since we would make no progress.

if (approxRes.isZero()) {

approxRes = goog.math.Long.ONE;

}

res = res.add(approxRes);

rem = rem.subtract(approxRem);

}

return res;

};

/**

* Returns this Long modulo the given one.

* @param {goog.math.Long} other Long by which to mod.

* @return {!goog.math.Long} This Long modulo the given one.

*/

goog.math.Long.prototype.modulo = function(other) {

return this.subtract(this.div(other).multiply(other));

};

/** @return {!goog.math.Long} The bitwise-NOT of this value. */

goog.math.Long.prototype.not = function() {

return goog.math.Long.fromBits(~this.low_, ~this.high_);

};

/**

* Returns the bitwise-AND of this Long and the given one.

* @param {goog.math.Long} other The Long with which to AND.

* @return {!goog.math.Long} The bitwise-AND of this and the other.

*/

goog.math.Long.prototype.and = function(other) {

return goog.math.Long.fromBits(this.low_ & other.low_,

this.high_ & other.high_);

};

/**

* Returns the bitwise-OR of this Long and the given one.

* @param {goog.math.Long} other The Long with which to OR.

* @return {!goog.math.Long} The bitwise-OR of this and the other.

*/

goog.math.Long.prototype.or = function(other) {

return goog.math.Long.fromBits(this.low_ | other.low_,

this.high_ | other.high_);

};

/**

* Returns the bitwise-XOR of this Long and the given one.

* @param {goog.math.Long} other The Long with which to XOR.

* @return {!goog.math.Long} The bitwise-XOR of this and the other.

*/

goog.math.Long.prototype.xor = function(other) {

return goog.math.Long.fromBits(this.low_ ^ other.low_,

this.high_ ^ other.high_);

};

/**

* Returns this Long with bits shifted to the left by the given amount.

* @param {number} numBits The number of bits by which to shift.

* @return {!goog.math.Long} This shifted to the left by the given amount.

*/

goog.math.Long.prototype.shiftLeft = function(numBits) {

numBits &= 63;

if (numBits == 0) {

return this;

} else {

var low = this.low_;

if (numBits < 32) {

var high = this.high_;

return goog.math.Long.fromBits(

low << numBits,

(high << numBits) | (low >>> (32 - numBits)));

} else {

return goog.math.Long.fromBits(0, low << (numBits - 32));

}

}

};

/**

* Returns this Long with bits shifted to the right by the given amount.

* @param {number} numBits The number of bits by which to shift.

* @return {!goog.math.Long} This shifted to the right by the given amount.

*/

goog.math.Long.prototype.shiftRight = function(numBits) {

numBits &= 63;

if (numBits == 0) {

return this;

} else {

var high = this.high_;

if (numBits < 32) {

var low = this.low_;

return goog.math.Long.fromBits(

(low >>> numBits) | (high << (32 - numBits)),

high >> numBits);

} else {

return goog.math.Long.fromBits(

high >> (numBits - 32),

high >= 0 ? 0 : -1);

}

}

};

/**

* Returns this Long with bits shifted to the right by the given amount, with

* the new top bits matching the current sign bit.

* @param {number} numBits The number of bits by which to shift.

* @return {!goog.math.Long} This shifted to the right by the given amount, with

* zeros placed into the new leading bits.

*/

goog.math.Long.prototype.shiftRightUnsigned = function(numBits) {

numBits &= 63;

if (numBits == 0) {

return this;

} else {

var high = this.high_;

if (numBits < 32) {

var low = this.low_;

return goog.math.Long.fromBits(

(low >>> numBits) | (high << (32 - numBits)),

high >>> numBits);

} else if (numBits == 32) {

return goog.math.Long.fromBits(high, 0);

} else {

return goog.math.Long.fromBits(high >>> (numBits - 32), 0);

}

}

};

//======= begin jsbn =======

var navigator = { appName: 'Modern Browser' }; // polyfill a little

// Copyright (c) 2005 Tom Wu

// All Rights Reserved.

// http://www-cs-students.stanford.edu/~tjw/jsbn/

/*

* Copyright (c) 2003-2005 Tom Wu

* All Rights Reserved.

*

* Permission is hereby granted, free of charge, to any person obtaining

* a copy of this software and associated documentation files (the

* "Software"), to deal in the Software without restriction, including

* without limitation the rights to use, copy, modify, merge, publish,

* distribute, sublicense, and/or sell copies of the Software, and to

* permit persons to whom the Software is furnished to do so, subject to

* the following conditions:

*

* The above copyright notice and this permission notice shall be

* included in all copies or substantial portions of the Software.

*

* THE SOFTWARE IS PROVIDED "AS-IS" AND WITHOUT WARRANTY OF ANY KIND,

* EXPRESS, IMPLIED OR OTHERWISE, INCLUDING WITHOUT LIMITATION, ANY

* WARRANTY OF MERCHANTABILITY OR FITNESS FOR A PARTICULAR PURPOSE.

*

* IN NO EVENT SHALL TOM WU BE LIABLE FOR ANY SPECIAL, INCIDENTAL,

* INDIRECT OR CONSEQUENTIAL DAMAGES OF ANY KIND, OR ANY DAMAGES WHATSOEVER

* RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER OR NOT ADVISED OF

* THE POSSIBILITY OF DAMAGE, AND ON ANY THEORY OF LIABILITY, ARISING OUT

* OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.

*

* In addition, the following condition applies:

*

* All redistributions must retain an intact copy of this copyright notice

* and disclaimer.

*/

// Basic JavaScript BN library - subset useful for RSA encryption.

// Bits per digit

var dbits;

// JavaScript engine analysis

var canary = 0xdeadbeefcafe;

var j_lm = ((canary&0xffffff)==0xefcafe);

// (public) Constructor

function BigInteger(a,b,c) {

if(a != null)

if("number" == typeof a) this.fromNumber(a,b,c);

else if(b == null && "string" != typeof a) this.fromString(a,256);

else this.fromString(a,b);

}

// return new, unset BigInteger

function nbi() { return new BigInteger(null); }

// am: Compute w_j += (x*this_i), propagate carries,

// c is initial carry, returns final carry.

// c < 3*dvalue, x < 2*dvalue, this_i < dvalue

// We need to select the fastest one that works in this environment.

// am1: use a single mult and divide to get the high bits,

// max digit bits should be 26 because

// max internal value = 2*dvalue^2-2*dvalue (< 2^53)

function am1(i,x,w,j,c,n) {

while(--n >= 0) {

var v = x*this[i++]+w[j]+c;

c = Math.floor(v/0x4000000);

w[j++] = v&0x3ffffff;

}

return c;

}

// am2 avoids a big mult-and-extract completely.

// Max digit bits should be <= 30 because we do bitwise ops

// on values up to 2*hdvalue^2-hdvalue-1 (< 2^31)

function am2(i,x,w,j,c,n) {

var xl = x&0x7fff, xh = x>>15;

while(--n >= 0) {

var l = this[i]&0x7fff;

var h = this[i++]>>15;

var m = xh*l+h*xl;

l = xl*l+((m&0x7fff)<<15)+w[j]+(c&0x3fffffff);

c = (l>>>30)+(m>>>15)+xh*h+(c>>>30);

w[j++] = l&0x3fffffff;

}

return c;

}

// Alternately, set max digit bits to 28 since some

// browsers slow down when dealing with 32-bit numbers.

function am3(i,x,w,j,c,n) {

var xl = x&0x3fff, xh = x>>14;

while(--n >= 0) {

var l = this[i]&0x3fff;

var h = this[i++]>>14;

var m = xh*l+h*xl;

l = xl*l+((m&0x3fff)<<14)+w[j]+c;

c = (l>>28)+(m>>14)+xh*h;

w[j++] = l&0xfffffff;

}

return c;

}

if(j_lm && (navigator.appName == "Microsoft Internet Explorer")) {

BigInteger.prototype.am = am2;

dbits = 30;

}

else if(j_lm && (navigator.appName != "Netscape")) {

BigInteger.prototype.am = am1;

dbits = 26;

}

else { // Mozilla/Netscape seems to prefer am3

BigInteger.prototype.am = am3;

dbits = 28;

}

BigInteger.prototype.DB = dbits;

BigInteger.prototype.DM = ((1<<dbits)-1);

BigInteger.prototype.DV = (1<<dbits);

var BI_FP = 52;

BigInteger.prototype.FV = Math.pow(2,BI_FP);

BigInteger.prototype.F1 = BI_FP-dbits;

BigInteger.prototype.F2 = 2*dbits-BI_FP;

// Digit conversions

var BI_RM = "0123456789abcdefghijklmnopqrstuvwxyz";

var BI_RC = new Array();

var rr,vv;

rr = "0".charCodeAt(0);

for(vv = 0; vv <= 9; ++vv) BI_RC[rr++] = vv;

rr = "a".charCodeAt(0);

for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;

rr = "A".charCodeAt(0);

for(vv = 10; vv < 36; ++vv) BI_RC[rr++] = vv;

function int2char(n) { return BI_RM.charAt(n); }

function intAt(s,i) {

var c = BI_RC[s.charCodeAt(i)];

return (c==null)?-1:c;

}

// (protected) copy this to r

function bnpCopyTo(r) {

for(var i = this.t-1; i >= 0; --i) r[i] = this[i];

r.t = this.t;

r.s = this.s;

}

// (protected) set from integer value x, -DV <= x < DV

function bnpFromInt(x) {

this.t = 1;

this.s = (x<0)?-1:0;

if(x > 0) this[0] = x;

else if(x < -1) this[0] = x+DV;

else this.t = 0;

}

// return bigint initialized to value

function nbv(i) { var r = nbi(); r.fromInt(i); return r; }

// (protected) set from string and radix

function bnpFromString(s,b) {

var k;

if(b == 16) k = 4;

else if(b == 8) k = 3;

else if(b == 256) k = 8; // byte array

else if(b == 2) k = 1;

else if(b == 32) k = 5;

else if(b == 4) k = 2;

else { this.fromRadix(s,b); return; }

this.t = 0;

this.s = 0;

var i = s.length, mi = false, sh = 0;

while(--i >= 0) {

var x = (k==8)?s[i]&0xff:intAt(s,i);

if(x < 0) {

if(s.charAt(i) == "-") mi = true;

continue;

}

mi = false;

if(sh == 0)

this[this.t++] = x;

else if(sh+k > this.DB) {

this[this.t-1] |= (x&((1<<(this.DB-sh))-1))<<sh;

this[this.t++] = (x>>(this.DB-sh));

}

else

this[this.t-1] |= x<<sh;

sh += k;

if(sh >= this.DB) sh -= this.DB;

}

if(k == 8 && (s[0]&0x80) != 0) {