remove electron-in-page-search

app/node_modules/cuint/.npmignore

@@ -0,0 +1 @@
+node_modules/

app/node_modules/cuint/History.md

@@ -0,0 +1,74 @@
+0.2.2 / 2016-08-23
+==================
+
+* merged pull request c5f32fa from vote539
+
+0.2.1 / 2015-12-18
+==================
+
+* fixed issue #3: invalid remainder in x.div(y) where y > x -- thanks @bltpanda
+
+0.2.0 / 2015-01-05
+==================
+
+* merged pull request c6d1c41 from tec27
+* updated package.json file
+
+0.1.5 / 2014-03-21
+==================
+
+* fixed bug in uint32.div()
+
+0.1.3 / 2014-03-08
+==================
+
+* minor tweaks to shiftr()
+
+0.1.3 / 2014-03-06
+==================
+
+* #div() always sets the remainder
+
+0.1.2 / 2014-01-17
+==================
+
+* fix for uint64.fromString(36) substring param
+
+0.1.1 / 2014-01-04
+==================
+
+* faster uint32.fromString()
+* fix for uint64.div()
+* adjusted toString() to handle max radix of 36
+* added minified versions in build/
+* updated README
+
+0.1.0 / 2014-01-03
+==================
+
+* added support for unsigned 64 bits integers
+
+0.0.3 / 2014-01-02
+==================
+
+* shiftLeft() and shiftRight() fixes when n > 16
+* not() fix
+* adjusted fromString() slice from 8 to 6 to avoid radix overflow
+
+0.0.2 / 2014-01-02
+==================
+
+* 1.div() fix
+
+0.0.1 / 2014-01-01
+==================
+
+* toString() fix for uint < radix
+* toString() no longer alters the unsigned integer
+* fixed shiftLeft() not applying mask properly, affecting toString() and div()
+* added examples
+
+0.0.0 / 2013-12-31
+==================
+
+* Initial release (only supports 32 bits uint)

app/node_modules/cuint/README.md

@@ -0,0 +1,205 @@
+# C-like unsigned integers for Javascript
+
+## Synopsis
+
+Javascript does not natively support handling of unsigned 32 or 64 bits integers. This library provides that functionality, following C behaviour, enabling the writing of algorithms that depend on it. It was designed with performance in mind and tries its best to be as fast as possible. Any improvement is welcome!
+
+
+## How it works
+
+An unsigned 32 bits integer is represented by an object with its first 16 bits (low bits) and its 16 last ones (high bits). All the supported standard operations on the unsigned integer are then performed transparently.
+
+	e.g.
+	10000010000100000100010000100010 (2182104098 or 0x82104422) is represented by:
+	high=1000001000010000
+	low= 0100010000100010
+
+NB.
+In case of overflow, the unsigned integer is _truncated_ to its lowest 32 bits (in case of UINT32) or 64  bits (in case of UINT64).
+
+The same applies to 64 bits integers, which are split into 4 16 bits ones.
+
+## Installation
+
+In nodejs:
+
+    npm install cuint
+
+In the browser, include the following (file is located in the _build_ directory), and access the constructor with _UINT32_:
+
+`<script src="/your/path/to/uint32.js"></script>
+...
+<script type="text/javascript">
+  var v1 = UINT32('326648991');
+  var v2 = UINT32('265443576');
+  var v1plus2 = v1.add(v2) // 592092567
+</script>`
+
+## Usage
+
+To instantiate an unsigned 32 bits integer, do any of the following:
+
+	var UINT32 = require('cuint').UINT32 // NodeJS
+	UINT32( <low bits>, <high bits> )
+	UINT32( <number> )
+	UINT32( '<number>', <radix> ) // radix = 10 by default
+
+To instantiate an unsigned 64 bits integer, do any of the following:
+
+	var UINT64 = require('cuint').UINT64 // NodeJS
+	UINT64( <low bits>, <high bits> )
+	UINT64( <first low bits>, <second low bits>, <first high bits>, <second high bits> )
+	UINT64( <number> )
+	UINT64( '<number>', <radix> ) // radix = 10 by default
+
+## Important
+
+Most methods __do modify__ the object they are applied to. For instance, the following is equivalent to `x += y`
+
+	UINT(x).add( UINT(y) )
+
+This allows for chaining and reduces the cost of the emulation.
+To have `z = x + y`, do the following:
+
+    z = UINT(x).clone().add( UINT(y) )
+
+## Examples for UINT32
+
+* Using low and high bits
+> `UINT32( 2, 1 )		// 65538`
+> { remainder: null, _low: 2, _high: 1 }
+
+* Using a number (signed 32 bits integer)
+> `UINT32( 65538 ) 	// 65538`
+> { remainder: null, _low: 2, _high: 1 }
+
+* Using a string
+> `UINT32( '65538' )	// 65538`
+> { remainder: null, _low: 2, _high: 1 }
+
+* Using another string
+> `UINT32( '3266489917' )`
+> { remainder: null, _low: 44605, _high: 49842 }
+
+* Divide 2 unsigned 32 bits integers - note that the remainder is also provided
+> `UINT32( '3266489917' ).div( UINT32( '668265263' ) )`
+> {	remainder:
+>			{	remainder: null
+>			,	_low: 385
+>			,	_high: 9055
+>			}
+>	,	_low: 4
+>	,	_high: 0
+>	}
+
+## Examples for UINT64
+
+* Using low and high bits
+> `UINT64( 2, 1 )		// 4294967298`
+> { remainder: null, _a00: 2, _a16: 0, _a32: 1, _a48: 0 }
+
+* Using first/second low and high bits
+> `UINT64( 2, 1, 0, 0 )		// 65538`
+> { remainder: null, _a00: 2, _a16: 1, _a32: 0, _a48: 0 }
+
+* Using a number (signed 32 bits integer)
+> `UINT64( 65538 ) 	// 65538`
+> { remainder: null, _a00: 2, _a16: 1, _a32: 0, _a48: 0 }
+
+* Using a string
+> `UINT64( '65538' )	// 65538`
+> { remainder: null, _a00: 2, _a16: 1, _a32: 0, _a48: 0 }
+
+* Using another string
+> `UINT64( '3266489917' )`
+> { remainder: null, _a00: 44605, _a16: 49842, _a32: 0, _a48: 0 }
+
+* Divide 2 unsigned 64 bits integers - note that the remainder is also provided
+> `UINT64( 'F00000000000', 16 ).div( UINT64( '800000000000', 16 ) )`
+> { remainder: 
+>   { remainder: null,
+>     _a00: 0,
+>     _a16: 0,
+>     _a32: 28672,
+>     _a48: 0 },
+>  _a00: 1,
+>  _a16: 0,
+>  _a32: 0,
+>  _a48: 0 }
+
+## Methods
+
+Methods specific to _UINT32_ and _UINT64_:
+
+* `UINT32.fromBits(<low bits>, <high bits>)*`
+Set the current _UINT32_ object with its low and high bits
+* `UINT64.fromBits(<low bits>, <high bits>)*`
+Set the current _UINT64_ object with its low and high bits
+* `UINT64.fromBits(<first low bits>, <second low bits>, <first high bits>, <second high bits>)*`
+Set the current _UINT64_ object with all its low and high bits
+
+Methods common to _UINT32_ and _UINT64_:
+
+* `UINT.fromNumber(<number>)*`
+Set the current _UINT_ object from a number (first 32 bits only)
+* `UINT.fromString(<string>, <radix>)`
+Set the current _UINT_ object from a string
+* `UINT.toNumber()`
+Convert this _UINT_ to a number
+* `UINT.toString(<radix>)`
+Convert this _UINT_ to a string
+* `UINT.add(<uint>)*`
+Add two _UINT_. The current _UINT_ stores the result
+* `UINT.subtract(<uint>)*`
+Subtract two _UINT_. The current _UINT_ stores the result
+* `UINT.multiply(<uint>)*`
+Multiply two _UINT_. The current _UINT_ stores the result
+* `UINT.div(<uint>)*`
+Divide two _UINT_. The current _UINT_ stores the result.
+The remainder is made available as the _remainder_ property on the _UINT_ object.
+It can be null, meaning there are no remainder.
+* `UINT.negate()`
+Negate the current _UINT_
+* `UINT.equals(<uint>)` alias `UINT.eq(<uint>)`
+Equals
+* `UINT.lessThan(<uint>)` alias `UINT.lt(<uint>)`
+Less than (strict)
+* `UINT.greaterThan(<uint>)` alias `UINT.gt(<uint>)`
+Greater than (strict)
+* `UINT.not()`
+Bitwise NOT
+* `UINT.or(<uint>)*`
+Bitwise OR
+* `UINT.and(<uint>)*`
+Bitwise AND
+* `UINT.xor(<uint>)*`
+Bitwise XOR
+* `UINT.shiftRight(<number>)*` alias `UINT.shiftr(<number>)*`
+Bitwise shift right
+* `UINT.shiftLeft(<number>[, <allowOverflow>])*` alias `UINT.shiftl(<number>[, <allowOverflow>])*`
+Bitwise shift left
+* `UINT.rotateLeft(<number>)*` alias `UINT.rotl(<number>)*`
+Bitwise rotate left
+* `UINT.rotateRight(<number>)*` alias `UINT.rotr(<number>)*`
+Bitwise rotate right
+* `UINT.clone()`
+Clone the current _UINT_
+
+NB. methods with an * do __modify__ the object it is applied to. Input objects are not modified.
+
+## TODO
+
+* more methods:
+    * pow
+    * log
+    * sqrt
+    * ...
+* signed version
+
+
+## License
+
+MIT
+
+
+> Written with [StackEdit](https://stackedit.io/).

app/node_modules/cuint/build.js

@@ -0,0 +1,16 @@
+var fs = require('fs')
+var path = require('path')
+var minify = require('minify')
+
+minify.optimize('lib/uint32.js', { returnName: true, callback: save('build/uint32.min.js') })
+fs.writeFileSync( 'build/uint32.js', fs.readFileSync('lib/uint32.js') )
+
+minify.optimize('lib/uint64.js', { returnName: true, callback: save('build/uint64.min.js') })
+fs.writeFileSync( 'build/uint64.js', fs.readFileSync('lib/uint64.js') )
+
+function save (filename) {
+	return function (p) {
+		console.log('Renaming ' + path.basename(p.name) + ' to ' + filename)
+		fs.renameSync( p.name, filename )
+	}
+}

app/node_modules/cuint/build/uint32.js

@@ -0,0 +1,451 @@
+/**
+	C-like unsigned 32 bits integers in Javascript
+	Copyright (C) 2013, Pierre Curto
+	MIT license
+ */
+;(function (root) {
+
+	// Local cache for typical radices
+	var radixPowerCache = {
+		36: UINT32( Math.pow(36, 5) )
+	,	16: UINT32( Math.pow(16, 7) )
+	,	10: UINT32( Math.pow(10, 9) )
+	,	2:  UINT32( Math.pow(2, 30) )
+	}
+	var radixCache = {
+		36: UINT32(36)
+	,	16: UINT32(16)
+	,	10: UINT32(10)
+	,	2:  UINT32(2)
+	}
+
+	/**
+	 *	Represents an unsigned 32 bits integer
+	 * @constructor
+	 * @param {Number|String|Number} low bits     | integer as a string 		 | integer as a number
+	 * @param {Number|Number|Undefined} high bits | radix (optional, default=10)
+	 * @return 
+	 */
+	function UINT32 (l, h) {
+		if ( !(this instanceof UINT32) )
+			return new UINT32(l, h)
+
+		this._low = 0
+		this._high = 0
+		this.remainder = null
+		if (typeof h == 'undefined')
+			return fromNumber.call(this, l)
+
+		if (typeof l == 'string')
+			return fromString.call(this, l, h)
+
+		fromBits.call(this, l, h)
+	}
+
+	/**
+	 * Set the current _UINT32_ object with its low and high bits
+	 * @method fromBits
+	 * @param {Number} low bits
+	 * @param {Number} high bits
+	 * @return ThisExpression
+	 */
+	function fromBits (l, h) {
+		this._low = l | 0
+		this._high = h | 0
+
+		return this
+	}
+	UINT32.prototype.fromBits = fromBits
+
+	/**
+	 * Set the current _UINT32_ object from a number
+	 * @method fromNumber
+	 * @param {Number} number
+	 * @return ThisExpression
+	 */
+	function fromNumber (value) {
+		this._low = value & 0xFFFF
+		this._high = value >>> 16
+
+		return this
+	}
+	UINT32.prototype.fromNumber = fromNumber
+
+	/**
+	 * Set the current _UINT32_ object from a string
+	 * @method fromString
+	 * @param {String} integer as a string
+	 * @param {Number} radix (optional, default=10)
+	 * @return ThisExpression
+	 */
+	function fromString (s, radix) {
+		var value = parseInt(s, radix || 10)
+
+		this._low = value & 0xFFFF
+		this._high = value >>> 16
+
+		return this
+	}
+	UINT32.prototype.fromString = fromString
+
+	/**
+	 * Convert this _UINT32_ to a number
+	 * @method toNumber
+	 * @return {Number} the converted UINT32
+	 */
+	UINT32.prototype.toNumber = function () {
+		return (this._high * 65536) + this._low
+	}
+
+	/**
+	 * Convert this _UINT32_ to a string
+	 * @method toString
+	 * @param {Number} radix (optional, default=10)
+	 * @return {String} the converted UINT32
+	 */
+	UINT32.prototype.toString = function (radix) {
+		return this.toNumber().toString(radix || 10)
+	}
+
+	/**
+	 * Add two _UINT32_. The current _UINT32_ stores the result
+	 * @method add
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.add = function (other) {
+		var a00 = this._low + other._low
+		var a16 = a00 >>> 16
+
+		a16 += this._high + other._high
+
+		this._low = a00 & 0xFFFF
+		this._high = a16 & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Subtract two _UINT32_. The current _UINT32_ stores the result
+	 * @method subtract
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.subtract = function (other) {
+		//TODO inline
+		return this.add( other.clone().negate() )
+	}
+
+	/**
+	 * Multiply two _UINT32_. The current _UINT32_ stores the result
+	 * @method multiply
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.multiply = function (other) {
+		/*
+			a = a00 + a16
+			b = b00 + b16
+			a*b = (a00 + a16)(b00 + b16)
+				= a00b00 + a00b16 + a16b00 + a16b16
+
+			a16b16 overflows the 32bits
+		 */
+		var a16 = this._high
+		var a00 = this._low
+		var b16 = other._high
+		var b00 = other._low
+
+/* Removed to increase speed under normal circumstances (i.e. not multiplying by 0 or 1)
+		// this == 0 or other == 1: nothing to do
+		if ((a00 == 0 && a16 == 0) || (b00 == 1 && b16 == 0)) return this
+
+		// other == 0 or this == 1: this = other
+		if ((b00 == 0 && b16 == 0) || (a00 == 1 && a16 == 0)) {
+			this._low = other._low
+			this._high = other._high
+			return this
+		}
+*/
+
+		var c16, c00
+		c00 = a00 * b00
+		c16 = c00 >>> 16
+
+		c16 += a16 * b00
+		c16 &= 0xFFFF		// Not required but improves performance
+		c16 += a00 * b16
+
+		this._low = c00 & 0xFFFF
+		this._high = c16 & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Divide two _UINT32_. The current _UINT32_ stores the result.
+	 * The remainder is made available as the _remainder_ property on
+	 * the _UINT32_ object. It can be null, meaning there are no remainder.
+	 * @method div
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.div = function (other) {
+		if ( (other._low == 0) && (other._high == 0) ) throw Error('division by zero')
+
+		// other == 1
+		if (other._high == 0 && other._low == 1) {
+			this.remainder = new UINT32(0)
+			return this
+		}
+
+		// other > this: 0
+		if ( other.gt(this) ) {
+			this.remainder = this.clone()
+			this._low = 0
+			this._high = 0
+			return this
+		}
+		// other == this: 1
+		if ( this.eq(other) ) {
+			this.remainder = new UINT32(0)
+			this._low = 1
+			this._high = 0
+			return this
+		}
+
+		// Shift the divisor left until it is higher than the dividend
+		var _other = other.clone()
+		var i = -1
+		while ( !this.lt(_other) ) {
+			// High bit can overflow the default 16bits
+			// Its ok since we right shift after this loop
+			// The overflown bit must be kept though
+			_other.shiftLeft(1, true)
+			i++
+		}
+
+		// Set the remainder
+		this.remainder = this.clone()
+		// Initialize the current result to 0
+		this._low = 0
+		this._high = 0
+		for (; i >= 0; i--) {
+			_other.shiftRight(1)
+			// If shifted divisor is smaller than the dividend
+			// then subtract it from the dividend
+			if ( !this.remainder.lt(_other) ) {
+				this.remainder.subtract(_other)
+				// Update the current result
+				if (i >= 16) {
+					this._high |= 1 << (i - 16)
+				} else {
+					this._low |= 1 << i
+				}
+			}
+		}
+
+		return this
+	}
+
+	/**
+	 * Negate the current _UINT32_
+	 * @method negate
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.negate = function () {
+		var v = ( ~this._low & 0xFFFF ) + 1
+		this._low = v & 0xFFFF
+		this._high = (~this._high + (v >>> 16)) & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Equals
+	 * @method eq
+	 * @param {Object} other UINT32
+	 * @return {Boolean}
+	 */
+	UINT32.prototype.equals = UINT32.prototype.eq = function (other) {
+		return (this._low == other._low) && (this._high == other._high)
+	}
+
+	/**
+	 * Greater than (strict)
+	 * @method gt
+	 * @param {Object} other UINT32
+	 * @return {Boolean}
+	 */
+	UINT32.prototype.greaterThan = UINT32.prototype.gt = function (other) {
+		if (this._high > other._high) return true
+		if (this._high < other._high) return false
+		return this._low > other._low
+	}
+
+	/**
+	 * Less than (strict)
+	 * @method lt
+	 * @param {Object} other UINT32
+	 * @return {Boolean}
+	 */
+	UINT32.prototype.lessThan = UINT32.prototype.lt = function (other) {
+		if (this._high < other._high) return true
+		if (this._high > other._high) return false
+		return this._low < other._low
+	}
+
+	/**
+	 * Bitwise OR
+	 * @method or
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.or = function (other) {
+		this._low |= other._low
+		this._high |= other._high
+
+		return this
+	}
+
+	/**
+	 * Bitwise AND
+	 * @method and
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.and = function (other) {
+		this._low &= other._low
+		this._high &= other._high
+
+		return this
+	}
+
+	/**
+	 * Bitwise NOT
+	 * @method not
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.not = function() {
+		this._low = ~this._low & 0xFFFF
+		this._high = ~this._high & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Bitwise XOR
+	 * @method xor
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.xor = function (other) {
+		this._low ^= other._low
+		this._high ^= other._high
+
+		return this
+	}
+
+	/**
+	 * Bitwise shift right
+	 * @method shiftRight
+	 * @param {Number} number of bits to shift
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.shiftRight = UINT32.prototype.shiftr = function (n) {
+		if (n > 16) {
+			this._low = this._high >> (n - 16)
+			this._high = 0
+		} else if (n == 16) {
+			this._low = this._high
+			this._high = 0
+		} else {
+			this._low = (this._low >> n) | ( (this._high << (16-n)) & 0xFFFF )
+			this._high >>= n
+		}
+
+		return this
+	}
+
+	/**
+	 * Bitwise shift left
+	 * @method shiftLeft
+	 * @param {Number} number of bits to shift
+	 * @param {Boolean} allow overflow
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.shiftLeft = UINT32.prototype.shiftl = function (n, allowOverflow) {
+		if (n > 16) {
+			this._high = this._low << (n - 16)
+			this._low = 0
+			if (!allowOverflow) {
+				this._high &= 0xFFFF
+			}
+		} else if (n == 16) {
+			this._high = this._low
+			this._low = 0
+		} else {
+			this._high = (this._high << n) | (this._low >> (16-n))
+			this._low = (this._low << n) & 0xFFFF
+			if (!allowOverflow) {
+				// Overflow only allowed on the high bits...
+				this._high &= 0xFFFF
+			}
+		}
+
+		return this
+	}
+
+	/**
+	 * Bitwise rotate left
+	 * @method rotl
+	 * @param {Number} number of bits to rotate
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.rotateLeft = UINT32.prototype.rotl = function (n) {
+		var v = (this._high << 16) | this._low
+		v = (v << n) | (v >>> (32 - n))
+		this._low = v & 0xFFFF
+		this._high = v >>> 16
+
+		return this
+	}
+
+	/**
+	 * Bitwise rotate right
+	 * @method rotr
+	 * @param {Number} number of bits to rotate
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.rotateRight = UINT32.prototype.rotr = function (n) {
+		var v = (this._high << 16) | this._low
+		v = (v >>> n) | (v << (32 - n))
+		this._low = v & 0xFFFF
+		this._high = v >>> 16
+
+		return this
+	}
+
+	/**
+	 * Clone the current _UINT32_
+	 * @method clone
+	 * @return {Object} cloned UINT32
+	 */
+	UINT32.prototype.clone = function () {
+		return new UINT32(this._low, this._high)
+	}
+
+	if (typeof define != 'undefined' && define.amd) {
+		// AMD / RequireJS
+		define([], function () {
+			return UINT32
+		})
+	} else if (typeof module != 'undefined' && module.exports) {
+		// Node.js
+		module.exports = UINT32
+	} else {
+		// Browser
+		root['UINT32'] = UINT32
+	}
+
+})(this)

app/node_modules/cuint/build/uint32.min.js

@@ -0,0 +1 @@
+!function(t){function h(t,s){return this instanceof h?(this._low=0,this._high=0,this.remainder=null,"undefined"==typeof s?o.call(this,t):"string"==typeof t?r.call(this,t,s):void i.call(this,t,s)):new h(t,s)}function i(t,h){return this._low=0|t,this._high=0|h,this}function o(t){return this._low=65535&t,this._high=t>>>16,this}function r(t,h){var i=parseInt(t,h||10);return this._low=65535&i,this._high=i>>>16,this}({36:h(Math.pow(36,5)),16:h(Math.pow(16,7)),10:h(Math.pow(10,9)),2:h(Math.pow(2,30))}),{36:h(36),16:h(16),10:h(10),2:h(2)};h.prototype.fromBits=i,h.prototype.fromNumber=o,h.prototype.fromString=r,h.prototype.toNumber=function(){return 65536*this._high+this._low},h.prototype.toString=function(t){return this.toNumber().toString(t||10)},h.prototype.add=function(t){var h=this._low+t._low,i=h>>>16;return i+=this._high+t._high,this._low=65535&h,this._high=65535&i,this},h.prototype.subtract=function(t){return this.add(t.clone().negate())},h.prototype.multiply=function(t){var h,i,o=this._high,r=this._low,s=t._high,e=t._low;return i=r*e,h=i>>>16,h+=o*e,h&=65535,h+=r*s,this._low=65535&i,this._high=65535&h,this},h.prototype.div=function(t){if(0==t._low&&0==t._high)throw Error("division by zero");if(0==t._high&&1==t._low)return this.remainder=new h(0),this;if(t.gt(this))return this.remainder=this.clone(),this._low=0,this._high=0,this;if(this.eq(t))return this.remainder=new h(0),this._low=1,this._high=0,this;for(var i=t.clone(),o=-1;!this.lt(i);)i.shiftLeft(1,!0),o++;for(this.remainder=this.clone(),this._low=0,this._high=0;o>=0;o--)i.shiftRight(1),this.remainder.lt(i)||(this.remainder.subtract(i),o>=16?this._high|=1<<o-16:this._low|=1<<o);return this},h.prototype.negate=function(){var t=(65535&~this._low)+1;return this._low=65535&t,this._high=~this._high+(t>>>16)&65535,this},h.prototype.equals=h.prototype.eq=function(t){return this._low==t._low&&this._high==t._high},h.prototype.greaterThan=h.prototype.gt=function(t){return this._high>t._high?!0:this._high<t._high?!1:this._low>t._low},h.prototype.lessThan=h.prototype.lt=function(t){return this._high<t._high?!0:this._high>t._high?!1:this._low<t._low},h.prototype.or=function(t){return this._low|=t._low,this._high|=t._high,this},h.prototype.and=function(t){return this._low&=t._low,this._high&=t._high,this},h.prototype.not=function(){return this._low=65535&~this._low,this._high=65535&~this._high,this},h.prototype.xor=function(t){return this._low^=t._low,this._high^=t._high,this},h.prototype.shiftRight=h.prototype.shiftr=function(t){return t>16?(this._low=this._high>>t-16,this._high=0):16==t?(this._low=this._high,this._high=0):(this._low=this._low>>t|this._high<<16-t&65535,this._high>>=t),this},h.prototype.shiftLeft=h.prototype.shiftl=function(t,h){return t>16?(this._high=this._low<<t-16,this._low=0,h||(this._high&=65535)):16==t?(this._high=this._low,this._low=0):(this._high=this._high<<t|this._low>>16-t,this._low=this._low<<t&65535,h||(this._high&=65535)),this},h.prototype.rotateLeft=h.prototype.rotl=function(t){var h=this._high<<16|this._low;return h=h<<t|h>>>32-t,this._low=65535&h,this._high=h>>>16,this},h.prototype.rotateRight=h.prototype.rotr=function(t){var h=this._high<<16|this._low;return h=h>>>t|h<<32-t,this._low=65535&h,this._high=h>>>16,this},h.prototype.clone=function(){return new h(this._low,this._high)},"undefined"!=typeof define&&define.amd?define([],function(){return h}):"undefined"!=typeof module&&module.exports?module.exports=h:t.UINT32=h}(this);

app/node_modules/cuint/build/uint64.js

@@ -0,0 +1,648 @@
+/**
+	C-like unsigned 64 bits integers in Javascript
+	Copyright (C) 2013, Pierre Curto
+	MIT license
+ */
+;(function (root) {
+
+	// Local cache for typical radices
+	var radixPowerCache = {
+		16: UINT64( Math.pow(16, 5) )
+	,	10: UINT64( Math.pow(10, 5) )
+	,	2:  UINT64( Math.pow(2, 5) )
+	}
+	var radixCache = {
+		16: UINT64(16)
+	,	10: UINT64(10)
+	,	2:  UINT64(2)
+	}
+
+	/**
+	 *	Represents an unsigned 64 bits integer
+	 * @constructor
+	 * @param {Number} first low bits (8)
+	 * @param {Number} second low bits (8)
+	 * @param {Number} first high bits (8)
+	 * @param {Number} second high bits (8)
+	 * or
+	 * @param {Number} low bits (32)
+	 * @param {Number} high bits (32)
+	 * or
+	 * @param {String|Number} integer as a string 		 | integer as a number
+	 * @param {Number|Undefined} radix (optional, default=10)
+	 * @return 
+	 */
+	function UINT64 (a00, a16, a32, a48) {
+		if ( !(this instanceof UINT64) )
+			return new UINT64(a00, a16, a32, a48)
+
+		this.remainder = null
+		if (typeof a00 == 'string')
+			return fromString.call(this, a00, a16)
+
+		if (typeof a16 == 'undefined')
+			return fromNumber.call(this, a00)
+
+		fromBits.apply(this, arguments)
+	}
+
+	/**
+	 * Set the current _UINT64_ object with its low and high bits
+	 * @method fromBits
+	 * @param {Number} first low bits (8)
+	 * @param {Number} second low bits (8)
+	 * @param {Number} first high bits (8)
+	 * @param {Number} second high bits (8)
+	 * or
+	 * @param {Number} low bits (32)
+	 * @param {Number} high bits (32)
+	 * @return ThisExpression
+	 */
+	function fromBits (a00, a16, a32, a48) {
+		if (typeof a32 == 'undefined') {
+			this._a00 = a00 & 0xFFFF
+			this._a16 = a00 >>> 16
+			this._a32 = a16 & 0xFFFF
+			this._a48 = a16 >>> 16
+			return this
+		}
+
+		this._a00 = a00 | 0
+		this._a16 = a16 | 0
+		this._a32 = a32 | 0
+		this._a48 = a48 | 0
+
+		return this
+	}
+	UINT64.prototype.fromBits = fromBits
+
+	/**
+	 * Set the current _UINT64_ object from a number
+	 * @method fromNumber
+	 * @param {Number} number
+	 * @return ThisExpression
+	 */
+	function fromNumber (value) {
+		this._a00 = value & 0xFFFF
+		this._a16 = value >>> 16
+		this._a32 = 0
+		this._a48 = 0
+
+		return this
+	}
+	UINT64.prototype.fromNumber = fromNumber
+
+	/**
+	 * Set the current _UINT64_ object from a string
+	 * @method fromString
+	 * @param {String} integer as a string
+	 * @param {Number} radix (optional, default=10)
+	 * @return ThisExpression
+	 */
+	function fromString (s, radix) {
+		radix = radix || 10
+
+		this._a00 = 0
+		this._a16 = 0
+		this._a32 = 0
+		this._a48 = 0
+
+		/*
+			In Javascript, bitwise operators only operate on the first 32 bits 
+			of a number, even though parseInt() encodes numbers with a 53 bits 
+			mantissa.
+			Therefore UINT64(<Number>) can only work on 32 bits.
+			The radix maximum value is 36 (as per ECMA specs) (26 letters + 10 digits)
+			maximum input value is m = 32bits as 1 = 2^32 - 1
+			So the maximum substring length n is:
+			36^(n+1) - 1 = 2^32 - 1
+			36^(n+1) = 2^32
+			(n+1)ln(36) = 32ln(2)
+			n = 32ln(2)/ln(36) - 1
+			n = 5.189644915687692
+			n = 5
+		 */
+		var radixUint = radixPowerCache[radix] || new UINT64( Math.pow(radix, 5) )
+
+		for (var i = 0, len = s.length; i < len; i += 5) {
+			var size = Math.min(5, len - i)
+			var value = parseInt( s.slice(i, i + size), radix )
+			this.multiply(
+					size < 5
+						? new UINT64( Math.pow(radix, size) )
+						: radixUint
+				)
+				.add( new UINT64(value) )
+		}
+
+		return this
+	}
+	UINT64.prototype.fromString = fromString
+
+	/**
+	 * Convert this _UINT64_ to a number (last 32 bits are dropped)
+	 * @method toNumber
+	 * @return {Number} the converted UINT64
+	 */
+	UINT64.prototype.toNumber = function () {
+		return (this._a16 * 65536) + this._a00
+	}
+
+	/**
+	 * Convert this _UINT64_ to a string
+	 * @method toString
+	 * @param {Number} radix (optional, default=10)
+	 * @return {String} the converted UINT64
+	 */
+	UINT64.prototype.toString = function (radix) {
+		radix = radix || 10
+		var radixUint = radixCache[radix] || new UINT64(radix)
+
+		if ( !this.gt(radixUint) ) return this.toNumber().toString(radix)
+
+		var self = this.clone()
+		var res = new Array(64)
+		for (var i = 63; i >= 0; i--) {
+			self.div(radixUint)
+			res[i] = self.remainder.toNumber().toString(radix)
+			if ( !self.gt(radixUint) ) break
+		}
+		res[i-1] = self.toNumber().toString(radix)
+
+		return res.join('')
+	}
+
+	/**
+	 * Add two _UINT64_. The current _UINT64_ stores the result
+	 * @method add
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.add = function (other) {
+		var a00 = this._a00 + other._a00
+
+		var a16 = a00 >>> 16
+		a16 += this._a16 + other._a16
+
+		var a32 = a16 >>> 16
+		a32 += this._a32 + other._a32
+
+		var a48 = a32 >>> 16
+		a48 += this._a48 + other._a48
+
+		this._a00 = a00 & 0xFFFF
+		this._a16 = a16 & 0xFFFF
+		this._a32 = a32 & 0xFFFF
+		this._a48 = a48 & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Subtract two _UINT64_. The current _UINT64_ stores the result
+	 * @method subtract
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.subtract = function (other) {
+		return this.add( other.clone().negate() )
+	}
+
+	/**
+	 * Multiply two _UINT64_. The current _UINT64_ stores the result
+	 * @method multiply
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.multiply = function (other) {
+		/*
+			a = a00 + a16 + a32 + a48
+			b = b00 + b16 + b32 + b48
+			a*b = (a00 + a16 + a32 + a48)(b00 + b16 + b32 + b48)
+				= a00b00 + a00b16 + a00b32 + a00b48
+				+ a16b00 + a16b16 + a16b32 + a16b48
+				+ a32b00 + a32b16 + a32b32 + a32b48
+				+ a48b00 + a48b16 + a48b32 + a48b48
+
+			a16b48, a32b32, a48b16, a48b32 and a48b48 overflow the 64 bits
+			so it comes down to:
+			a*b	= a00b00 + a00b16 + a00b32 + a00b48
+				+ a16b00 + a16b16 + a16b32
+				+ a32b00 + a32b16
+				+ a48b00
+				= a00b00
+				+ a00b16 + a16b00
+				+ a00b32 + a16b16 + a32b00
+				+ a00b48 + a16b32 + a32b16 + a48b00
+		 */
+		var a00 = this._a00
+		var a16 = this._a16
+		var a32 = this._a32
+		var a48 = this._a48
+		var b00 = other._a00
+		var b16 = other._a16
+		var b32 = other._a32
+		var b48 = other._a48
+
+		var c00 = a00 * b00
+
+		var c16 = c00 >>> 16
+		c16 += a00 * b16
+		var c32 = c16 >>> 16
+		c16 &= 0xFFFF
+		c16 += a16 * b00
+
+		c32 += c16 >>> 16
+		c32 += a00 * b32
+		var c48 = c32 >>> 16
+		c32 &= 0xFFFF
+		c32 += a16 * b16
+		c48 += c32 >>> 16
+		c32 &= 0xFFFF
+		c32 += a32 * b00
+
+		c48 += c32 >>> 16
+		c48 += a00 * b48
+		c48 &= 0xFFFF
+		c48 += a16 * b32
+		c48 &= 0xFFFF
+		c48 += a32 * b16
+		c48 &= 0xFFFF
+		c48 += a48 * b00
+
+		this._a00 = c00 & 0xFFFF
+		this._a16 = c16 & 0xFFFF
+		this._a32 = c32 & 0xFFFF
+		this._a48 = c48 & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Divide two _UINT64_. The current _UINT64_ stores the result.
+	 * The remainder is made available as the _remainder_ property on
+	 * the _UINT64_ object. It can be null, meaning there are no remainder.
+	 * @method div
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.div = function (other) {
+		if ( (other._a16 == 0) && (other._a32 == 0) && (other._a48 == 0) ) {
+			if (other._a00 == 0) throw Error('division by zero')
+
+			// other == 1: this
+			if (other._a00 == 1) {
+				this.remainder = new UINT64(0)
+				return this
+			}
+		}
+
+		// other > this: 0
+		if ( other.gt(this) ) {
+			this.remainder = this.clone()
+			this._a00 = 0
+			this._a16 = 0
+			this._a32 = 0
+			this._a48 = 0
+			return this
+		}
+		// other == this: 1
+		if ( this.eq(other) ) {
+			this.remainder = new UINT64(0)
+			this._a00 = 1
+			this._a16 = 0
+			this._a32 = 0
+			this._a48 = 0
+			return this
+		}
+
+		// Shift the divisor left until it is higher than the dividend
+		var _other = other.clone()
+		var i = -1
+		while ( !this.lt(_other) ) {
+			// High bit can overflow the default 16bits
+			// Its ok since we right shift after this loop
+			// The overflown bit must be kept though
+			_other.shiftLeft(1, true)
+			i++
+		}
+
+		// Set the remainder
+		this.remainder = this.clone()
+		// Initialize the current result to 0
+		this._a00 = 0
+		this._a16 = 0
+		this._a32 = 0
+		this._a48 = 0
+		for (; i >= 0; i--) {
+			_other.shiftRight(1)
+			// If shifted divisor is smaller than the dividend
+			// then subtract it from the dividend
+			if ( !this.remainder.lt(_other) ) {
+				this.remainder.subtract(_other)
+				// Update the current result
+				if (i >= 48) {
+					this._a48 |= 1 << (i - 48)
+				} else if (i >= 32) {
+					this._a32 |= 1 << (i - 32)
+				} else if (i >= 16) {
+					this._a16 |= 1 << (i - 16)
+				} else {
+					this._a00 |= 1 << i
+				}
+			}
+		}
+
+		return this
+	}
+
+	/**
+	 * Negate the current _UINT64_
+	 * @method negate
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.negate = function () {
+		var v = ( ~this._a00 & 0xFFFF ) + 1
+		this._a00 = v & 0xFFFF
+		v = (~this._a16 & 0xFFFF) + (v >>> 16)
+		this._a16 = v & 0xFFFF
+		v = (~this._a32 & 0xFFFF) + (v >>> 16)
+		this._a32 = v & 0xFFFF
+		this._a48 = (~this._a48 + (v >>> 16)) & 0xFFFF
+
+		return this
+	}
+
+	/**
+
+	 * @method eq
+	 * @param {Object} other UINT64
+	 * @return {Boolean}
+	 */
+	UINT64.prototype.equals = UINT64.prototype.eq = function (other) {
+		return (this._a48 == other._a48) && (this._a00 == other._a00)
+			 && (this._a32 == other._a32) && (this._a16 == other._a16)
+	}
+
+	/**
+	 * Greater than (strict)
+	 * @method gt
+	 * @param {Object} other UINT64
+	 * @return {Boolean}
+	 */
+	UINT64.prototype.greaterThan = UINT64.prototype.gt = function (other) {
+		if (this._a48 > other._a48) return true
+		if (this._a48 < other._a48) return false
+		if (this._a32 > other._a32) return true
+		if (this._a32 < other._a32) return false
+		if (this._a16 > other._a16) return true
+		if (this._a16 < other._a16) return false
+		return this._a00 > other._a00
+	}
+
+	/**
+	 * Less than (strict)
+	 * @method lt
+	 * @param {Object} other UINT64
+	 * @return {Boolean}
+	 */
+	UINT64.prototype.lessThan = UINT64.prototype.lt = function (other) {
+		if (this._a48 < other._a48) return true
+		if (this._a48 > other._a48) return false
+		if (this._a32 < other._a32) return true
+		if (this._a32 > other._a32) return false
+		if (this._a16 < other._a16) return true
+		if (this._a16 > other._a16) return false
+		return this._a00 < other._a00
+	}
+
+	/**
+	 * Bitwise OR
+	 * @method or
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.or = function (other) {
+		this._a00 |= other._a00
+		this._a16 |= other._a16
+		this._a32 |= other._a32
+		this._a48 |= other._a48
+
+		return this
+	}
+
+	/**
+	 * Bitwise AND
+	 * @method and
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.and = function (other) {
+		this._a00 &= other._a00
+		this._a16 &= other._a16
+		this._a32 &= other._a32
+		this._a48 &= other._a48
+
+		return this
+	}
+
+	/**
+	 * Bitwise XOR
+	 * @method xor
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.xor = function (other) {
+		this._a00 ^= other._a00
+		this._a16 ^= other._a16
+		this._a32 ^= other._a32
+		this._a48 ^= other._a48
+
+		return this
+	}
+
+	/**
+	 * Bitwise NOT
+	 * @method not
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.not = function() {
+		this._a00 = ~this._a00 & 0xFFFF
+		this._a16 = ~this._a16 & 0xFFFF
+		this._a32 = ~this._a32 & 0xFFFF
+		this._a48 = ~this._a48 & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Bitwise shift right
+	 * @method shiftRight
+	 * @param {Number} number of bits to shift
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.shiftRight = UINT64.prototype.shiftr = function (n) {
+		n %= 64
+		if (n >= 48) {
+			this._a00 = this._a48 >> (n - 48)
+			this._a16 = 0
+			this._a32 = 0
+			this._a48 = 0
+		} else if (n >= 32) {
+			n -= 32
+			this._a00 = ( (this._a32 >> n) | (this._a48 << (16-n)) ) & 0xFFFF
+			this._a16 = (this._a48 >> n) & 0xFFFF
+			this._a32 = 0
+			this._a48 = 0
+		} else if (n >= 16) {
+			n -= 16
+			this._a00 = ( (this._a16 >> n) | (this._a32 << (16-n)) ) & 0xFFFF
+			this._a16 = ( (this._a32 >> n) | (this._a48 << (16-n)) ) & 0xFFFF
+			this._a32 = (this._a48 >> n) & 0xFFFF
+			this._a48 = 0
+		} else {
+			this._a00 = ( (this._a00 >> n) | (this._a16 << (16-n)) ) & 0xFFFF
+			this._a16 = ( (this._a16 >> n) | (this._a32 << (16-n)) ) & 0xFFFF
+			this._a32 = ( (this._a32 >> n) | (this._a48 << (16-n)) ) & 0xFFFF
+			this._a48 = (this._a48 >> n) & 0xFFFF
+		}
+
+		return this
+	}
+
+	/**
+	 * Bitwise shift left
+	 * @method shiftLeft
+	 * @param {Number} number of bits to shift
+	 * @param {Boolean} allow overflow
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.shiftLeft = UINT64.prototype.shiftl = function (n, allowOverflow) {
+		n %= 64
+		if (n >= 48) {
+			this._a48 = this._a00 << (n - 48)
+			this._a32 = 0
+			this._a16 = 0
+			this._a00 = 0
+		} else if (n >= 32) {
+			n -= 32
+			this._a48 = (this._a16 << n) | (this._a00 >> (16-n))
+			this._a32 = (this._a00 << n) & 0xFFFF
+			this._a16 = 0
+			this._a00 = 0
+		} else if (n >= 16) {
+			n -= 16
+			this._a48 = (this._a32 << n) | (this._a16 >> (16-n))
+			this._a32 = ( (this._a16 << n) | (this._a00 >> (16-n)) ) & 0xFFFF
+			this._a16 = (this._a00 << n) & 0xFFFF
+			this._a00 = 0
+		} else {
+			this._a48 = (this._a48 << n) | (this._a32 >> (16-n))
+			this._a32 = ( (this._a32 << n) | (this._a16 >> (16-n)) ) & 0xFFFF
+			this._a16 = ( (this._a16 << n) | (this._a00 >> (16-n)) ) & 0xFFFF
+			this._a00 = (this._a00 << n) & 0xFFFF
+		}
+		if (!allowOverflow) {
+			this._a48 &= 0xFFFF
+		}
+
+		return this
+	}
+
+	/**
+	 * Bitwise rotate left
+	 * @method rotl
+	 * @param {Number} number of bits to rotate
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.rotateLeft = UINT64.prototype.rotl = function (n) {
+		n %= 64
+		if (n == 0) return this
+		if (n >= 32) {
+			// A.B.C.D
+			// B.C.D.A rotl(16)
+			// C.D.A.B rotl(32)
+			var v = this._a00
+			this._a00 = this._a32
+			this._a32 = v
+			v = this._a48
+			this._a48 = this._a16
+			this._a16 = v
+			if (n == 32) return this
+			n -= 32
+		}
+
+		var high = (this._a48 << 16) | this._a32
+		var low = (this._a16 << 16) | this._a00
+
+		var _high = (high << n) | (low >>> (32 - n))
+		var _low = (low << n) | (high >>> (32 - n))
+
+		this._a00 = _low & 0xFFFF
+		this._a16 = _low >>> 16
+		this._a32 = _high & 0xFFFF
+		this._a48 = _high >>> 16
+
+		return this
+	}
+
+	/**
+	 * Bitwise rotate right
+	 * @method rotr
+	 * @param {Number} number of bits to rotate
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.rotateRight = UINT64.prototype.rotr = function (n) {
+		n %= 64
+		if (n == 0) return this
+		if (n >= 32) {
+			// A.B.C.D
+			// D.A.B.C rotr(16)
+			// C.D.A.B rotr(32)
+			var v = this._a00
+			this._a00 = this._a32
+			this._a32 = v
+			v = this._a48
+			this._a48 = this._a16
+			this._a16 = v
+			if (n == 32) return this
+			n -= 32
+		}
+
+		var high = (this._a48 << 16) | this._a32
+		var low = (this._a16 << 16) | this._a00
+
+		var _high = (high >>> n) | (low << (32 - n))
+		var _low = (low >>> n) | (high << (32 - n))
+
+		this._a00 = _low & 0xFFFF
+		this._a16 = _low >>> 16
+		this._a32 = _high & 0xFFFF
+		this._a48 = _high >>> 16
+
+		return this
+	}
+
+	/**
+	 * Clone the current _UINT64_
+	 * @method clone
+	 * @return {Object} cloned UINT64
+	 */
+	UINT64.prototype.clone = function () {
+		return new UINT64(this._a00, this._a16, this._a32, this._a48)
+	}
+
+	if (typeof define != 'undefined' && define.amd) {
+		// AMD / RequireJS
+		define([], function () {
+			return UINT64
+		})
+	} else if (typeof module != 'undefined' && module.exports) {
+		// Node.js
+		module.exports = UINT64
+	} else {
+		// Browser
+		root['UINT64'] = UINT64
+	}
+
+})(this)

app/node_modules/cuint/examples/adding.js

@@ -0,0 +1,6 @@
+var UINT32 = require('..').UINT32
+
+var v1 = UINT32('326648991')
+var v2 = UINT32('265443576')
+var v1plus2 = v1.clone().add(v2)
+console.log( v1 + ' + ' + v2 + ' = ' + v1plus2 )

app/node_modules/cuint/examples/dividing.js

@@ -0,0 +1,6 @@
+var UINT32 = require('..').UINT32
+
+var v1 = UINT32('3266489917')
+var v2 = UINT32('668265263')
+var v1div2 = v1.clone().div(v2)
+console.log( v1 + ' / ' + v2 + ' = ' + v1div2 )

app/node_modules/cuint/examples/uint32.html

@@ -0,0 +1,19 @@
+<html>
+<body>
+	<div>
+		<div id='data'></div>
+	</div>
+	<script type="text/javascript" src="../build/uint32.lmd.js"></script>
+	<script type="text/javascript">
+		var v1 = UINT32('326648991')
+		var v2 = UINT32('265443576')
+		var v1plus2 = v1.clone().add(v2)
+		document.getElementById('data').innerHTML += '<p>' + v1 + ' + ' + v2 + ' = ' + v1plus2 + '</p>'
+
+		var v1 = UINT32('3266489917')
+		var v2 = UINT32('668265263')
+		var v1div2 = v1.clone().div(v2)
+		document.getElementById('data').innerHTML += '<p>' + v1 + ' / ' + v2 + ' = ' + v1div2 + '</p>'
+	</script>
+</body>
+</html>

app/node_modules/cuint/index.js

@@ -0,0 +1,2 @@
+exports.UINT32 = require('./lib/uint32')
+exports.UINT64 = require('./lib/uint64')

app/node_modules/cuint/lib/uint32.js

@@ -0,0 +1,451 @@
+/**
+	C-like unsigned 32 bits integers in Javascript
+	Copyright (C) 2013, Pierre Curto
+	MIT license
+ */
+;(function (root) {
+
+	// Local cache for typical radices
+	var radixPowerCache = {
+		36: UINT32( Math.pow(36, 5) )
+	,	16: UINT32( Math.pow(16, 7) )
+	,	10: UINT32( Math.pow(10, 9) )
+	,	2:  UINT32( Math.pow(2, 30) )
+	}
+	var radixCache = {
+		36: UINT32(36)
+	,	16: UINT32(16)
+	,	10: UINT32(10)
+	,	2:  UINT32(2)
+	}
+
+	/**
+	 *	Represents an unsigned 32 bits integer
+	 * @constructor
+	 * @param {Number|String|Number} low bits     | integer as a string 		 | integer as a number
+	 * @param {Number|Number|Undefined} high bits | radix (optional, default=10)
+	 * @return 
+	 */
+	function UINT32 (l, h) {
+		if ( !(this instanceof UINT32) )
+			return new UINT32(l, h)
+
+		this._low = 0
+		this._high = 0
+		this.remainder = null
+		if (typeof h == 'undefined')
+			return fromNumber.call(this, l)
+
+		if (typeof l == 'string')
+			return fromString.call(this, l, h)
+
+		fromBits.call(this, l, h)
+	}
+
+	/**
+	 * Set the current _UINT32_ object with its low and high bits
+	 * @method fromBits
+	 * @param {Number} low bits
+	 * @param {Number} high bits
+	 * @return ThisExpression
+	 */
+	function fromBits (l, h) {
+		this._low = l | 0
+		this._high = h | 0
+
+		return this
+	}
+	UINT32.prototype.fromBits = fromBits
+
+	/**
+	 * Set the current _UINT32_ object from a number
+	 * @method fromNumber
+	 * @param {Number} number
+	 * @return ThisExpression
+	 */
+	function fromNumber (value) {
+		this._low = value & 0xFFFF
+		this._high = value >>> 16
+
+		return this
+	}
+	UINT32.prototype.fromNumber = fromNumber
+
+	/**
+	 * Set the current _UINT32_ object from a string
+	 * @method fromString
+	 * @param {String} integer as a string
+	 * @param {Number} radix (optional, default=10)
+	 * @return ThisExpression
+	 */
+	function fromString (s, radix) {
+		var value = parseInt(s, radix || 10)
+
+		this._low = value & 0xFFFF
+		this._high = value >>> 16
+
+		return this
+	}
+	UINT32.prototype.fromString = fromString
+
+	/**
+	 * Convert this _UINT32_ to a number
+	 * @method toNumber
+	 * @return {Number} the converted UINT32
+	 */
+	UINT32.prototype.toNumber = function () {
+		return (this._high * 65536) + this._low
+	}
+
+	/**
+	 * Convert this _UINT32_ to a string
+	 * @method toString
+	 * @param {Number} radix (optional, default=10)
+	 * @return {String} the converted UINT32
+	 */
+	UINT32.prototype.toString = function (radix) {
+		return this.toNumber().toString(radix || 10)
+	}
+
+	/**
+	 * Add two _UINT32_. The current _UINT32_ stores the result
+	 * @method add
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.add = function (other) {
+		var a00 = this._low + other._low
+		var a16 = a00 >>> 16
+
+		a16 += this._high + other._high
+
+		this._low = a00 & 0xFFFF
+		this._high = a16 & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Subtract two _UINT32_. The current _UINT32_ stores the result
+	 * @method subtract
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.subtract = function (other) {
+		//TODO inline
+		return this.add( other.clone().negate() )
+	}
+
+	/**
+	 * Multiply two _UINT32_. The current _UINT32_ stores the result
+	 * @method multiply
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.multiply = function (other) {
+		/*
+			a = a00 + a16
+			b = b00 + b16
+			a*b = (a00 + a16)(b00 + b16)
+				= a00b00 + a00b16 + a16b00 + a16b16
+
+			a16b16 overflows the 32bits
+		 */
+		var a16 = this._high
+		var a00 = this._low
+		var b16 = other._high
+		var b00 = other._low
+
+/* Removed to increase speed under normal circumstances (i.e. not multiplying by 0 or 1)
+		// this == 0 or other == 1: nothing to do
+		if ((a00 == 0 && a16 == 0) || (b00 == 1 && b16 == 0)) return this
+
+		// other == 0 or this == 1: this = other
+		if ((b00 == 0 && b16 == 0) || (a00 == 1 && a16 == 0)) {
+			this._low = other._low
+			this._high = other._high
+			return this
+		}
+*/
+
+		var c16, c00
+		c00 = a00 * b00
+		c16 = c00 >>> 16
+
+		c16 += a16 * b00
+		c16 &= 0xFFFF		// Not required but improves performance
+		c16 += a00 * b16
+
+		this._low = c00 & 0xFFFF
+		this._high = c16 & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Divide two _UINT32_. The current _UINT32_ stores the result.
+	 * The remainder is made available as the _remainder_ property on
+	 * the _UINT32_ object. It can be null, meaning there are no remainder.
+	 * @method div
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.div = function (other) {
+		if ( (other._low == 0) && (other._high == 0) ) throw Error('division by zero')
+
+		// other == 1
+		if (other._high == 0 && other._low == 1) {
+			this.remainder = new UINT32(0)
+			return this
+		}
+
+		// other > this: 0
+		if ( other.gt(this) ) {
+			this.remainder = this.clone()
+			this._low = 0
+			this._high = 0
+			return this
+		}
+		// other == this: 1
+		if ( this.eq(other) ) {
+			this.remainder = new UINT32(0)
+			this._low = 1
+			this._high = 0
+			return this
+		}
+
+		// Shift the divisor left until it is higher than the dividend
+		var _other = other.clone()
+		var i = -1
+		while ( !this.lt(_other) ) {
+			// High bit can overflow the default 16bits
+			// Its ok since we right shift after this loop
+			// The overflown bit must be kept though
+			_other.shiftLeft(1, true)
+			i++
+		}
+
+		// Set the remainder
+		this.remainder = this.clone()
+		// Initialize the current result to 0
+		this._low = 0
+		this._high = 0
+		for (; i >= 0; i--) {
+			_other.shiftRight(1)
+			// If shifted divisor is smaller than the dividend
+			// then subtract it from the dividend
+			if ( !this.remainder.lt(_other) ) {
+				this.remainder.subtract(_other)
+				// Update the current result
+				if (i >= 16) {
+					this._high |= 1 << (i - 16)
+				} else {
+					this._low |= 1 << i
+				}
+			}
+		}
+
+		return this
+	}
+
+	/**
+	 * Negate the current _UINT32_
+	 * @method negate
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.negate = function () {
+		var v = ( ~this._low & 0xFFFF ) + 1
+		this._low = v & 0xFFFF
+		this._high = (~this._high + (v >>> 16)) & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Equals
+	 * @method eq
+	 * @param {Object} other UINT32
+	 * @return {Boolean}
+	 */
+	UINT32.prototype.equals = UINT32.prototype.eq = function (other) {
+		return (this._low == other._low) && (this._high == other._high)
+	}
+
+	/**
+	 * Greater than (strict)
+	 * @method gt
+	 * @param {Object} other UINT32
+	 * @return {Boolean}
+	 */
+	UINT32.prototype.greaterThan = UINT32.prototype.gt = function (other) {
+		if (this._high > other._high) return true
+		if (this._high < other._high) return false
+		return this._low > other._low
+	}
+
+	/**
+	 * Less than (strict)
+	 * @method lt
+	 * @param {Object} other UINT32
+	 * @return {Boolean}
+	 */
+	UINT32.prototype.lessThan = UINT32.prototype.lt = function (other) {
+		if (this._high < other._high) return true
+		if (this._high > other._high) return false
+		return this._low < other._low
+	}
+
+	/**
+	 * Bitwise OR
+	 * @method or
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.or = function (other) {
+		this._low |= other._low
+		this._high |= other._high
+
+		return this
+	}
+
+	/**
+	 * Bitwise AND
+	 * @method and
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.and = function (other) {
+		this._low &= other._low
+		this._high &= other._high
+
+		return this
+	}
+
+	/**
+	 * Bitwise NOT
+	 * @method not
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.not = function() {
+		this._low = ~this._low & 0xFFFF
+		this._high = ~this._high & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Bitwise XOR
+	 * @method xor
+	 * @param {Object} other UINT32
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.xor = function (other) {
+		this._low ^= other._low
+		this._high ^= other._high
+
+		return this
+	}
+
+	/**
+	 * Bitwise shift right
+	 * @method shiftRight
+	 * @param {Number} number of bits to shift
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.shiftRight = UINT32.prototype.shiftr = function (n) {
+		if (n > 16) {
+			this._low = this._high >> (n - 16)
+			this._high = 0
+		} else if (n == 16) {
+			this._low = this._high
+			this._high = 0
+		} else {
+			this._low = (this._low >> n) | ( (this._high << (16-n)) & 0xFFFF )
+			this._high >>= n
+		}
+
+		return this
+	}
+
+	/**
+	 * Bitwise shift left
+	 * @method shiftLeft
+	 * @param {Number} number of bits to shift
+	 * @param {Boolean} allow overflow
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.shiftLeft = UINT32.prototype.shiftl = function (n, allowOverflow) {
+		if (n > 16) {
+			this._high = this._low << (n - 16)
+			this._low = 0
+			if (!allowOverflow) {
+				this._high &= 0xFFFF
+			}
+		} else if (n == 16) {
+			this._high = this._low
+			this._low = 0
+		} else {
+			this._high = (this._high << n) | (this._low >> (16-n))
+			this._low = (this._low << n) & 0xFFFF
+			if (!allowOverflow) {
+				// Overflow only allowed on the high bits...
+				this._high &= 0xFFFF
+			}
+		}
+
+		return this
+	}
+
+	/**
+	 * Bitwise rotate left
+	 * @method rotl
+	 * @param {Number} number of bits to rotate
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.rotateLeft = UINT32.prototype.rotl = function (n) {
+		var v = (this._high << 16) | this._low
+		v = (v << n) | (v >>> (32 - n))
+		this._low = v & 0xFFFF
+		this._high = v >>> 16
+
+		return this
+	}
+
+	/**
+	 * Bitwise rotate right
+	 * @method rotr
+	 * @param {Number} number of bits to rotate
+	 * @return ThisExpression
+	 */
+	UINT32.prototype.rotateRight = UINT32.prototype.rotr = function (n) {
+		var v = (this._high << 16) | this._low
+		v = (v >>> n) | (v << (32 - n))
+		this._low = v & 0xFFFF
+		this._high = v >>> 16
+
+		return this
+	}
+
+	/**
+	 * Clone the current _UINT32_
+	 * @method clone
+	 * @return {Object} cloned UINT32
+	 */
+	UINT32.prototype.clone = function () {
+		return new UINT32(this._low, this._high)
+	}
+
+	if (typeof define != 'undefined' && define.amd) {
+		// AMD / RequireJS
+		define([], function () {
+			return UINT32
+		})
+	} else if (typeof module != 'undefined' && module.exports) {
+		// Node.js
+		module.exports = UINT32
+	} else {
+		// Browser
+		root['UINT32'] = UINT32
+	}
+
+})(this)

app/node_modules/cuint/lib/uint64.js

@@ -0,0 +1,648 @@
+/**
+	C-like unsigned 64 bits integers in Javascript
+	Copyright (C) 2013, Pierre Curto
+	MIT license
+ */
+;(function (root) {
+
+	// Local cache for typical radices
+	var radixPowerCache = {
+		16: UINT64( Math.pow(16, 5) )
+	,	10: UINT64( Math.pow(10, 5) )
+	,	2:  UINT64( Math.pow(2, 5) )
+	}
+	var radixCache = {
+		16: UINT64(16)
+	,	10: UINT64(10)
+	,	2:  UINT64(2)
+	}
+
+	/**
+	 *	Represents an unsigned 64 bits integer
+	 * @constructor
+	 * @param {Number} first low bits (8)
+	 * @param {Number} second low bits (8)
+	 * @param {Number} first high bits (8)
+	 * @param {Number} second high bits (8)
+	 * or
+	 * @param {Number} low bits (32)
+	 * @param {Number} high bits (32)
+	 * or
+	 * @param {String|Number} integer as a string 		 | integer as a number
+	 * @param {Number|Undefined} radix (optional, default=10)
+	 * @return 
+	 */
+	function UINT64 (a00, a16, a32, a48) {
+		if ( !(this instanceof UINT64) )
+			return new UINT64(a00, a16, a32, a48)
+
+		this.remainder = null
+		if (typeof a00 == 'string')
+			return fromString.call(this, a00, a16)
+
+		if (typeof a16 == 'undefined')
+			return fromNumber.call(this, a00)
+
+		fromBits.apply(this, arguments)
+	}
+
+	/**
+	 * Set the current _UINT64_ object with its low and high bits
+	 * @method fromBits
+	 * @param {Number} first low bits (8)
+	 * @param {Number} second low bits (8)
+	 * @param {Number} first high bits (8)
+	 * @param {Number} second high bits (8)
+	 * or
+	 * @param {Number} low bits (32)
+	 * @param {Number} high bits (32)
+	 * @return ThisExpression
+	 */
+	function fromBits (a00, a16, a32, a48) {
+		if (typeof a32 == 'undefined') {
+			this._a00 = a00 & 0xFFFF
+			this._a16 = a00 >>> 16
+			this._a32 = a16 & 0xFFFF
+			this._a48 = a16 >>> 16
+			return this
+		}
+
+		this._a00 = a00 | 0
+		this._a16 = a16 | 0
+		this._a32 = a32 | 0
+		this._a48 = a48 | 0
+
+		return this
+	}
+	UINT64.prototype.fromBits = fromBits
+
+	/**
+	 * Set the current _UINT64_ object from a number
+	 * @method fromNumber
+	 * @param {Number} number
+	 * @return ThisExpression
+	 */
+	function fromNumber (value) {
+		this._a00 = value & 0xFFFF
+		this._a16 = value >>> 16
+		this._a32 = 0
+		this._a48 = 0
+
+		return this
+	}
+	UINT64.prototype.fromNumber = fromNumber
+
+	/**
+	 * Set the current _UINT64_ object from a string
+	 * @method fromString
+	 * @param {String} integer as a string
+	 * @param {Number} radix (optional, default=10)
+	 * @return ThisExpression
+	 */
+	function fromString (s, radix) {
+		radix = radix || 10
+
+		this._a00 = 0
+		this._a16 = 0
+		this._a32 = 0
+		this._a48 = 0
+
+		/*
+			In Javascript, bitwise operators only operate on the first 32 bits 
+			of a number, even though parseInt() encodes numbers with a 53 bits 
+			mantissa.
+			Therefore UINT64(<Number>) can only work on 32 bits.
+			The radix maximum value is 36 (as per ECMA specs) (26 letters + 10 digits)
+			maximum input value is m = 32bits as 1 = 2^32 - 1
+			So the maximum substring length n is:
+			36^(n+1) - 1 = 2^32 - 1
+			36^(n+1) = 2^32
+			(n+1)ln(36) = 32ln(2)
+			n = 32ln(2)/ln(36) - 1
+			n = 5.189644915687692
+			n = 5
+		 */
+		var radixUint = radixPowerCache[radix] || new UINT64( Math.pow(radix, 5) )
+
+		for (var i = 0, len = s.length; i < len; i += 5) {
+			var size = Math.min(5, len - i)
+			var value = parseInt( s.slice(i, i + size), radix )
+			this.multiply(
+					size < 5
+						? new UINT64( Math.pow(radix, size) )
+						: radixUint
+				)
+				.add( new UINT64(value) )
+		}
+
+		return this
+	}
+	UINT64.prototype.fromString = fromString
+
+	/**
+	 * Convert this _UINT64_ to a number (last 32 bits are dropped)
+	 * @method toNumber
+	 * @return {Number} the converted UINT64
+	 */
+	UINT64.prototype.toNumber = function () {
+		return (this._a16 * 65536) + this._a00
+	}
+
+	/**
+	 * Convert this _UINT64_ to a string
+	 * @method toString
+	 * @param {Number} radix (optional, default=10)
+	 * @return {String} the converted UINT64
+	 */
+	UINT64.prototype.toString = function (radix) {
+		radix = radix || 10
+		var radixUint = radixCache[radix] || new UINT64(radix)
+
+		if ( !this.gt(radixUint) ) return this.toNumber().toString(radix)
+
+		var self = this.clone()
+		var res = new Array(64)
+		for (var i = 63; i >= 0; i--) {
+			self.div(radixUint)
+			res[i] = self.remainder.toNumber().toString(radix)
+			if ( !self.gt(radixUint) ) break
+		}
+		res[i-1] = self.toNumber().toString(radix)
+
+		return res.join('')
+	}
+
+	/**
+	 * Add two _UINT64_. The current _UINT64_ stores the result
+	 * @method add
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.add = function (other) {
+		var a00 = this._a00 + other._a00
+
+		var a16 = a00 >>> 16
+		a16 += this._a16 + other._a16
+
+		var a32 = a16 >>> 16
+		a32 += this._a32 + other._a32
+
+		var a48 = a32 >>> 16
+		a48 += this._a48 + other._a48
+
+		this._a00 = a00 & 0xFFFF
+		this._a16 = a16 & 0xFFFF
+		this._a32 = a32 & 0xFFFF
+		this._a48 = a48 & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Subtract two _UINT64_. The current _UINT64_ stores the result
+	 * @method subtract
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.subtract = function (other) {
+		return this.add( other.clone().negate() )
+	}
+
+	/**
+	 * Multiply two _UINT64_. The current _UINT64_ stores the result
+	 * @method multiply
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.multiply = function (other) {
+		/*
+			a = a00 + a16 + a32 + a48
+			b = b00 + b16 + b32 + b48
+			a*b = (a00 + a16 + a32 + a48)(b00 + b16 + b32 + b48)
+				= a00b00 + a00b16 + a00b32 + a00b48
+				+ a16b00 + a16b16 + a16b32 + a16b48
+				+ a32b00 + a32b16 + a32b32 + a32b48
+				+ a48b00 + a48b16 + a48b32 + a48b48
+
+			a16b48, a32b32, a48b16, a48b32 and a48b48 overflow the 64 bits
+			so it comes down to:
+			a*b	= a00b00 + a00b16 + a00b32 + a00b48
+				+ a16b00 + a16b16 + a16b32
+				+ a32b00 + a32b16
+				+ a48b00
+				= a00b00
+				+ a00b16 + a16b00
+				+ a00b32 + a16b16 + a32b00
+				+ a00b48 + a16b32 + a32b16 + a48b00
+		 */
+		var a00 = this._a00
+		var a16 = this._a16
+		var a32 = this._a32
+		var a48 = this._a48
+		var b00 = other._a00
+		var b16 = other._a16
+		var b32 = other._a32
+		var b48 = other._a48
+
+		var c00 = a00 * b00
+
+		var c16 = c00 >>> 16
+		c16 += a00 * b16
+		var c32 = c16 >>> 16
+		c16 &= 0xFFFF
+		c16 += a16 * b00
+
+		c32 += c16 >>> 16
+		c32 += a00 * b32
+		var c48 = c32 >>> 16
+		c32 &= 0xFFFF
+		c32 += a16 * b16
+		c48 += c32 >>> 16
+		c32 &= 0xFFFF
+		c32 += a32 * b00
+
+		c48 += c32 >>> 16
+		c48 += a00 * b48
+		c48 &= 0xFFFF
+		c48 += a16 * b32
+		c48 &= 0xFFFF
+		c48 += a32 * b16
+		c48 &= 0xFFFF
+		c48 += a48 * b00
+
+		this._a00 = c00 & 0xFFFF
+		this._a16 = c16 & 0xFFFF
+		this._a32 = c32 & 0xFFFF
+		this._a48 = c48 & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Divide two _UINT64_. The current _UINT64_ stores the result.
+	 * The remainder is made available as the _remainder_ property on
+	 * the _UINT64_ object. It can be null, meaning there are no remainder.
+	 * @method div
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.div = function (other) {
+		if ( (other._a16 == 0) && (other._a32 == 0) && (other._a48 == 0) ) {
+			if (other._a00 == 0) throw Error('division by zero')
+
+			// other == 1: this
+			if (other._a00 == 1) {
+				this.remainder = new UINT64(0)
+				return this
+			}
+		}
+
+		// other > this: 0
+		if ( other.gt(this) ) {
+			this.remainder = this.clone()
+			this._a00 = 0
+			this._a16 = 0
+			this._a32 = 0
+			this._a48 = 0
+			return this
+		}
+		// other == this: 1
+		if ( this.eq(other) ) {
+			this.remainder = new UINT64(0)
+			this._a00 = 1
+			this._a16 = 0
+			this._a32 = 0
+			this._a48 = 0
+			return this
+		}
+
+		// Shift the divisor left until it is higher than the dividend
+		var _other = other.clone()
+		var i = -1
+		while ( !this.lt(_other) ) {
+			// High bit can overflow the default 16bits
+			// Its ok since we right shift after this loop
+			// The overflown bit must be kept though
+			_other.shiftLeft(1, true)
+			i++
+		}
+
+		// Set the remainder
+		this.remainder = this.clone()
+		// Initialize the current result to 0
+		this._a00 = 0
+		this._a16 = 0
+		this._a32 = 0
+		this._a48 = 0
+		for (; i >= 0; i--) {
+			_other.shiftRight(1)
+			// If shifted divisor is smaller than the dividend
+			// then subtract it from the dividend
+			if ( !this.remainder.lt(_other) ) {
+				this.remainder.subtract(_other)
+				// Update the current result
+				if (i >= 48) {
+					this._a48 |= 1 << (i - 48)
+				} else if (i >= 32) {
+					this._a32 |= 1 << (i - 32)
+				} else if (i >= 16) {
+					this._a16 |= 1 << (i - 16)
+				} else {
+					this._a00 |= 1 << i
+				}
+			}
+		}
+
+		return this
+	}
+
+	/**
+	 * Negate the current _UINT64_
+	 * @method negate
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.negate = function () {
+		var v = ( ~this._a00 & 0xFFFF ) + 1
+		this._a00 = v & 0xFFFF
+		v = (~this._a16 & 0xFFFF) + (v >>> 16)
+		this._a16 = v & 0xFFFF
+		v = (~this._a32 & 0xFFFF) + (v >>> 16)
+		this._a32 = v & 0xFFFF
+		this._a48 = (~this._a48 + (v >>> 16)) & 0xFFFF
+
+		return this
+	}
+
+	/**
+
+	 * @method eq
+	 * @param {Object} other UINT64
+	 * @return {Boolean}
+	 */
+	UINT64.prototype.equals = UINT64.prototype.eq = function (other) {
+		return (this._a48 == other._a48) && (this._a00 == other._a00)
+			 && (this._a32 == other._a32) && (this._a16 == other._a16)
+	}
+
+	/**
+	 * Greater than (strict)
+	 * @method gt
+	 * @param {Object} other UINT64
+	 * @return {Boolean}
+	 */
+	UINT64.prototype.greaterThan = UINT64.prototype.gt = function (other) {
+		if (this._a48 > other._a48) return true
+		if (this._a48 < other._a48) return false
+		if (this._a32 > other._a32) return true
+		if (this._a32 < other._a32) return false
+		if (this._a16 > other._a16) return true
+		if (this._a16 < other._a16) return false
+		return this._a00 > other._a00
+	}
+
+	/**
+	 * Less than (strict)
+	 * @method lt
+	 * @param {Object} other UINT64
+	 * @return {Boolean}
+	 */
+	UINT64.prototype.lessThan = UINT64.prototype.lt = function (other) {
+		if (this._a48 < other._a48) return true
+		if (this._a48 > other._a48) return false
+		if (this._a32 < other._a32) return true
+		if (this._a32 > other._a32) return false
+		if (this._a16 < other._a16) return true
+		if (this._a16 > other._a16) return false
+		return this._a00 < other._a00
+	}
+
+	/**
+	 * Bitwise OR
+	 * @method or
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.or = function (other) {
+		this._a00 |= other._a00
+		this._a16 |= other._a16
+		this._a32 |= other._a32
+		this._a48 |= other._a48
+
+		return this
+	}
+
+	/**
+	 * Bitwise AND
+	 * @method and
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.and = function (other) {
+		this._a00 &= other._a00
+		this._a16 &= other._a16
+		this._a32 &= other._a32
+		this._a48 &= other._a48
+
+		return this
+	}
+
+	/**
+	 * Bitwise XOR
+	 * @method xor
+	 * @param {Object} other UINT64
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.xor = function (other) {
+		this._a00 ^= other._a00
+		this._a16 ^= other._a16
+		this._a32 ^= other._a32
+		this._a48 ^= other._a48
+
+		return this
+	}
+
+	/**
+	 * Bitwise NOT
+	 * @method not
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.not = function() {
+		this._a00 = ~this._a00 & 0xFFFF
+		this._a16 = ~this._a16 & 0xFFFF
+		this._a32 = ~this._a32 & 0xFFFF
+		this._a48 = ~this._a48 & 0xFFFF
+
+		return this
+	}
+
+	/**
+	 * Bitwise shift right
+	 * @method shiftRight
+	 * @param {Number} number of bits to shift
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.shiftRight = UINT64.prototype.shiftr = function (n) {
+		n %= 64
+		if (n >= 48) {
+			this._a00 = this._a48 >> (n - 48)
+			this._a16 = 0
+			this._a32 = 0
+			this._a48 = 0
+		} else if (n >= 32) {
+			n -= 32
+			this._a00 = ( (this._a32 >> n) | (this._a48 << (16-n)) ) & 0xFFFF
+			this._a16 = (this._a48 >> n) & 0xFFFF
+			this._a32 = 0
+			this._a48 = 0
+		} else if (n >= 16) {
+			n -= 16
+			this._a00 = ( (this._a16 >> n) | (this._a32 << (16-n)) ) & 0xFFFF
+			this._a16 = ( (this._a32 >> n) | (this._a48 << (16-n)) ) & 0xFFFF
+			this._a32 = (this._a48 >> n) & 0xFFFF
+			this._a48 = 0
+		} else {
+			this._a00 = ( (this._a00 >> n) | (this._a16 << (16-n)) ) & 0xFFFF
+			this._a16 = ( (this._a16 >> n) | (this._a32 << (16-n)) ) & 0xFFFF
+			this._a32 = ( (this._a32 >> n) | (this._a48 << (16-n)) ) & 0xFFFF
+			this._a48 = (this._a48 >> n) & 0xFFFF
+		}
+
+		return this
+	}
+
+	/**
+	 * Bitwise shift left
+	 * @method shiftLeft
+	 * @param {Number} number of bits to shift
+	 * @param {Boolean} allow overflow
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.shiftLeft = UINT64.prototype.shiftl = function (n, allowOverflow) {
+		n %= 64
+		if (n >= 48) {
+			this._a48 = this._a00 << (n - 48)
+			this._a32 = 0
+			this._a16 = 0
+			this._a00 = 0
+		} else if (n >= 32) {
+			n -= 32
+			this._a48 = (this._a16 << n) | (this._a00 >> (16-n))
+			this._a32 = (this._a00 << n) & 0xFFFF
+			this._a16 = 0
+			this._a00 = 0
+		} else if (n >= 16) {
+			n -= 16
+			this._a48 = (this._a32 << n) | (this._a16 >> (16-n))
+			this._a32 = ( (this._a16 << n) | (this._a00 >> (16-n)) ) & 0xFFFF
+			this._a16 = (this._a00 << n) & 0xFFFF
+			this._a00 = 0
+		} else {
+			this._a48 = (this._a48 << n) | (this._a32 >> (16-n))
+			this._a32 = ( (this._a32 << n) | (this._a16 >> (16-n)) ) & 0xFFFF
+			this._a16 = ( (this._a16 << n) | (this._a00 >> (16-n)) ) & 0xFFFF
+			this._a00 = (this._a00 << n) & 0xFFFF
+		}
+		if (!allowOverflow) {
+			this._a48 &= 0xFFFF
+		}
+
+		return this
+	}
+
+	/**
+	 * Bitwise rotate left
+	 * @method rotl
+	 * @param {Number} number of bits to rotate
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.rotateLeft = UINT64.prototype.rotl = function (n) {
+		n %= 64
+		if (n == 0) return this
+		if (n >= 32) {
+			// A.B.C.D
+			// B.C.D.A rotl(16)
+			// C.D.A.B rotl(32)
+			var v = this._a00
+			this._a00 = this._a32
+			this._a32 = v
+			v = this._a48
+			this._a48 = this._a16
+			this._a16 = v
+			if (n == 32) return this
+			n -= 32
+		}
+
+		var high = (this._a48 << 16) | this._a32
+		var low = (this._a16 << 16) | this._a00
+
+		var _high = (high << n) | (low >>> (32 - n))
+		var _low = (low << n) | (high >>> (32 - n))
+
+		this._a00 = _low & 0xFFFF
+		this._a16 = _low >>> 16
+		this._a32 = _high & 0xFFFF
+		this._a48 = _high >>> 16
+
+		return this
+	}
+
+	/**
+	 * Bitwise rotate right
+	 * @method rotr
+	 * @param {Number} number of bits to rotate
+	 * @return ThisExpression
+	 */
+	UINT64.prototype.rotateRight = UINT64.prototype.rotr = function (n) {
+		n %= 64
+		if (n == 0) return this
+		if (n >= 32) {
+			// A.B.C.D
+			// D.A.B.C rotr(16)
+			// C.D.A.B rotr(32)
+			var v = this._a00
+			this._a00 = this._a32
+			this._a32 = v
+			v = this._a48
+			this._a48 = this._a16
+			this._a16 = v
+			if (n == 32) return this
+			n -= 32
+		}
+
+		var high = (this._a48 << 16) | this._a32
+		var low = (this._a16 << 16) | this._a00
+
+		var _high = (high >>> n) | (low << (32 - n))
+		var _low = (low >>> n) | (high << (32 - n))
+
+		this._a00 = _low & 0xFFFF
+		this._a16 = _low >>> 16
+		this._a32 = _high & 0xFFFF
+		this._a48 = _high >>> 16
+
+		return this
+	}
+
+	/**
+	 * Clone the current _UINT64_
+	 * @method clone
+	 * @return {Object} cloned UINT64
+	 */
+	UINT64.prototype.clone = function () {
+		return new UINT64(this._a00, this._a16, this._a32, this._a48)
+	}
+
+	if (typeof define != 'undefined' && define.amd) {
+		// AMD / RequireJS
+		define([], function () {
+			return UINT64
+		})
+	} else if (typeof module != 'undefined' && module.exports) {
+		// Node.js
+		module.exports = UINT64
+	} else {
+		// Browser
+		root['UINT64'] = UINT64
+	}
+
+})(this)

app/node_modules/cuint/package.json

@@ -0,0 +1,58 @@
+{
+  "_from": "cuint@^0.2.1",
+  "_id": "cuint@0.2.2",
+  "_inBundle": false,
+  "_integrity": "sha1-QICG1AlVDCYxFVYZ6fp7ytw7mRs=",
+  "_location": "/cuint",
+  "_phantomChildren": {},
+  "_requested": {
+    "type": "range",
+    "registry": true,
+    "raw": "cuint@^0.2.1",
+    "name": "cuint",
+    "escapedName": "cuint",
+    "rawSpec": "^0.2.1",
+    "saveSpec": null,
+    "fetchSpec": "^0.2.1"
+  },
+  "_requiredBy": [
+    "/asar"
+  ],
+  "_resolved": "https://registry.npmjs.org/cuint/-/cuint-0.2.2.tgz",
+  "_shasum": "408086d409550c2631155619e9fa7bcadc3b991b",
+  "_spec": "cuint@^0.2.1",
+  "_where": "F:\\projects\\p\\gitlit\\app\\node_modules\\asar",
+  "author": {
+    "name": "Pierre Curto"
+  },
+  "bugs": {
+    "url": "https://github.com/pierrec/js-cuint/issues"
+  },
+  "bundleDependencies": false,
+  "deprecated": false,
+  "description": "Unsigned integers for Javascript",
+  "devDependencies": {
+    "minify": "0.2.x",
+    "mocha": "^2.1.0"
+  },
+  "homepage": "https://github.com/pierrec/js-cuint",
+  "keywords": [
+    "C",
+    "unsigned",
+    "integer",
+    "32bits",
+    "64bits"
+  ],
+  "license": "MIT",
+  "main": "index.js",
+  "name": "cuint",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/pierrec/js-cuint.git"
+  },
+  "scripts": {
+    "prepublish": "node build",
+    "test": "mocha"
+  },
+  "version": "0.2.2"
+}

app/node_modules/cuint/test/UINT32-test.js

@@ -0,0 +1,220 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('UINT32 constructor', function () {
+
+  describe('with no parameters', function () {
+
+    it('should properly initialize', function (done) {
+      var u = UINT32()
+
+      assert.equal( u._low, 0 )
+      assert.equal( u._high, 0 )
+      done()
+    })
+
+  })
+
+  describe('with low and high bits', function () {
+
+    describe('0, 0', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32(0, 0)
+
+        assert.equal( u._low, 0 )
+        assert.equal( u._high, 0 )
+        done()
+      })
+    })
+
+    describe('1, 0', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32(1, 0)
+
+        assert.equal( u._low, 1 )
+        assert.equal( u._high, 0 )
+        done()
+      })
+    })
+
+    describe('0, 1', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32(0, 1)
+
+        assert.equal( u._low, 0 )
+        assert.equal( u._high, 1 )
+        done()
+      })
+    })
+
+    describe('3, 5', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32(3, 5)
+
+        assert.equal( u._low, 3 )
+        assert.equal( u._high, 5 )
+        done()
+      })
+    })
+
+  })
+
+  describe('with number', function () {
+
+    describe('0', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32(0)
+
+        assert.equal( u._low, 0 )
+        assert.equal( u._high, 0 )
+        done()
+      })
+    })
+
+    describe('1', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32(1)
+
+        assert.equal( u._low, 1 )
+        assert.equal( u._high, 0 )
+        done()
+      })
+    })
+
+    describe('3', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32(3)
+
+        assert.equal( u._low, 3 )
+        assert.equal( u._high, 0 )
+        done()
+      })
+    })
+
+    describe('with high bit', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32( Math.pow(2,17)+123 )
+
+        assert.equal( u._low, 123 )
+        assert.equal( u._high, 2 )
+        done()
+      })
+    })
+
+  })
+
+  describe('with string', function () {
+
+    describe('"0"', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32('0')
+
+        assert.equal( u._low, 0 )
+        assert.equal( u._high, 0 )
+        done()
+      })
+    })
+
+    describe('"1"', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32('1')
+
+        assert.equal( u._low, 1 )
+        assert.equal( u._high, 0 )
+        done()
+      })
+    })
+
+    describe('10', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32('10')
+
+        assert.equal( u._low, 10 )
+        assert.equal( u._high, 0 )
+        done()
+      })
+    })
+
+    describe('with high bit', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32( '' + (Math.pow(2,17)+123) )
+
+        assert.equal( u._low, 123 )
+        assert.equal( u._high, 2 )
+        done()
+      })
+    })
+
+    describe('with radix 10', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32( '123', 10 )
+
+        assert.equal( u._low, 123 )
+        assert.equal( u._high, 0 )
+        done()
+      })
+    })
+
+    describe('with radix 2', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32( '1111011', 2 )
+
+        assert.equal( u._low, 123 )
+        assert.equal( u._high, 0 )
+        done()
+      })
+    })
+
+    describe('with radix 16', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32( '7B', 16 )
+
+        assert.equal( u._low, 123 )
+        assert.equal( u._high, 0 )
+        done()
+      })
+    })
+
+    describe('8000 with radix 16', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32( '8000', 16 )
+
+        assert.equal( u._low, 32768 )
+        assert.equal( u._high, 0 )
+        done()
+      })
+    })
+
+    describe('80000000 with radix 16', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32( '80000000', 16 )
+
+        assert.equal( u._low, 0 )
+        assert.equal( u._high, 32768 )
+        done()
+      })
+    })
+
+    describe('maximum unsigned 32 bits value in base 2', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32( Array(33).join('1'), 2 )
+
+        assert.equal( u._low, 65535 )
+        assert.equal( u._high, 65535 )
+        done()
+      })
+    })
+
+    describe('maximum unsigned 32 bits value in base 16', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT32( Array(9).join('F'), 16 )
+
+        assert.equal( u._low, 65535 )
+        assert.equal( u._high, 65535 )
+        done()
+      })
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_add-test.js

@@ -0,0 +1,109 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('add method', function () {
+
+  describe('0+0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(0).add( UINT32(0) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('0+1', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT32(0).add( UINT32(1) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('1+0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(1).add( UINT32(0) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('1+1', function () {
+
+    it('should return 2', function (done) {
+      var u = UINT32(1).add( UINT32(1) )
+
+      assert.equal( u.toNumber(), 2 )
+      done()
+    })
+
+  })
+
+  describe('low bit+high bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT32(123).add( UINT32(n) )
+
+      assert.equal( u.toNumber(), 123 + n )
+      done()
+    })
+
+  })
+
+  describe('high bit+low bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT32(n).add( UINT32(123) )
+
+      assert.equal( u.toNumber(), 123 + n )
+      done()
+    })
+
+  })
+
+  describe('high bit+high bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT32(n).add( UINT32(n) )
+
+      assert.equal( u.toNumber(), n + n )
+      done()
+    })
+
+  })
+
+  describe('overflow', function () {
+
+    it('should return n', function (done) {
+      var n = 'FFFFFFFF'
+      var u = UINT32(n, 16).add( UINT32(n, 16) )
+
+      assert.equal( u.toNumber(), -2 )
+      done()
+    })
+
+  })
+
+  describe('high bit+high bit 2', function () {
+
+    it('should return n', function (done) {
+      var u = UINT32('326648991').add( UINT32('265443576') )
+
+      assert.equal( u.toNumber(), 592092567 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_and-test.js

@@ -0,0 +1,64 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('and method', function () {
+
+  describe('0&1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(0).and( UINT32(1) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1&2', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(1).and( UINT32(2) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1&2^16', function () {
+
+    it('should return 0', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(1).and( UINT32(n) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('2^16&1', function () {
+
+    it('should return 0', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(n).and( UINT32(1) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('2^16&2^16', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(n).and( UINT32(n) )
+
+      assert.equal( u.toNumber(), n )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_div-test.js

@@ -0,0 +1,114 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('div method', function () {
+
+  describe('1/0', function () {
+
+    it('should throw', function (done) {
+      assert.throws(
+          function () {
+            UINT32(1).div( UINT32(0) )
+          }
+        , function (err) {
+            if (err instanceof Error) return true
+          }
+        )
+
+
+      done()
+    })
+
+  })
+
+  describe('0/1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(2).div( UINT32(1) )
+
+      assert.equal( u.toNumber(), 2 )
+      done()
+    })
+
+  })
+
+  describe('2/1', function () {
+
+    it('should return 2', function (done) {
+      var u = UINT32(0).div( UINT32(1) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1/2', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(1).div( UINT32(2) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('low bit/high bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT32(3).div( UINT32(n) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('high bit/low bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT32(n).div( UINT32(3) )
+
+      assert.equal( u.toNumber(), (n/3)|0 )
+      assert.equal( u.remainder.toNumber(), 2 )
+      done()
+    })
+
+  })
+
+  describe('high bit/high bit', function () {
+
+    it('should return n', function (done) {
+      var n = 'FFFFFFFF'
+      var u = UINT32(n, 16).div( UINT32(n, 16) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('high bit/high bit 2', function () {
+
+    it('should return n', function (done) {
+      var u = UINT32('3266489917').div( UINT32('668265263') )
+
+      assert.equal( u.toNumber(), 4 )
+      done()
+    })
+
+  })
+
+  describe('374761393/(16^3)', function () {
+    it('should return 91494', function (done) {
+      var u = UINT32('374761393').div( UINT32(16*16*16) )
+
+      assert.equal( u.toNumber(), 91494 )
+      done()
+    })
+  })
+
+})

app/node_modules/cuint/test/UINT32_equals-test.js

@@ -0,0 +1,62 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('equals method', function () {
+
+  describe('0==0', function () {
+
+    it('should return true', function (done) {
+      var u = UINT32(0).equals( UINT32(0) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('1==1', function () {
+
+    it('should return true', function (done) {
+      var u = UINT32(1).equals( UINT32(1) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('low bit', function () {
+
+    it('should return true', function (done) {
+      var u = UINT32(3).equals( UINT32(3) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('high bit', function () {
+
+    it('should return true', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT32(n).equals( UINT32(n) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('1!=2', function () {
+
+    it('should return false', function (done) {
+      var u = UINT32(1).equals( UINT32(2) )
+
+      assert( !u )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_greaterThan-test.js

@@ -0,0 +1,52 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('greaterThan method', function () {
+
+  describe('0>1', function () {
+
+    it('should return false', function (done) {
+      var u = UINT32(0).greaterThan( UINT32(1) )
+
+      assert( !u )
+      done()
+    })
+
+  })
+
+  describe('1>2', function () {
+
+    it('should return false', function (done) {
+      var u = UINT32(1).greaterThan( UINT32(2) )
+
+      assert( !u )
+      done()
+    })
+
+  })
+
+  describe('1>2^16', function () {
+
+    it('should return false', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(1).greaterThan( UINT32(n) )
+
+      assert( !u )
+      done()
+    })
+
+  })
+
+  describe('2^16>1', function () {
+
+    it('should return true', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(n).greaterThan( UINT32(1) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_lessThan-test.js

@@ -0,0 +1,52 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('lessThan method', function () {
+
+  describe('0<1', function () {
+
+    it('should return true', function (done) {
+      var u = UINT32(0).lessThan( UINT32(1) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('1<2', function () {
+
+    it('should return true', function (done) {
+      var u = UINT32(1).lessThan( UINT32(2) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('1<2^16', function () {
+
+    it('should return true', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(1).lessThan( UINT32(n) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('2^16<1', function () {
+
+    it('should return false', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(n).lessThan( UINT32(1) )
+
+      assert( !u )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_multiply-test.js

@@ -0,0 +1,75 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('multiply method', function () {
+
+  describe('0*0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(0).multiply( UINT32(0) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1*0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(1).multiply( UINT32(0) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('0*1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(0).multiply( UINT32(1) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('low bit*high bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT32(3).multiply( UINT32(n) )
+
+      assert.equal( u.toNumber(), 3*n )
+      done()
+    })
+
+  })
+
+  describe('high bit*low bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT32(n).multiply( UINT32(3) )
+
+      assert.equal( u.toNumber(), 3*n )
+      done()
+    })
+
+  })
+
+  describe('high bit*high bit', function () {
+
+    it('should return n', function (done) {
+      var n = 'FFFFFFFF'
+      var u = UINT32(n, 16).multiply( UINT32(n, 16) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_negate-test.js

@@ -0,0 +1,51 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('negate method', function () {
+
+  describe('0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(0).negate()
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1', function () {
+
+    it('should return -1', function (done) {
+      var u = UINT32(1).negate()
+
+      assert.equal( u.toNumber(), -1 )
+      done()
+    })
+
+  })
+
+  describe('low bit', function () {
+
+    it('should return -n', function (done) {
+      var u = UINT32(3).negate()
+
+      assert.equal( u.toNumber(), -3 )
+      done()
+    })
+
+  })
+
+  describe('high bit', function () {
+
+    it('should return -n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT32(n).negate()
+
+      assert.equal( u.toNumber(), -n )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_not-test.js

@@ -0,0 +1,45 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('not method', function () {
+
+  describe('0', function () {
+
+    it('should return 2^32-1', function (done) {
+      var u = UINT32(0).not()
+
+      assert.equal( u.toString(16), 'ffffffff' )
+      done()
+    })
+
+  })
+
+  describe('1', function () {
+
+    it('should return 2^32-2', function (done) {
+      var u = UINT32(1).not()
+
+      assert.equal( u.toString(16), 'fffffffe' )
+      done()
+    })
+
+  })
+
+  describe('2^31', function() {
+    var u = UINT32(0x7FFFFFFF).not()
+
+    assert.equal( u.toString(16), '80000000')
+  })
+
+  describe('all bits set', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(0xFFFFFFFF).not()
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_or-test.js

@@ -0,0 +1,52 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('or method', function () {
+
+  describe('0|1', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT32(0).or( UINT32(1) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('1|2', function () {
+
+    it('should return 3', function (done) {
+      var u = UINT32(1).or( UINT32(2) )
+
+      assert.equal( u.toNumber(), 3 )
+      done()
+    })
+
+  })
+
+  describe('1|2^16', function () {
+
+    it('should return n+1', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(1).or( UINT32(n) )
+
+      assert.equal( u.toNumber(), n+1 )
+      done()
+    })
+
+  })
+
+  describe('2^16|1', function () {
+
+    it('should return n+1', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(n).or( UINT32(1) )
+
+      assert.equal( u.toNumber(), n+1 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_rotateLeft-test.js

@@ -0,0 +1,51 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('rotateLeft method', function () {
+
+  describe('0rotl1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(0).rotateLeft(1)
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1rotl2', function () {
+
+    it('should return 4', function (done) {
+      var u = UINT32(1).rotateLeft(2)
+
+      assert.equal( u.toNumber(), 4 )
+      done()
+    })
+
+  })
+
+  describe('1rotl16', function () {
+
+    it('should return 2^16', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(1).rotateLeft(16)
+
+      assert.equal( u.toNumber(), n )
+      done()
+    })
+
+  })
+
+  describe('1rotl32', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT32(1).rotateLeft(32)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_rotateRight-test.js

@@ -0,0 +1,51 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('rotateRight method', function () {
+
+  describe('0rotr1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(0).rotateRight(1)
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('4rotr1', function () {
+
+    it('should return 2', function (done) {
+      var u = UINT32(4).rotateRight(1)
+
+      assert.equal( u.toNumber(), 2 )
+      done()
+    })
+
+  })
+
+  describe('2^16rotr16', function () {
+
+    it('should return 1', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(n).rotateRight(16)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('1rotr32', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT32(1).rotateRight(32)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_shiftLeft-test.js

@@ -0,0 +1,73 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('shiftLeft method', function () {
+
+  describe('0<<1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(0).shiftLeft(1)
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1<<2', function () {
+
+    it('should return 4', function (done) {
+      var u = UINT32(1).shiftLeft(2)
+
+      assert.equal( u.toNumber(), 4 )
+      done()
+    })
+
+  })
+
+  describe('1<<16', function () {
+
+    it('should return 2^16', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(1).shiftLeft(16)
+
+      assert.equal( u.toNumber(), n )
+      done()
+    })
+
+  })
+
+  describe('1<<32', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(1).shiftLeft(32)
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1<<31', function () {
+
+    it('should return 2^31', function (done) {
+      var u = UINT32(1).shiftLeft(31)
+
+      assert.equal( u.toString(16), '80000000' )
+      done()
+    })
+
+  })
+
+  describe('9<<28', function () {
+
+    it('should return 2^31', function (done) {
+      var u = UINT32(9).shiftLeft(28)
+
+      assert.equal( u.toString(16), '90000000' )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_shiftRight-test.js

@@ -0,0 +1,95 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('shiftRight method', function () {
+
+  describe('0>>1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(0).shiftRight(1)
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('4>>2', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT32(4).shiftRight(2)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('2^16>>16', function () {
+
+    it('should return 1', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(n).shiftRight(16)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('1>>32', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(1).shiftRight(32)
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('2^31>>31', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT32('80000000', 16).shiftRight(31)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('2^28>>28', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT32('10000000', 16).shiftRight(28)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('2^31+2^28>>31', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT32('90000000', 16).shiftRight(31)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('2^31+2^28>>28', function () {
+
+    it('should return 9', function (done) {
+      var u = UINT32('90000000', 16).shiftRight(28)
+
+      assert.equal( u.toNumber(), 9 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_subtract-test.js

@@ -0,0 +1,75 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('subtract method', function () {
+
+  describe('0-0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(0).subtract( UINT32(0) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1-0', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT32(1).subtract( UINT32(0) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('0-1', function () {
+
+    it('should return -1', function (done) {
+      var u = UINT32(0).subtract( UINT32(1) )
+
+      assert.equal( u.toNumber(), -1 )
+      done()
+    })
+
+  })
+
+  describe('low bit-high bit', function () {
+
+    it('should return 0', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT32(1).subtract( UINT32(n) )
+
+      assert.equal( u.toNumber(), 1-n )
+      done()
+    })
+
+  })
+
+  describe('high bit-low bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT32(n).subtract( UINT32(123) )
+
+      assert.equal( u.toNumber(), n - 123 )
+      done()
+    })
+
+  })
+
+  describe('high bit-high bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT32(n+1).subtract( UINT32(n) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_toNumber-test.js

@@ -0,0 +1,63 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('toNumber method', function () {
+
+  describe('from 0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT32(0).toNumber()
+
+      assert.equal( u, 0 )
+      done()
+    })
+
+  })
+
+  describe('from low bit number', function () {
+
+    it('should return the number', function (done) {
+      var u = UINT32(123).toNumber()
+
+      assert.equal( u, 123 )
+      done()
+    })
+
+  })
+
+  describe('from high bit number', function () {
+
+    it('should return the number', function (done) {
+      var n = Math.pow(2,17)
+      var u = UINT32(n).toNumber()
+
+      assert.equal( u, n )
+      done()
+    })
+
+  })
+
+  describe('from high and low bit number', function () {
+
+    it('should return the number', function (done) {
+      var n = Math.pow(2,17) + 123
+      var u = UINT32(n).toNumber()
+
+      assert.equal( u, n )
+      done()
+    })
+
+  })
+
+  describe('toNumber and toString', function () {
+
+    it('should return the same result for 100 random numbers', function () {
+      for (var i=0; i<100; i++) {
+        var u = UINT32(Math.floor(Math.random() * 0xffffffff));
+        assert.equal(u.toNumber(), parseInt(u.toString()));
+      }
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_toString-test.js

@@ -0,0 +1,74 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('toString method', function () {
+
+  describe('from 0', function () {
+
+    it('should return "0"', function (done) {
+      var u = UINT32(0).toString()
+
+      assert.equal( u, '0' )
+      done()
+    })
+
+  })
+
+  describe('from low bit number', function () {
+
+    it('should return the number', function (done) {
+      var u = UINT32(123).toString()
+
+      assert.equal( u, '123' )
+      done()
+    })
+
+  })
+
+  describe('from high bit number', function () {
+
+    it('should return the number', function (done) {
+      var n = Math.pow(2,17)
+      var u = UINT32(n).toString()
+
+      assert.equal( u, ''+n )
+      done()
+    })
+
+  })
+
+  describe('from high and low bit number', function () {
+
+    it('should return the number', function (done) {
+      var n = Math.pow(2,17) + 123
+      var u = UINT32(n).toString()
+
+      assert.equal( u, ''+n )
+      done()
+    })
+
+  })
+
+  describe('< radix', function () {
+
+    it('should return the number', function (done) {
+      var u = UINT32(4).toString()
+
+      assert.equal( u, '4' )
+      done()
+    })
+
+  })
+
+  describe('= radix', function () {
+
+    it('should return the number', function (done) {
+      var u = UINT32(2).toString(2)
+
+      assert.equal( u, '10' )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT32_xor-test.js

@@ -0,0 +1,64 @@
+var assert = require('assert')
+var UINT32 = require('..').UINT32
+
+describe('xor method', function () {
+
+  describe('0^1', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT32(0).xor( UINT32(1) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('1^2', function () {
+
+    it('should return 3', function (done) {
+      var u = UINT32(1).xor( UINT32(2) )
+
+      assert.equal( u.toNumber(), 3 )
+      done()
+    })
+
+  })
+
+  describe('1^2^16', function () {
+
+    it('should return n+1', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(1).xor( UINT32(n) )
+
+      assert.equal( u.toNumber(), n+1 )
+      done()
+    })
+
+  })
+
+  describe('2^16^1', function () {
+
+    it('should return n+1', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(n).xor( UINT32(1) )
+
+      assert.equal( u.toNumber(), n+1 )
+      done()
+    })
+
+  })
+
+  describe('2^16^2^16', function () {
+
+    it('should return 0', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT32(n).xor( UINT32(n) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64-test.js

@@ -0,0 +1,284 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('UINT64 constructor', function () {
+
+  describe('with no parameters', function () {
+
+    it('should properly initialize', function (done) {
+      var u = UINT64()
+
+      assert.equal( u._a00, 0 )
+      assert.equal( u._a16, 0 )
+      assert.equal( u._a32, 0 )
+      assert.equal( u._a48, 0 )
+      done()
+    })
+
+  })
+
+  describe('with low and high bits', function () {
+
+    describe('0, 0', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64(0, 0)
+
+        assert.equal( u._a00, 0 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('1, 0', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64(1, 0)
+
+        assert.equal( u._a00, 1 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('0, 1', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64(0, 1)
+
+        assert.equal( u._a00, 0 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 1 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('3, 5', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64(3, 5)
+
+        assert.equal( u._a00, 3 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 5 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+  })
+
+  describe('with number', function () {
+
+    describe('0', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64(0)
+
+        assert.equal( u._a00, 0 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('1', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64(1)
+
+        assert.equal( u._a00, 1 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('3', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64(3)
+
+        assert.equal( u._a00, 3 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('with high bit', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64( Math.pow(2,17)+123 )
+
+        assert.equal( u._a00, 123 )
+        assert.equal( u._a16, 2 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+  })
+
+  describe('with string', function () {
+
+    describe('"0"', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64('0')
+
+        assert.equal( u._a00, 0 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('"1"', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64('1')
+
+        assert.equal( u._a00, 1 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('10', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64('10')
+
+        assert.equal( u._a00, 10 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('with high bit', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64( '' + (Math.pow(2,17)+123) )
+
+        assert.equal( u._a00, 123 )
+        assert.equal( u._a16, 2 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('with radix 10', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64( '123', 10 )
+
+        assert.equal( u._a00, 123 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('with radix 2', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64( '1111011', 2 )
+
+        assert.equal( u._a00, 123 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('with radix 16', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64( '7B', 16 )
+
+        assert.equal( u._a00, 123 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('8000 with radix 16', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64( '8000', 16 )
+
+        assert.equal( u._a00, 32768 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('80000000 with radix 16', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64( '80000000', 16 )
+
+        assert.equal( u._a00, 0 )
+        assert.equal( u._a16, 32768 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('800000000000 with radix 16', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64( '800000000000', 16 )
+
+        assert.equal( u._a00, 0 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 32768 )
+        assert.equal( u._a48, 0 )
+        done()
+      })
+    })
+
+    describe('8000000000000000 with radix 16', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64( '8000000000000000', 16 )
+
+        assert.equal( u._a00, 0 )
+        assert.equal( u._a16, 0 )
+        assert.equal( u._a32, 0 )
+        assert.equal( u._a48, 32768 )
+        done()
+      })
+    })
+
+    describe('maximum unsigned 64 bits value in base 2', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64( Array(65).join('1'), 2 )
+
+        assert.equal( u._a00, 65535 )
+        assert.equal( u._a16, 65535 )
+        assert.equal( u._a32, 65535 )
+        assert.equal( u._a48, 65535 )
+        done()
+      })
+    })
+
+    describe('maximum unsigned 64 bits value in base 16', function () {
+      it('should properly initialize', function (done) {
+        var u = UINT64( Array(17).join('F'), 16 )
+
+        assert.equal( u._a00, 65535 )
+        assert.equal( u._a16, 65535 )
+        assert.equal( u._a32, 65535 )
+        assert.equal( u._a48, 65535 )
+        done()
+      })
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_add-test.js

@@ -0,0 +1,120 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('add method', function () {
+
+  describe('0+0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(0).add( UINT64(0) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('0+1', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT64(0).add( UINT64(1) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('1+0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(1).add( UINT64(0) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('1+1', function () {
+
+    it('should return 2', function (done) {
+      var u = UINT64(1).add( UINT64(1) )
+
+      assert.equal( u.toNumber(), 2 )
+      done()
+    })
+
+  })
+
+  describe('low bit+high bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT64(123).add( UINT64(n) )
+
+      assert.equal( u.toNumber(), 123 + n )
+      done()
+    })
+
+  })
+
+  describe('high bit+low bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT64(n).add( UINT64(123) )
+
+      assert.equal( u.toNumber(), 123 + n )
+      done()
+    })
+
+  })
+
+  describe('high bit+high bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT64(n).add( UINT64(n) )
+
+      assert.equal( u.toNumber(), n + n )
+      done()
+    })
+
+  })
+
+  describe('overflow', function () {
+
+    it('should return n', function (done) {
+      var n = 'FFFFFFFF'
+      var u = UINT64(n, 16).add( UINT64(n, 16) )
+
+      assert.equal( u.toNumber(), -2 )
+      done()
+    })
+
+  })
+
+  describe('high bit+high bit 2', function () {
+
+    it('should return n', function (done) {
+      var u = UINT64('326648991').add( UINT64('265443576') )
+
+      assert.equal( u.toNumber(), 592092567 )
+      done()
+    })
+
+  })
+
+  describe('high bit+high bit 3', function () {
+
+    it('should return n', function (done) {
+      var u = UINT64('800000000000', 16).add( UINT64('100000000000', 16) )
+
+      assert.equal( u.toString(16), '900000000000' )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_and-test.js

@@ -0,0 +1,64 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('and method', function () {
+
+  describe('0&1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(0).and( UINT64(1) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1&2', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(1).and( UINT64(2) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1&2^16', function () {
+
+    it('should return 0', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(1).and( UINT64(n) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('2^16&1', function () {
+
+    it('should return 0', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(n).and( UINT64(1) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('2^16&2^16', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(n).and( UINT64(n) )
+
+      assert.equal( u.toNumber(), n )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_div-test.js

@@ -0,0 +1,105 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('div method', function () {
+
+  describe('1/0', function () {
+
+    it('should throw', function (done) {
+      assert.throws(
+          function () {
+            UINT64(1).div( UINT64(0) )
+          }
+        , function (err) {
+            if (err instanceof Error) return true
+          }
+        )
+
+
+      done()
+    })
+
+  })
+
+  describe('0/1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(2).div( UINT64(1) )
+
+      assert.equal( u.toNumber(), 2 )
+      done()
+    })
+
+  })
+
+  describe('2/1', function () {
+
+    it('should return 2', function (done) {
+      var u = UINT64(0).div( UINT64(1) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1/2', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(1).div( UINT64(2) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('low bit/high bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT64(3).div( UINT64(n) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('high bit/low bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT64(n).div( UINT64(3) )
+
+      assert.equal( u.toNumber(), (n/3)|0 )
+      assert.equal( u.remainder.toNumber(), 2 )
+      done()
+    })
+
+  })
+
+  describe('high bit/high bit', function () {
+
+    it('should return n', function (done) {
+      var n = 'FFFFFFFF'
+      var u = UINT64(n, 16).div( UINT64(n, 16) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('high bit/high bit 2', function () {
+
+    it('should return n', function (done) {
+      var u = UINT64('3266489917').div( UINT64('668265263') )
+
+      assert.equal( u.toNumber(), 4 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_equals-test.js

@@ -0,0 +1,62 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('equals method', function () {
+
+  describe('0==0', function () {
+
+    it('should return true', function (done) {
+      var u = UINT64(0).equals( UINT64(0) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('1==1', function () {
+
+    it('should return true', function (done) {
+      var u = UINT64(1).equals( UINT64(1) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('low bit', function () {
+
+    it('should return true', function (done) {
+      var u = UINT64(3).equals( UINT64(3) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('high bit', function () {
+
+    it('should return true', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT64(n).equals( UINT64(n) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('1!=2', function () {
+
+    it('should return false', function (done) {
+      var u = UINT64(1).equals( UINT64(2) )
+
+      assert( !u )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_greaterThan-test.js

@@ -0,0 +1,52 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('greaterThan method', function () {
+
+  describe('0>1', function () {
+
+    it('should return false', function (done) {
+      var u = UINT64(0).greaterThan( UINT64(1) )
+
+      assert( !u )
+      done()
+    })
+
+  })
+
+  describe('1>2', function () {
+
+    it('should return false', function (done) {
+      var u = UINT64(1).greaterThan( UINT64(2) )
+
+      assert( !u )
+      done()
+    })
+
+  })
+
+  describe('1>2^16', function () {
+
+    it('should return false', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(1).greaterThan( UINT64(n) )
+
+      assert( !u )
+      done()
+    })
+
+  })
+
+  describe('2^16>1', function () {
+
+    it('should return true', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(n).greaterThan( UINT64(1) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_lessThan-test.js

@@ -0,0 +1,52 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('lessThan method', function () {
+
+  describe('0<1', function () {
+
+    it('should return true', function (done) {
+      var u = UINT64(0).lessThan( UINT64(1) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('1<2', function () {
+
+    it('should return true', function (done) {
+      var u = UINT64(1).lessThan( UINT64(2) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('1<2^16', function () {
+
+    it('should return true', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(1).lessThan( UINT64(n) )
+
+      assert( u )
+      done()
+    })
+
+  })
+
+  describe('2^16<1', function () {
+
+    it('should return false', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(n).lessThan( UINT64(1) )
+
+      assert( !u )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_multiply-test.js

@@ -0,0 +1,75 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('multiply method', function () {
+
+  describe('0*0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(0).multiply( UINT64(0) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1*0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(1).multiply( UINT64(0) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('0*1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(0).multiply( UINT64(1) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('low bit*high bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT64(3).multiply( UINT64(n) )
+
+      assert.equal( u.toNumber(), 3*n )
+      done()
+    })
+
+  })
+
+  describe('high bit*low bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT64(n).multiply( UINT64(3) )
+
+      assert.equal( u.toNumber(), 3*n )
+      done()
+    })
+
+  })
+
+  describe('high bit*high bit', function () {
+
+    it('should return n', function (done) {
+      var n = 'FFFFFFFF'
+      var u = UINT64(n, 16).multiply( UINT64(n, 16) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_negate-test.js

@@ -0,0 +1,51 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('negate method', function () {
+
+  describe('0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(0).negate()
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1', function () {
+
+    it('should return -1', function (done) {
+      var u = UINT64(1).negate()
+
+      assert.equal( u.toNumber(), -1 )
+      done()
+    })
+
+  })
+
+  describe('low bit', function () {
+
+    it('should return -n', function (done) {
+      var u = UINT64(3).negate()
+
+      assert.equal( u.toNumber(), -3 )
+      done()
+    })
+
+  })
+
+  describe('high bit', function () {
+
+    it('should return -n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT64(n).negate()
+
+      assert.equal( u.toNumber(), -n )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_not-test.js

@@ -0,0 +1,45 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('not method', function () {
+
+  describe('0', function () {
+
+    it('should return 2^64-1', function (done) {
+      var u = UINT64(0).not()
+
+      assert.equal( u.toString(16), 'ffffffffffffffff' )
+      done()
+    })
+
+  })
+
+  describe('1', function () {
+
+    it('should return 2^64-2', function (done) {
+      var u = UINT64(1).not()
+
+      assert.equal( u.toString(16), 'fffffffffffffffe' )
+      done()
+    })
+
+  })
+
+  describe('2^63', function() {
+    var u = UINT64(0xFFFF, 0xFFFF, 0xFFFF, 0x7FFF).not()
+
+    assert.equal( u.toString(16), '8000000000000000')
+  })
+
+  describe('all bits set', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(0xFFFF, 0xFFFF, 0xFFFF, 0xFFFF).not()
+
+      assert.equal( u.toString(), '0' )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_or-test.js

@@ -0,0 +1,52 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('or method', function () {
+
+  describe('0|1', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT64(0).or( UINT64(1) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('1|2', function () {
+
+    it('should return 3', function (done) {
+      var u = UINT64(1).or( UINT64(2) )
+
+      assert.equal( u.toNumber(), 3 )
+      done()
+    })
+
+  })
+
+  describe('1|2^16', function () {
+
+    it('should return n+1', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(1).or( UINT64(n) )
+
+      assert.equal( u.toNumber(), n+1 )
+      done()
+    })
+
+  })
+
+  describe('2^16|1', function () {
+
+    it('should return n+1', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(n).or( UINT64(1) )
+
+      assert.equal( u.toNumber(), n+1 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_rotateLeft-test.js

@@ -0,0 +1,51 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('rotateLeft method', function () {
+
+  describe('0rotl1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(0).rotateLeft(1)
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1rotl2', function () {
+
+    it('should return 4', function (done) {
+      var u = UINT64(1).rotateLeft(2)
+
+      assert.equal( u.toNumber(), 4 )
+      done()
+    })
+
+  })
+
+  describe('1rotl16', function () {
+
+    it('should return 2^16', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(1).rotateLeft(16)
+
+      assert.equal( u.toNumber(), n )
+      done()
+    })
+
+  })
+
+  describe('1rotl32', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT64(1).rotateLeft(32)
+
+      assert.equal( u.toString(16), '100000000' )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_rotateRight-test.js

@@ -0,0 +1,51 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('rotateRight method', function () {
+
+  describe('0rotr1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(0).rotateRight(1)
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('4rotr1', function () {
+
+    it('should return 2', function (done) {
+      var u = UINT64(4).rotateRight(1)
+
+      assert.equal( u.toNumber(), 2 )
+      done()
+    })
+
+  })
+
+  describe('2^16rotr16', function () {
+
+    it('should return 1', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(n).rotateRight(16)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('1rotr32', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT64(1).rotateRight(32)
+
+      assert.equal( u.toString(16), '100000000' )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_shiftLeft-test.js

@@ -0,0 +1,73 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('shiftLeft method', function () {
+
+  describe('0<<1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(0).shiftLeft(1)
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1<<2', function () {
+
+    it('should return 4', function (done) {
+      var u = UINT64(1).shiftLeft(2)
+
+      assert.equal( u.toNumber(), 4 )
+      done()
+    })
+
+  })
+
+  describe('1<<16', function () {
+
+    it('should return 2^16', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(1).shiftLeft(16)
+
+      assert.equal( u.toNumber(), n )
+      done()
+    })
+
+  })
+
+  describe('1<<32', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(1).shiftLeft(32)
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1<<31', function () {
+
+    it('should return 2^31', function (done) {
+      var u = UINT64(1).shiftLeft(31)
+
+      assert.equal( u.toString(16), '80000000' )
+      done()
+    })
+
+  })
+
+  describe('9<<28', function () {
+
+    it('should return 2^31', function (done) {
+      var u = UINT64(9).shiftLeft(28)
+
+      assert.equal( u.toString(16), '90000000' )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_shiftRight-test.js

@@ -0,0 +1,95 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('shiftRight method', function () {
+
+  describe('0>>1', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(0).shiftRight(1)
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('4>>2', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT64(4).shiftRight(2)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('2^16>>16', function () {
+
+    it('should return 1', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(n).shiftRight(16)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('1>>32', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(1).shiftRight(32)
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('2^31>>31', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT64('80000000', 16).shiftRight(31)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('2^28>>28', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT64('10000000', 16).shiftRight(28)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('2^31+2^28>>31', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT64('90000000', 16).shiftRight(31)
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('2^31+2^28>>28', function () {
+
+    it('should return 9', function (done) {
+      var u = UINT64('90000000', 16).shiftRight(28)
+
+      assert.equal( u.toNumber(), 9 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_subtract-test.js

@@ -0,0 +1,75 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('subtract method', function () {
+
+  describe('0-0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(0).subtract( UINT64(0) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+  describe('1-0', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT64(1).subtract( UINT64(0) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('0-1', function () {
+
+    it('should return -1', function (done) {
+      var u = UINT64(0).subtract( UINT64(1) )
+
+      assert.equal( u.toNumber(), -1 )
+      done()
+    })
+
+  })
+
+  describe('low bit-high bit', function () {
+
+    it('should return 0', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT64(1).subtract( UINT64(n) )
+
+      assert.equal( u.toNumber(), 1-n )
+      done()
+    })
+
+  })
+
+  describe('high bit-low bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT64(n).subtract( UINT64(123) )
+
+      assert.equal( u.toNumber(), n - 123 )
+      done()
+    })
+
+  })
+
+  describe('high bit-high bit', function () {
+
+    it('should return n', function (done) {
+      var n = Math.pow(2, 17)
+      var u = UINT64(n+1).subtract( UINT64(n) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_toNumber-test.js

@@ -0,0 +1,63 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('toNumber method', function () {
+
+  describe('from 0', function () {
+
+    it('should return 0', function (done) {
+      var u = UINT64(0).toNumber()
+
+      assert.equal( u, 0 )
+      done()
+    })
+
+  })
+
+  describe('from low bit number', function () {
+
+    it('should return the number', function (done) {
+      var u = UINT64(123).toNumber()
+
+      assert.equal( u, 123 )
+      done()
+    })
+
+  })
+
+  describe('from high bit number', function () {
+
+    it('should return the number', function (done) {
+      var n = Math.pow(2,17)
+      var u = UINT64(n).toNumber()
+
+      assert.equal( u, n )
+      done()
+    })
+
+  })
+
+  describe('from high and low bit number', function () {
+
+    it('should return the number', function (done) {
+      var n = Math.pow(2,17) + 123
+      var u = UINT64(n).toNumber()
+
+      assert.equal( u, n )
+      done()
+    })
+
+  })
+
+  describe('toNumber and toString', function () {
+
+    it('should return the same result for 100 random numbers', function () {
+      for (var i=0; i<100; i++) {
+        var u = UINT64(Math.floor(Math.random() * 0xffffffff), 0);
+        assert.equal(u.toNumber(), parseInt(u.toString()));
+      }
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_toString-test.js

@@ -0,0 +1,74 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('toString method', function () {
+
+  describe('from 0', function () {
+
+    it('should return "0"', function (done) {
+      var u = UINT64(0).toString()
+
+      assert.equal( u, '0' )
+      done()
+    })
+
+  })
+
+  describe('from low bit number', function () {
+
+    it('should return the number', function (done) {
+      var u = UINT64(123).toString()
+
+      assert.equal( u, '123' )
+      done()
+    })
+
+  })
+
+  describe('from high bit number', function () {
+
+    it('should return the number', function (done) {
+      var n = Math.pow(2,17)
+      var u = UINT64(n).toString()
+
+      assert.equal( u, ''+n )
+      done()
+    })
+
+  })
+
+  describe('from high and low bit number', function () {
+
+    it('should return the number', function (done) {
+      var n = Math.pow(2,17) + 123
+      var u = UINT64(n).toString()
+
+      assert.equal( u, ''+n )
+      done()
+    })
+
+  })
+
+  describe('< radix', function () {
+
+    it('should return the number', function (done) {
+      var u = UINT64(4).toString()
+
+      assert.equal( u, '4' )
+      done()
+    })
+
+  })
+
+  describe('= radix', function () {
+
+    it('should return the number', function (done) {
+      var u = UINT64(2).toString(2)
+
+      assert.equal( u, '10' )
+      done()
+    })
+
+  })
+
+})

app/node_modules/cuint/test/UINT64_xor-test.js

@@ -0,0 +1,64 @@
+var assert = require('assert')
+var UINT64 = require('..').UINT64
+
+describe('xor method', function () {
+
+  describe('0^1', function () {
+
+    it('should return 1', function (done) {
+      var u = UINT64(0).xor( UINT64(1) )
+
+      assert.equal( u.toNumber(), 1 )
+      done()
+    })
+
+  })
+
+  describe('1^2', function () {
+
+    it('should return 3', function (done) {
+      var u = UINT64(1).xor( UINT64(2) )
+
+      assert.equal( u.toNumber(), 3 )
+      done()
+    })
+
+  })
+
+  describe('1^2^16', function () {
+
+    it('should return n+1', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(1).xor( UINT64(n) )
+
+      assert.equal( u.toNumber(), n+1 )
+      done()
+    })
+
+  })
+
+  describe('2^16^1', function () {
+
+    it('should return n+1', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(n).xor( UINT64(1) )
+
+      assert.equal( u.toNumber(), n+1 )
+      done()
+    })
+
+  })
+
+  describe('2^16^2^16', function () {
+
+    it('should return 0', function (done) {
+      var n = Math.pow(2, 16)
+      var u = UINT64(n).xor( UINT64(n) )
+
+      assert.equal( u.toNumber(), 0 )
+      done()
+    })
+
+  })
+
+})