Update

4 files changed, 1101 insertions, 0 deletions

diff --git a/alarm/node_modules/cuint/build/uint32.js b/alarm/node_modules/cuint/build/uint32.js
new file mode 100644
index 0000000..8e99538
--- /dev/null
+++ b/alarm/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)
diff --git a/alarm/node_modules/cuint/build/uint32.min.js b/alarm/node_modules/cuint/build/uint32.min.js
new file mode 100644
index 0000000..299e070
--- /dev/null
+++ b/alarm/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);
\ No newline at end of file
diff --git a/alarm/node_modules/cuint/build/uint64.js b/alarm/node_modules/cuint/build/uint64.js
new file mode 100644
index 0000000..bb90522
--- /dev/null
+++ b/alarm/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)
diff --git a/alarm/node_modules/cuint/build/uint64.min.js b/alarm/node_modules/cuint/build/uint64.min.js
new file mode 100644
index 0000000..6143756
--- /dev/null
+++ b/alarm/node_modules/cuint/build/uint64.min.js
@@ -0,0 +1 @@
+!function(t){function i(t,_,r,e){return this instanceof i?(this.remainder=null,"string"==typeof t?h.call(this,t,_):"undefined"==typeof _?s.call(this,t):void a.apply(this,arguments)):new i(t,_,r,e)}function a(t,i,a,s){return"undefined"==typeof a?(this._a00=65535&t,this._a16=t>>>16,this._a32=65535&i,this._a48=i>>>16,this):(this._a00=0|t,this._a16=0|i,this._a32=0|a,this._a48=0|s,this)}function s(t){return this._a00=65535&t,this._a16=t>>>16,this._a32=0,this._a48=0,this}function h(t,a){a=a||10,this._a00=0,this._a16=0,this._a32=0,this._a48=0;for(var s=_[a]||new i(Math.pow(a,5)),h=0,r=t.length;r>h;h+=5){var e=Math.min(5,r-h),n=parseInt(t.slice(h,h+e),a);this.multiply(5>e?new i(Math.pow(a,e)):s).add(new i(n))}return this}var _={16:i(Math.pow(16,5)),10:i(Math.pow(10,5)),2:i(Math.pow(2,5))},r={16:i(16),10:i(10),2:i(2)};i.prototype.fromBits=a,i.prototype.fromNumber=s,i.prototype.fromString=h,i.prototype.toNumber=function(){return 65536*this._a16+this._a00},i.prototype.toString=function(t){t=t||10;var a=r[t]||new i(t);if(!this.gt(a))return this.toNumber().toString(t);for(var s=this.clone(),h=new Array(64),_=63;_>=0&&(s.div(a),h[_]=s.remainder.toNumber().toString(t),s.gt(a));_--);return h[_-1]=s.toNumber().toString(t),h.join("")},i.prototype.add=function(t){var i=this._a00+t._a00,a=i>>>16;a+=this._a16+t._a16;var s=a>>>16;s+=this._a32+t._a32;var h=s>>>16;return h+=this._a48+t._a48,this._a00=65535&i,this._a16=65535&a,this._a32=65535&s,this._a48=65535&h,this},i.prototype.subtract=function(t){return this.add(t.clone().negate())},i.prototype.multiply=function(t){var i=this._a00,a=this._a16,s=this._a32,h=this._a48,_=t._a00,r=t._a16,e=t._a32,n=t._a48,o=i*_,u=o>>>16;u+=i*r;var p=u>>>16;u&=65535,u+=a*_,p+=u>>>16,p+=i*e;var f=p>>>16;return p&=65535,p+=a*r,f+=p>>>16,p&=65535,p+=s*_,f+=p>>>16,f+=i*n,f&=65535,f+=a*e,f&=65535,f+=s*r,f&=65535,f+=h*_,this._a00=65535&o,this._a16=65535&u,this._a32=65535&p,this._a48=65535&f,this},i.prototype.div=function(t){if(0==t._a16&&0==t._a32&&0==t._a48){if(0==t._a00)throw Error("division by zero");if(1==t._a00)return this.remainder=new i(0),this}if(t.gt(this))return this.remainder=this.clone(),this._a00=0,this._a16=0,this._a32=0,this._a48=0,this;if(this.eq(t))return this.remainder=new i(0),this._a00=1,this._a16=0,this._a32=0,this._a48=0,this;for(var a=t.clone(),s=-1;!this.lt(a);)a.shiftLeft(1,!0),s++;for(this.remainder=this.clone(),this._a00=0,this._a16=0,this._a32=0,this._a48=0;s>=0;s--)a.shiftRight(1),this.remainder.lt(a)||(this.remainder.subtract(a),s>=48?this._a48|=1<<s-48:s>=32?this._a32|=1<<s-32:s>=16?this._a16|=1<<s-16:this._a00|=1<<s);return this},i.prototype.negate=function(){var t=(65535&~this._a00)+1;return this._a00=65535&t,t=(65535&~this._a16)+(t>>>16),this._a16=65535&t,t=(65535&~this._a32)+(t>>>16),this._a32=65535&t,this._a48=~this._a48+(t>>>16)&65535,this},i.prototype.equals=i.prototype.eq=function(t){return this._a48==t._a48&&this._a00==t._a00&&this._a32==t._a32&&this._a16==t._a16},i.prototype.greaterThan=i.prototype.gt=function(t){return this._a48>t._a48?!0:this._a48<t._a48?!1:this._a32>t._a32?!0:this._a32<t._a32?!1:this._a16>t._a16?!0:this._a16<t._a16?!1:this._a00>t._a00},i.prototype.lessThan=i.prototype.lt=function(t){return this._a48<t._a48?!0:this._a48>t._a48?!1:this._a32<t._a32?!0:this._a32>t._a32?!1:this._a16<t._a16?!0:this._a16>t._a16?!1:this._a00<t._a00},i.prototype.or=function(t){return this._a00|=t._a00,this._a16|=t._a16,this._a32|=t._a32,this._a48|=t._a48,this},i.prototype.and=function(t){return this._a00&=t._a00,this._a16&=t._a16,this._a32&=t._a32,this._a48&=t._a48,this},i.prototype.xor=function(t){return this._a00^=t._a00,this._a16^=t._a16,this._a32^=t._a32,this._a48^=t._a48,this},i.prototype.not=function(){return this._a00=65535&~this._a00,this._a16=65535&~this._a16,this._a32=65535&~this._a32,this._a48=65535&~this._a48,this},i.prototype.shiftRight=i.prototype.shiftr=function(t){return t%=64,t>=48?(this._a00=this._a48>>t-48,this._a16=0,this._a32=0,this._a48=0):t>=32?(t-=32,this._a00=65535&(this._a32>>t|this._a48<<16-t),this._a16=this._a48>>t&65535,this._a32=0,this._a48=0):t>=16?(t-=16,this._a00=65535&(this._a16>>t|this._a32<<16-t),this._a16=65535&(this._a32>>t|this._a48<<16-t),this._a32=this._a48>>t&65535,this._a48=0):(this._a00=65535&(this._a00>>t|this._a16<<16-t),this._a16=65535&(this._a16>>t|this._a32<<16-t),this._a32=65535&(this._a32>>t|this._a48<<16-t),this._a48=this._a48>>t&65535),this},i.prototype.shiftLeft=i.prototype.shiftl=function(t,i){return t%=64,t>=48?(this._a48=this._a00<<t-48,this._a32=0,this._a16=0,this._a00=0):t>=32?(t-=32,this._a48=this._a16<<t|this._a00>>16-t,this._a32=this._a00<<t&65535,this._a16=0,this._a00=0):t>=16?(t-=16,this._a48=this._a32<<t|this._a16>>16-t,this._a32=65535&(this._a16<<t|this._a00>>16-t),this._a16=this._a00<<t&65535,this._a00=0):(this._a48=this._a48<<t|this._a32>>16-t,this._a32=65535&(this._a32<<t|this._a16>>16-t),this._a16=65535&(this._a16<<t|this._a00>>16-t),this._a00=this._a00<<t&65535),i||(this._a48&=65535),this},i.prototype.rotateLeft=i.prototype.rotl=function(t){if(t%=64,0==t)return this;if(t>=32){var i=this._a00;if(this._a00=this._a32,this._a32=i,i=this._a48,this._a48=this._a16,this._a16=i,32==t)return this;t-=32}var a=this._a48<<16|this._a32,s=this._a16<<16|this._a00,h=a<<t|s>>>32-t,_=s<<t|a>>>32-t;return this._a00=65535&_,this._a16=_>>>16,this._a32=65535&h,this._a48=h>>>16,this},i.prototype.rotateRight=i.prototype.rotr=function(t){if(t%=64,0==t)return this;if(t>=32){var i=this._a00;if(this._a00=this._a32,this._a32=i,i=this._a48,this._a48=this._a16,this._a16=i,32==t)return this;t-=32}var a=this._a48<<16|this._a32,s=this._a16<<16|this._a00,h=a>>>t|s<<32-t,_=s>>>t|a<<32-t;return this._a00=65535&_,this._a16=_>>>16,this._a32=65535&h,this._a48=h>>>16,this},i.prototype.clone=function(){return new i(this._a00,this._a16,this._a32,this._a48)},"undefined"!=typeof define&&define.amd?define([],function(){return i}):"undefined"!=typeof module&&module.exports?module.exports=i:t.UINT64=i}(this);
\ No newline at end of file