long - npm Package Compare versions

long

Package Overview

Dependencies

Maintainers

Advanced tools

Install Socket

Detect and block malicious and high-risk dependencies

Install

Comparing version 3.2.0 to 4.0.0

dist/long.js.map

1211

dist/long.js

		@@ -1,1209 +0,2 @@
		/*
		Copyright 2013 Daniel Wirtz <dcode@dcode.io>
		Copyright 2009 The Closure Library Authors. All Rights Reserved.

		Licensed under the Apache License, Version 2.0 (the "License");
		you may not use this file except in compliance with the License.
		You may obtain a copy of the License at

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

		Unless required by applicable law or agreed to in writing, software
		distributed under the License is distributed on an "AS-IS" BASIS,
		WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		See the License for the specific language governing permissions and
		limitations under the License.
		*/

		/**
		* @license long.js (c) 2013 Daniel Wirtz <dcode@dcode.io>
		* Released under the Apache License, Version 2.0
		* see: https://github.com/dcodeIO/long.js for details
		*/
		(function(global, factory) {

		/* AMD */ if (typeof define === 'function' && define["amd"])
		define([], factory);
		/* CommonJS */ else if (typeof require === 'function' && typeof module === "object" && module && module["exports"])
		module["exports"] = factory();
		/* Global */ else
		(global["dcodeIO"] = global["dcodeIO"] \|\| {})["Long"] = factory();

		})(this, function() {
		"use strict";

		/**
		* Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as signed integers.
		* See the from* functions below for more convenient ways of constructing Longs.
		* @exports Long
		* @class A Long class for representing a 64 bit two's-complement integer value.
		* @param {number} low The low (signed) 32 bits of the long
		* @param {number} high The high (signed) 32 bits of the long
		* @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
		* @constructor
		*/
		function Long(low, high, unsigned) {

		/**
		* The low 32 bits as a signed value.
		* @type {number}
		*/
		this.low = low \| 0;

		/**
		* The high 32 bits as a signed value.
		* @type {number}
		*/
		this.high = high \| 0;

		/**
		* Whether unsigned or not.
		* @type {boolean}
		*/
		this.unsigned = !!unsigned;
		}

		// The internal representation of a long is the two given signed, 32-bit values.
		// We use 32-bit pieces because these are the size of integers on which
		// Javascript performs bit-operations. For operations like addition and
		// multiplication, we split each number into 16 bit pieces, which can easily be
		// multiplied within Javascript's floating-point representation without overflow
		// or change in sign.
		//
		// In the algorithms below, we frequently reduce the negative case to the
		// positive case by negating the input(s) and then post-processing the result.
		// Note that we must ALWAYS check specially whether those values are MIN_VALUE
		// (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as
		// a positive number, it overflows back into a negative). Not handling this
		// case would often result in infinite recursion.
		//
		// Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*
		// methods on which they depend.

		/**
		* An indicator used to reliably determine if an object is a Long or not.
		* @type {boolean}
		* @const
		* @private
		*/
		Long.prototype.__isLong__;

		Object.defineProperty(Long.prototype, "__isLong__", {
		value: true,
		enumerable: false,
		configurable: false
		});

		/**
		* @function
		* @param {*} obj Object
		* @returns {boolean}
		* @inner
		*/
		function isLong(obj) {
		return (obj && obj["__isLong__"]) === true;
		}

		/**
		* Tests if the specified object is a Long.
		* @function
		* @param {*} obj Object
		* @returns {boolean}
		*/
		Long.isLong = isLong;

		/**
		* A cache of the Long representations of small integer values.
		* @type {!Object}
		* @inner
		*/
		var INT_CACHE = {};

		/**
		* A cache of the Long representations of small unsigned integer values.
		* @type {!Object}
		* @inner
		*/
		var UINT_CACHE = {};

		/**
		* @param {number} value
		* @param {boolean=} unsigned
		* @returns {!Long}
		* @inner
		*/
		function fromInt(value, unsigned) {
		var obj, cachedObj, cache;
		if (unsigned) {
		value >>>= 0;
		if (cache = (0 <= value && value < 256)) {
		cachedObj = UINT_CACHE[value];
		if (cachedObj)
		return cachedObj;
		}
		obj = fromBits(value, (value \| 0) < 0 ? -1 : 0, true);
		if (cache)
		UINT_CACHE[value] = obj;
		return obj;
		} else {
		value \|= 0;
		if (cache = (-128 <= value && value < 128)) {
		cachedObj = INT_CACHE[value];
		if (cachedObj)
		return cachedObj;
		}
		obj = fromBits(value, value < 0 ? -1 : 0, false);
		if (cache)
		INT_CACHE[value] = obj;
		return obj;
		}
		}

		/**
		* Returns a Long representing the given 32 bit integer value.
		* @function
		* @param {number} value The 32 bit integer in question
		* @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
		* @returns {!Long} The corresponding Long value
		*/
		Long.fromInt = fromInt;

		/**
		* @param {number} value
		* @param {boolean=} unsigned
		* @returns {!Long}
		* @inner
		*/
		function fromNumber(value, unsigned) {
		if (isNaN(value) \|\| !isFinite(value))
		return unsigned ? UZERO : ZERO;
		if (unsigned) {
		if (value < 0)
		return UZERO;
		if (value >= TWO_PWR_64_DBL)
		return MAX_UNSIGNED_VALUE;
		} else {
		if (value <= -TWO_PWR_63_DBL)
		return MIN_VALUE;
		if (value + 1 >= TWO_PWR_63_DBL)
		return MAX_VALUE;
		}
		if (value < 0)
		return fromNumber(-value, unsigned).neg();
		return fromBits((value % TWO_PWR_32_DBL) \| 0, (value / TWO_PWR_32_DBL) \| 0, unsigned);
		}

		/**
		* Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.
		* @function
		* @param {number} value The number in question
		* @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
		* @returns {!Long} The corresponding Long value
		*/
		Long.fromNumber = fromNumber;

		/**
		* @param {number} lowBits
		* @param {number} highBits
		* @param {boolean=} unsigned
		* @returns {!Long}
		* @inner
		*/
		function fromBits(lowBits, highBits, unsigned) {
		return new Long(lowBits, highBits, unsigned);
		}

		/**
		* Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is
		* assumed to use 32 bits.
		* @function
		* @param {number} lowBits The low 32 bits
		* @param {number} highBits The high 32 bits
		* @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
		* @returns {!Long} The corresponding Long value
		*/
		Long.fromBits = fromBits;

		/**
		* @function
		* @param {number} base
		* @param {number} exponent
		* @returns {number}
		* @inner
		*/
		var pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)

		/**
		* @param {string} str
		* @param {(boolean\|number)=} unsigned
		* @param {number=} radix
		* @returns {!Long}
		* @inner
		*/
		function fromString(str, unsigned, radix) {
		if (str.length === 0)
		throw Error('empty string');
		if (str === "NaN" \|\| str === "Infinity" \|\| str === "+Infinity" \|\| str === "-Infinity")
		return ZERO;
		if (typeof unsigned === 'number') {
		// For goog.math.long compatibility
		radix = unsigned,
		unsigned = false;
		} else {
		unsigned = !! unsigned;
		}
		radix = radix \|\| 10;
		if (radix < 2 \|\| 36 < radix)
		throw RangeError('radix');

		var p;
		if ((p = str.indexOf('-')) > 0)
		throw Error('interior hyphen');
		else if (p === 0) {
		return fromString(str.substring(1), unsigned, radix).neg();
		}

		// Do several (8) digits each time through the loop, so as to
		// minimize the calls to the very expensive emulated div.
		var radixToPower = fromNumber(pow_dbl(radix, 8));

		var result = ZERO;
		for (var i = 0; i < str.length; i += 8) {
		var size = Math.min(8, str.length - i),
		value = parseInt(str.substring(i, i + size), radix);
		if (size < 8) {
		var power = fromNumber(pow_dbl(radix, size));
		result = result.mul(power).add(fromNumber(value));
		} else {
		result = result.mul(radixToPower);
		result = result.add(fromNumber(value));
		}
		}
		result.unsigned = unsigned;
		return result;
		}

		/**
		* Returns a Long representation of the given string, written using the specified radix.
		* @function
		* @param {string} str The textual representation of the Long
		* @param {(boolean\|number)=} unsigned Whether unsigned or not, defaults to `false` for signed
		* @param {number=} radix The radix in which the text is written (2-36), defaults to 10
		* @returns {!Long} The corresponding Long value
		*/
		Long.fromString = fromString;

		/**
		* @function
		* @param {!Long\|number\|string\|!{low: number, high: number, unsigned: boolean}} val
		* @returns {!Long}
		* @inner
		*/
		function fromValue(val) {
		if (val /* is compatible */ instanceof Long)
		return val;
		if (typeof val === 'number')
		return fromNumber(val);
		if (typeof val === 'string')
		return fromString(val);
		// Throws for non-objects, converts non-instanceof Long:
		return fromBits(val.low, val.high, val.unsigned);
		}

		/**
		* Converts the specified value to a Long.
		* @function
		* @param {!Long\|number\|string\|!{low: number, high: number, unsigned: boolean}} val Value
		* @returns {!Long}
		*/
		Long.fromValue = fromValue;

		// NOTE: the compiler should inline these constant values below and then remove these variables, so there should be
		// no runtime penalty for these.

		/**
		* @type {number}
		* @const
		* @inner
		*/
		var TWO_PWR_16_DBL = 1 << 16;

		/**
		* @type {number}
		* @const
		* @inner
		*/
		var TWO_PWR_24_DBL = 1 << 24;

		/**
		* @type {number}
		* @const
		* @inner
		*/
		var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;

		/**
		* @type {number}
		* @const
		* @inner
		*/
		var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;

		/**
		* @type {number}
		* @const
		* @inner
		*/
		var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;

		/**
		* @type {!Long}
		* @const
		* @inner
		*/
		var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);

		/**
		* @type {!Long}
		* @inner
		*/
		var ZERO = fromInt(0);

		/**
		* Signed zero.
		* @type {!Long}
		*/
		Long.ZERO = ZERO;

		/**
		* @type {!Long}
		* @inner
		*/
		var UZERO = fromInt(0, true);

		/**
		* Unsigned zero.
		* @type {!Long}
		*/
		Long.UZERO = UZERO;

		/**
		* @type {!Long}
		* @inner
		*/
		var ONE = fromInt(1);

		/**
		* Signed one.
		* @type {!Long}
		*/
		Long.ONE = ONE;

		/**
		* @type {!Long}
		* @inner
		*/
		var UONE = fromInt(1, true);

		/**
		* Unsigned one.
		* @type {!Long}
		*/
		Long.UONE = UONE;

		/**
		* @type {!Long}
		* @inner
		*/
		var NEG_ONE = fromInt(-1);

		/**
		* Signed negative one.
		* @type {!Long}
		*/
		Long.NEG_ONE = NEG_ONE;

		/**
		* @type {!Long}
		* @inner
		*/
		var MAX_VALUE = fromBits(0xFFFFFFFF\|0, 0x7FFFFFFF\|0, false);

		/**
		* Maximum signed value.
		* @type {!Long}
		*/
		Long.MAX_VALUE = MAX_VALUE;

		/**
		* @type {!Long}
		* @inner
		*/
		var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF\|0, 0xFFFFFFFF\|0, true);

		/**
		* Maximum unsigned value.
		* @type {!Long}
		*/
		Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;

		/**
		* @type {!Long}
		* @inner
		*/
		var MIN_VALUE = fromBits(0, 0x80000000\|0, false);

		/**
		* Minimum signed value.
		* @type {!Long}
		*/
		Long.MIN_VALUE = MIN_VALUE;

		/**
		* @alias Long.prototype
		* @inner
		*/
		var LongPrototype = Long.prototype;

		/**
		* Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.
		* @returns {number}
		*/
		LongPrototype.toInt = function toInt() {
		return this.unsigned ? this.low >>> 0 : this.low;
		};

		/**
		* Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).
		* @returns {number}
		*/
		LongPrototype.toNumber = function toNumber() {
		if (this.unsigned)
		return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0);
		return this.high * TWO_PWR_32_DBL + (this.low >>> 0);
		};

		/**
		* Converts the Long to a string written in the specified radix.
		* @param {number=} radix Radix (2-36), defaults to 10
		* @returns {string}
		* @override
		* @throws {RangeError} If `radix` is out of range
		*/
		LongPrototype.toString = function toString(radix) {
		radix = radix \|\| 10;
		if (radix < 2 \|\| 36 < radix)
		throw RangeError('radix');
		if (this.isZero())
		return '0';
		if (this.isNegative()) { // Unsigned Longs are never negative
		if (this.eq(MIN_VALUE)) {
		// We need to change the Long value before it can be negated, so we remove
		// the bottom-most digit in this base and then recurse to do the rest.
		var radixLong = fromNumber(radix),
		div = this.div(radixLong),
		rem1 = div.mul(radixLong).sub(this);
		return div.toString(radix) + rem1.toInt().toString(radix);
		} else
		return '-' + this.neg().toString(radix);
		}

		// Do several (6) digits each time through the loop, so as to
		// minimize the calls to the very expensive emulated div.
		var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),
		rem = this;
		var result = '';
		while (true) {
		var remDiv = rem.div(radixToPower),
		intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,
		digits = intval.toString(radix);
		rem = remDiv;
		if (rem.isZero())
		return digits + result;
		else {
		while (digits.length < 6)
		digits = '0' + digits;
		result = '' + digits + result;
		}
		}
		};

		/**
		* Gets the high 32 bits as a signed integer.
		* @returns {number} Signed high bits
		*/
		LongPrototype.getHighBits = function getHighBits() {
		return this.high;
		};

		/**
		* Gets the high 32 bits as an unsigned integer.
		* @returns {number} Unsigned high bits
		*/
		LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {
		return this.high >>> 0;
		};

		/**
		* Gets the low 32 bits as a signed integer.
		* @returns {number} Signed low bits
		*/
		LongPrototype.getLowBits = function getLowBits() {
		return this.low;
		};

		/**
		* Gets the low 32 bits as an unsigned integer.
		* @returns {number} Unsigned low bits
		*/
		LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {
		return this.low >>> 0;
		};

		/**
		* Gets the number of bits needed to represent the absolute value of this Long.
		* @returns {number}
		*/
		LongPrototype.getNumBitsAbs = function getNumBitsAbs() {
		if (this.isNegative()) // Unsigned Longs are never negative
		return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();
		var val = this.high != 0 ? this.high : this.low;
		for (var bit = 31; bit > 0; bit--)
		if ((val & (1 << bit)) != 0)
		break;
		return this.high != 0 ? bit + 33 : bit + 1;
		};

		/**
		* Tests if this Long's value equals zero.
		* @returns {boolean}
		*/
		LongPrototype.isZero = function isZero() {
		return this.high === 0 && this.low === 0;
		};

		/**
		* Tests if this Long's value is negative.
		* @returns {boolean}
		*/
		LongPrototype.isNegative = function isNegative() {
		return !this.unsigned && this.high < 0;
		};

		/**
		* Tests if this Long's value is positive.
		* @returns {boolean}
		*/
		LongPrototype.isPositive = function isPositive() {
		return this.unsigned \|\| this.high >= 0;
		};

		/**
		* Tests if this Long's value is odd.
		* @returns {boolean}
		*/
		LongPrototype.isOdd = function isOdd() {
		return (this.low & 1) === 1;
		};

		/**
		* Tests if this Long's value is even.
		* @returns {boolean}
		*/
		LongPrototype.isEven = function isEven() {
		return (this.low & 1) === 0;
		};

		/**
		* Tests if this Long's value equals the specified's.
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.equals = function equals(other) {
		if (!isLong(other))
		other = fromValue(other);
		if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1)
		return false;
		return this.high === other.high && this.low === other.low;
		};

		/**
		* Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.
		* @function
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.eq = LongPrototype.equals;

		/**
		* Tests if this Long's value differs from the specified's.
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.notEquals = function notEquals(other) {
		return !this.eq(/* validates */ other);
		};

		/**
		* Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.
		* @function
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.neq = LongPrototype.notEquals;

		/**
		* Tests if this Long's value is less than the specified's.
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.lessThan = function lessThan(other) {
		return this.comp(/* validates */ other) < 0;
		};

		/**
		* Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.
		* @function
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.lt = LongPrototype.lessThan;

		/**
		* Tests if this Long's value is less than or equal the specified's.
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {
		return this.comp(/* validates */ other) <= 0;
		};

		/**
		* Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.
		* @function
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.lte = LongPrototype.lessThanOrEqual;

		/**
		* Tests if this Long's value is greater than the specified's.
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.greaterThan = function greaterThan(other) {
		return this.comp(/* validates */ other) > 0;
		};

		/**
		* Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.
		* @function
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.gt = LongPrototype.greaterThan;

		/**
		* Tests if this Long's value is greater than or equal the specified's.
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {
		return this.comp(/* validates */ other) >= 0;
		};

		/**
		* Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.
		* @function
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.gte = LongPrototype.greaterThanOrEqual;

		/**
		* Compares this Long's value with the specified's.
		* @param {!Long\|number\|string} other Other value
		* @returns {number} 0 if they are the same, 1 if the this is greater and -1
		* if the given one is greater
		*/
		LongPrototype.compare = function compare(other) {
		if (!isLong(other))
		other = fromValue(other);
		if (this.eq(other))
		return 0;
		var thisNeg = this.isNegative(),
		otherNeg = other.isNegative();
		if (thisNeg && !otherNeg)
		return -1;
		if (!thisNeg && otherNeg)
		return 1;
		// At this point the sign bits are the same
		if (!this.unsigned)
		return this.sub(other).isNegative() ? -1 : 1;
		// Both are positive if at least one is unsigned
		return (other.high >>> 0) > (this.high >>> 0) \|\| (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1;
		};

		/**
		* Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.
		* @function
		* @param {!Long\|number\|string} other Other value
		* @returns {number} 0 if they are the same, 1 if the this is greater and -1
		* if the given one is greater
		*/
		LongPrototype.comp = LongPrototype.compare;

		/**
		* Negates this Long's value.
		* @returns {!Long} Negated Long
		*/
		LongPrototype.negate = function negate() {
		if (!this.unsigned && this.eq(MIN_VALUE))
		return MIN_VALUE;
		return this.not().add(ONE);
		};

		/**
		* Negates this Long's value. This is an alias of {@link Long#negate}.
		* @function
		* @returns {!Long} Negated Long
		*/
		LongPrototype.neg = LongPrototype.negate;

		/**
		* Returns the sum of this and the specified Long.
		* @param {!Long\|number\|string} addend Addend
		* @returns {!Long} Sum
		*/
		LongPrototype.add = function add(addend) {
		if (!isLong(addend))
		addend = fromValue(addend);

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

		var a48 = this.high >>> 16;
		var a32 = this.high & 0xFFFF;
		var a16 = this.low >>> 16;
		var a00 = this.low & 0xFFFF;

		var b48 = addend.high >>> 16;
		var b32 = addend.high & 0xFFFF;
		var b16 = addend.low >>> 16;
		var b00 = addend.low & 0xFFFF;

		var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
		c00 += a00 + b00;
		c16 += c00 >>> 16;
		c00 &= 0xFFFF;
		c16 += a16 + b16;
		c32 += c16 >>> 16;
		c16 &= 0xFFFF;
		c32 += a32 + b32;
		c48 += c32 >>> 16;
		c32 &= 0xFFFF;
		c48 += a48 + b48;
		c48 &= 0xFFFF;
		return fromBits((c16 << 16) \| c00, (c48 << 16) \| c32, this.unsigned);
		};

		/**
		* Returns the difference of this and the specified Long.
		* @param {!Long\|number\|string} subtrahend Subtrahend
		* @returns {!Long} Difference
		*/
		LongPrototype.subtract = function subtract(subtrahend) {
		if (!isLong(subtrahend))
		subtrahend = fromValue(subtrahend);
		return this.add(subtrahend.neg());
		};

		/**
		* Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.
		* @function
		* @param {!Long\|number\|string} subtrahend Subtrahend
		* @returns {!Long} Difference
		*/
		LongPrototype.sub = LongPrototype.subtract;

		/**
		* Returns the product of this and the specified Long.
		* @param {!Long\|number\|string} multiplier Multiplier
		* @returns {!Long} Product
		*/
		LongPrototype.multiply = function multiply(multiplier) {
		if (this.isZero())
		return ZERO;
		if (!isLong(multiplier))
		multiplier = fromValue(multiplier);
		if (multiplier.isZero())
		return ZERO;
		if (this.eq(MIN_VALUE))
		return multiplier.isOdd() ? MIN_VALUE : ZERO;
		if (multiplier.eq(MIN_VALUE))
		return this.isOdd() ? MIN_VALUE : ZERO;

		if (this.isNegative()) {
		if (multiplier.isNegative())
		return this.neg().mul(multiplier.neg());
		else
		return this.neg().mul(multiplier).neg();
		} else if (multiplier.isNegative())
		return this.mul(multiplier.neg()).neg();

		// If both longs are small, use float multiplication
		if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))
		return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);

		// Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.
		// We can skip products that would overflow.

		var a48 = this.high >>> 16;
		var a32 = this.high & 0xFFFF;
		var a16 = this.low >>> 16;
		var a00 = this.low & 0xFFFF;

		var b48 = multiplier.high >>> 16;
		var b32 = multiplier.high & 0xFFFF;
		var b16 = multiplier.low >>> 16;
		var b00 = multiplier.low & 0xFFFF;

		var c48 = 0, c32 = 0, c16 = 0, c00 = 0;
		c00 += a00 * b00;
		c16 += c00 >>> 16;
		c00 &= 0xFFFF;
		c16 += a16 * b00;
		c32 += c16 >>> 16;
		c16 &= 0xFFFF;
		c16 += a00 * b16;
		c32 += c16 >>> 16;
		c16 &= 0xFFFF;
		c32 += a32 * b00;
		c48 += c32 >>> 16;
		c32 &= 0xFFFF;
		c32 += a16 * b16;
		c48 += c32 >>> 16;
		c32 &= 0xFFFF;
		c32 += a00 * b32;
		c48 += c32 >>> 16;
		c32 &= 0xFFFF;
		c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;
		c48 &= 0xFFFF;
		return fromBits((c16 << 16) \| c00, (c48 << 16) \| c32, this.unsigned);
		};

		/**
		* Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.
		* @function
		* @param {!Long\|number\|string} multiplier Multiplier
		* @returns {!Long} Product
		*/
		LongPrototype.mul = LongPrototype.multiply;

		/**
		* Returns this Long divided by the specified. The result is signed if this Long is signed or
		* unsigned if this Long is unsigned.
		* @param {!Long\|number\|string} divisor Divisor
		* @returns {!Long} Quotient
		*/
		LongPrototype.divide = function divide(divisor) {
		if (!isLong(divisor))
		divisor = fromValue(divisor);
		if (divisor.isZero())
		throw Error('division by zero');
		if (this.isZero())
		return this.unsigned ? UZERO : ZERO;
		var approx, rem, res;
		if (!this.unsigned) {
		// This section is only relevant for signed longs and is derived from the
		// closure library as a whole.
		if (this.eq(MIN_VALUE)) {
		if (divisor.eq(ONE) \|\| divisor.eq(NEG_ONE))
		return MIN_VALUE; // recall that -MIN_VALUE == MIN_VALUE
		else if (divisor.eq(MIN_VALUE))
		return ONE;
		else {
		// At this point, we have \|other\| >= 2, so \|this/other\| < \|MIN_VALUE\|.
		var halfThis = this.shr(1);
		approx = halfThis.div(divisor).shl(1);
		if (approx.eq(ZERO)) {
		return divisor.isNegative() ? ONE : NEG_ONE;
		} else {
		rem = this.sub(divisor.mul(approx));
		res = approx.add(rem.div(divisor));
		return res;
		}
		}
		} else if (divisor.eq(MIN_VALUE))
		return this.unsigned ? UZERO : ZERO;
		if (this.isNegative()) {
		if (divisor.isNegative())
		return this.neg().div(divisor.neg());
		return this.neg().div(divisor).neg();
		} else if (divisor.isNegative())
		return this.div(divisor.neg()).neg();
		res = ZERO;
		} else {
		// The algorithm below has not been made for unsigned longs. It's therefore
		// required to take special care of the MSB prior to running it.
		if (!divisor.unsigned)
		divisor = divisor.toUnsigned();
		if (divisor.gt(this))
		return UZERO;
		if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true
		return UONE;
		res = UZERO;
		}

		// Repeat the following until the remainder is less than other: find a
		// floating-point that approximates remainder / other from below, add this
		// into the result, and subtract it from the remainder. It is critical that
		// the approximate value is less than or equal to the real value so that the
		// remainder never becomes negative.
		rem = this;
		while (rem.gte(divisor)) {
		// Approximate the result of division. This may be a little greater or
		// smaller than the actual value.
		approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));

		// We will tweak the approximate result by changing it in the 48-th digit or
		// the smallest non-fractional digit, whichever is larger.
		var log2 = Math.ceil(Math.log(approx) / Math.LN2),
		delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48),

		// Decrease the approximation until it is smaller than the remainder. Note
		// that if it is too large, the product overflows and is negative.
		approxRes = fromNumber(approx),
		approxRem = approxRes.mul(divisor);
		while (approxRem.isNegative() \|\| approxRem.gt(rem)) {
		approx -= delta;
		approxRes = fromNumber(approx, this.unsigned);
		approxRem = approxRes.mul(divisor);
		}

		// We know the answer can't be zero... and actually, zero would cause
		// infinite recursion since we would make no progress.
		if (approxRes.isZero())
		approxRes = ONE;

		res = res.add(approxRes);
		rem = rem.sub(approxRem);
		}
		return res;
		};

		/**
		* Returns this Long divided by the specified. This is an alias of {@link Long#divide}.
		* @function
		* @param {!Long\|number\|string} divisor Divisor
		* @returns {!Long} Quotient
		*/
		LongPrototype.div = LongPrototype.divide;

		/**
		* Returns this Long modulo the specified.
		* @param {!Long\|number\|string} divisor Divisor
		* @returns {!Long} Remainder
		*/
		LongPrototype.modulo = function modulo(divisor) {
		if (!isLong(divisor))
		divisor = fromValue(divisor);
		return this.sub(this.div(divisor).mul(divisor));
		};

		/**
		* Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.
		* @function
		* @param {!Long\|number\|string} divisor Divisor
		* @returns {!Long} Remainder
		*/
		LongPrototype.mod = LongPrototype.modulo;

		/**
		* Returns the bitwise NOT of this Long.
		* @returns {!Long}
		*/
		LongPrototype.not = function not() {
		return fromBits(~this.low, ~this.high, this.unsigned);
		};

		/**
		* Returns the bitwise AND of this Long and the specified.
		* @param {!Long\|number\|string} other Other Long
		* @returns {!Long}
		*/
		LongPrototype.and = function and(other) {
		if (!isLong(other))
		other = fromValue(other);
		return fromBits(this.low & other.low, this.high & other.high, this.unsigned);
		};

		/**
		* Returns the bitwise OR of this Long and the specified.
		* @param {!Long\|number\|string} other Other Long
		* @returns {!Long}
		*/
		LongPrototype.or = function or(other) {
		if (!isLong(other))
		other = fromValue(other);
		return fromBits(this.low \| other.low, this.high \| other.high, this.unsigned);
		};

		/**
		* Returns the bitwise XOR of this Long and the given one.
		* @param {!Long\|number\|string} other Other Long
		* @returns {!Long}
		*/
		LongPrototype.xor = function xor(other) {
		if (!isLong(other))
		other = fromValue(other);
		return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);
		};

		/**
		* Returns this Long with bits shifted to the left by the given amount.
		* @param {number\|!Long} numBits Number of bits
		* @returns {!Long} Shifted Long
		*/
		LongPrototype.shiftLeft = function shiftLeft(numBits) {
		if (isLong(numBits))
		numBits = numBits.toInt();
		if ((numBits &= 63) === 0)
		return this;
		else if (numBits < 32)
		return fromBits(this.low << numBits, (this.high << numBits) \| (this.low >>> (32 - numBits)), this.unsigned);
		else
		return fromBits(0, this.low << (numBits - 32), this.unsigned);
		};

		/**
		* Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.
		* @function
		* @param {number\|!Long} numBits Number of bits
		* @returns {!Long} Shifted Long
		*/
		LongPrototype.shl = LongPrototype.shiftLeft;

		/**
		* Returns this Long with bits arithmetically shifted to the right by the given amount.
		* @param {number\|!Long} numBits Number of bits
		* @returns {!Long} Shifted Long
		*/
		LongPrototype.shiftRight = function shiftRight(numBits) {
		if (isLong(numBits))
		numBits = numBits.toInt();
		if ((numBits &= 63) === 0)
		return this;
		else if (numBits < 32)
		return fromBits((this.low >>> numBits) \| (this.high << (32 - numBits)), this.high >> numBits, this.unsigned);
		else
		return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned);
		};

		/**
		* Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.
		* @function
		* @param {number\|!Long} numBits Number of bits
		* @returns {!Long} Shifted Long
		*/
		LongPrototype.shr = LongPrototype.shiftRight;

		/**
		* Returns this Long with bits logically shifted to the right by the given amount.
		* @param {number\|!Long} numBits Number of bits
		* @returns {!Long} Shifted Long
		*/
		LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {
		if (isLong(numBits))
		numBits = numBits.toInt();
		numBits &= 63;
		if (numBits === 0)
		return this;
		else {
		var high = this.high;
		if (numBits < 32) {
		var low = this.low;
		return fromBits((low >>> numBits) \| (high << (32 - numBits)), high >>> numBits, this.unsigned);
		} else if (numBits === 32)
		return fromBits(high, 0, this.unsigned);
		else
		return fromBits(high >>> (numBits - 32), 0, this.unsigned);
		}
		};

		/**
		* Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.
		* @function
		* @param {number\|!Long} numBits Number of bits
		* @returns {!Long} Shifted Long
		*/
		LongPrototype.shru = LongPrototype.shiftRightUnsigned;

		/**
		* Converts this Long to signed.
		* @returns {!Long} Signed long
		*/
		LongPrototype.toSigned = function toSigned() {
		if (!this.unsigned)
		return this;
		return fromBits(this.low, this.high, false);
		};

		/**
		* Converts this Long to unsigned.
		* @returns {!Long} Unsigned long
		*/
		LongPrototype.toUnsigned = function toUnsigned() {
		if (this.unsigned)
		return this;
		return fromBits(this.low, this.high, true);
		};

		/**
		* Converts this Long to its byte representation.
		* @param {boolean=} le Whether little or big endian, defaults to big endian
		* @returns {!Array.<number>} Byte representation
		*/
		LongPrototype.toBytes = function(le) {
		return le ? this.toBytesLE() : this.toBytesBE();
		}

		/**
		* Converts this Long to its little endian byte representation.
		* @returns {!Array.<number>} Little endian byte representation
		*/
		LongPrototype.toBytesLE = function() {
		var hi = this.high,
		lo = this.low;
		return [
		lo & 0xff,
		(lo >>> 8) & 0xff,
		(lo >>> 16) & 0xff,
		(lo >>> 24) & 0xff,
		hi & 0xff,
		(hi >>> 8) & 0xff,
		(hi >>> 16) & 0xff,
		(hi >>> 24) & 0xff
		];
		}

		/**
		* Converts this Long to its big endian byte representation.
		* @returns {!Array.<number>} Big endian byte representation
		*/
		LongPrototype.toBytesBE = function() {
		var hi = this.high,
		lo = this.low;
		return [
		(hi >>> 24) & 0xff,
		(hi >>> 16) & 0xff,
		(hi >>> 8) & 0xff,
		hi & 0xff,
		(lo >>> 24) & 0xff,
		(lo >>> 16) & 0xff,
		(lo >>> 8) & 0xff,
		lo & 0xff
		];
		}

		return Long;
		});
		!function(t,i){"object"==typeof exports&&"object"==typeof module?module.exports=i():"function"==typeof define&&define.amd?define([],i):"object"==typeof exports?exports.Long=i():t.Long=i()}("undefined"!=typeof self?self:this,function(){return function(t){function i(e){if(n[e])return n[e].exports;var r=n[e]={i:e,l:!1,exports:{}};return t[e].call(r.exports,r,r.exports,i),r.l=!0,r.exports}var n={};return i.m=t,i.c=n,i.d=function(t,n,e){i.o(t,n)\|\|Object.defineProperty(t,n,{configurable:!1,enumerable:!0,get:e})},i.n=function(t){var n=t&&t.__esModule?function(){return t.default}:function(){return t};return i.d(n,"a",n),n},i.o=function(t,i){return Object.prototype.hasOwnProperty.call(t,i)},i.p="",i(i.s=0)}([function(t,i){function n(t,i,n){this.low=0\|t,this.high=0\|i,this.unsigned=!!n}function e(t){return!0===(t&&t.__isLong__)}function r(t,i){var n,e,r;return i?(t>>>=0,(r=0<=t&&t<256)&&(e=l[t])?e:(n=h(t,(0\|t)<0?-1:0,!0),r&&(l[t]=n),n)):(t\|=0,(r=-128<=t&&t<128)&&(e=f[t])?e:(n=h(t,t<0?-1:0,!1),r&&(f[t]=n),n))}function s(t,i){if(isNaN(t))return i?p:m;if(i){if(t<0)return p;if(t>=c)return q}else{if(t<=-v)return _;if(t+1>=v)return E}return t<0?s(-t,i).neg():h(t%d\|0,t/d\|0,i)}function h(t,i,e){return new n(t,i,e)}function u(t,i,n){if(0===t.length)throw Error("empty string");if("NaN"===t\|\|"Infinity"===t\|\|"+Infinity"===t\|\|"-Infinity"===t)return m;if("number"==typeof i?(n=i,i=!1):i=!!i,(n=n\|\|10)<2\|\|36<n)throw RangeError("radix");var e;if((e=t.indexOf("-"))>0)throw Error("interior hyphen");if(0===e)return u(t.substring(1),i,n).neg();for(var r=s(a(n,8)),h=m,o=0;o<t.length;o+=8){var g=Math.min(8,t.length-o),f=parseInt(t.substring(o,o+g),n);if(g<8){var l=s(a(n,g));h=h.mul(l).add(s(f))}else h=h.mul(r),h=h.add(s(f))}return h.unsigned=i,h}function o(t,i){return"number"==typeof t?s(t,i):"string"==typeof t?u(t,i):h(t.low,t.high,"boolean"==typeof i?i:t.unsigned)}t.exports=n;var g=null;try{g=new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([0,97,115,109,1,0,0,0,1,13,2,96,0,1,127,96,4,127,127,127,127,1,127,3,7,6,0,1,1,1,1,1,6,6,1,127,1,65,0,11,7,50,6,3,109,117,108,0,1,5,100,105,118,95,115,0,2,5,100,105,118,95,117,0,3,5,114,101,109,95,115,0,4,5,114,101,109,95,117,0,5,8,103,101,116,95,104,105,103,104,0,0,10,191,1,6,4,0,35,0,11,36,1,1,126,32,0,173,32,1,173,66,32,134,132,32,2,173,32,3,173,66,32,134,132,126,34,4,66,32,135,167,36,0,32,4,167,11,36,1,1,126,32,0,173,32,1,173,66,32,134,132,32,2,173,32,3,173,66,32,134,132,127,34,4,66,32,135,167,36,0,32,4,167,11,36,1,1,126,32,0,173,32,1,173,66,32,134,132,32,2,173,32,3,173,66,32,134,132,128,34,4,66,32,135,167,36,0,32,4,167,11,36,1,1,126,32,0,173,32,1,173,66,32,134,132,32,2,173,32,3,173,66,32,134,132,129,34,4,66,32,135,167,36,0,32,4,167,11,36,1,1,126,32,0,173,32,1,173,66,32,134,132,32,2,173,32,3,173,66,32,134,132,130,34,4,66,32,135,167,36,0,32,4,167,11])),{}).exports}catch(t){}n.prototype.__isLong__,Object.defineProperty(n.prototype,"__isLong__",{value:!0}),n.isLong=e;var f={},l={};n.fromInt=r,n.fromNumber=s,n.fromBits=h;var a=Math.pow;n.fromString=u,n.fromValue=o;var d=4294967296,c=dd,v=c/2,w=r(1<<24),m=r(0);n.ZERO=m;var p=r(0,!0);n.UZERO=p;var y=r(1);n.ONE=y;var b=r(1,!0);n.UONE=b;var N=r(-1);n.NEG_ONE=N;var E=h(-1,2147483647,!1);n.MAX_VALUE=E;var q=h(-1,-1,!0);n.MAX_UNSIGNED_VALUE=q;var _=h(0,-2147483648,!1);n.MIN_VALUE=_;var B=n.prototype;B.toInt=function(){return this.unsigned?this.low>>>0:this.low},B.toNumber=function(){return this.unsigned?(this.high>>>0)d+(this.low>>>0):this.highd+(this.low>>>0)},B.toString=function(t){if((t=t\|\|10)<2\|\|36<t)throw RangeError("radix");if(this.isZero())return"0";if(this.isNegative()){if(this.eq(_)){var i=s(t),n=this.div(i),e=n.mul(i).sub(this);return n.toString(t)+e.toInt().toString(t)}return"-"+this.neg().toString(t)}for(var r=s(a(t,6),this.unsigned),h=this,u="";;){var o=h.div(r),g=h.sub(o.mul(r)).toInt()>>>0,f=g.toString(t);if(h=o,h.isZero())return f+u;for(;f.length<6;)f="0"+f;u=""+f+u}},B.getHighBits=function(){return this.high},B.getHighBitsUnsigned=function(){return this.high>>>0},B.getLowBits=function(){return this.low},B.getLowBitsUnsigned=function(){return this.low>>>0},B.getNumBitsAbs=function(){if(this.isNegative())return this.eq(_)?64:this.neg().getNumBitsAbs();for(var t=0!=this.high?this.high:this.low,i=31;i>0&&0==(t&1<<i);i--);return 0!=this.high?i+33:i+1},B.isZero=function(){return 0===this.high&&0===this.low},B.eqz=B.isZero,B.isNegative=function(){return!this.unsigned&&this.high<0},B.isPositive=function(){return this.unsigned\|\|this.high>=0},B.isOdd=function(){return 1==(1&this.low)},B.isEven=function(){return 0==(1&this.low)},B.equals=function(t){return e(t)\|\|(t=o(t)),(this.unsigned===t.unsigned\|\|this.high>>>31!=1\|\|t.high>>>31!=1)&&(this.high===t.high&&this.low===t.low)},B.eq=B.equals,B.notEquals=function(t){return!this.eq(t)},B.neq=B.notEquals,B.ne=B.notEquals,B.lessThan=function(t){return this.comp(t)<0},B.lt=B.lessThan,B.lessThanOrEqual=function(t){return this.comp(t)<=0},B.lte=B.lessThanOrEqual,B.le=B.lessThanOrEqual,B.greaterThan=function(t){return this.comp(t)>0},B.gt=B.greaterThan,B.greaterThanOrEqual=function(t){return this.comp(t)>=0},B.gte=B.greaterThanOrEqual,B.ge=B.greaterThanOrEqual,B.compare=function(t){if(e(t)\|\|(t=o(t)),this.eq(t))return 0;var i=this.isNegative(),n=t.isNegative();return i&&!n?-1:!i&&n?1:this.unsigned?t.high>>>0>this.high>>>0\|\|t.high===this.high&&t.low>>>0>this.low>>>0?-1:1:this.sub(t).isNegative()?-1:1},B.comp=B.compare,B.negate=function(){return!this.unsigned&&this.eq(_)?_:this.not().add(y)},B.neg=B.negate,B.add=function(t){e(t)\|\|(t=o(t));var i=this.high>>>16,n=65535&this.high,r=this.low>>>16,s=65535&this.low,u=t.high>>>16,g=65535&t.high,f=t.low>>>16,l=65535&t.low,a=0,d=0,c=0,v=0;return v+=s+l,c+=v>>>16,v&=65535,c+=r+f,d+=c>>>16,c&=65535,d+=n+g,a+=d>>>16,d&=65535,a+=i+u,a&=65535,h(c<<16\|v,a<<16\|d,this.unsigned)},B.subtract=function(t){return e(t)\|\|(t=o(t)),this.add(t.neg())},B.sub=B.subtract,B.multiply=function(t){if(this.isZero())return m;if(e(t)\|\|(t=o(t)),g){return h(g.mul(this.low,this.high,t.low,t.high),g.get_high(),this.unsigned)}if(t.isZero())return m;if(this.eq(_))return t.isOdd()?_:m;if(t.eq(_))return this.isOdd()?_:m;if(this.isNegative())return t.isNegative()?this.neg().mul(t.neg()):this.neg().mul(t).neg();if(t.isNegative())return this.mul(t.neg()).neg();if(this.lt(w)&&t.lt(w))return s(this.toNumber()t.toNumber(),this.unsigned);var i=this.high>>>16,n=65535&this.high,r=this.low>>>16,u=65535&this.low,f=t.high>>>16,l=65535&t.high,a=t.low>>>16,d=65535&t.low,c=0,v=0,p=0,y=0;return y+=ud,p+=y>>>16,y&=65535,p+=rd,v+=p>>>16,p&=65535,p+=ua,v+=p>>>16,p&=65535,v+=nd,c+=v>>>16,v&=65535,v+=ra,c+=v>>>16,v&=65535,v+=ul,c+=v>>>16,v&=65535,c+=id+na+rl+uf,c&=65535,h(p<<16\|y,c<<16\|v,this.unsigned)},B.mul=B.multiply,B.divide=function(t){if(e(t)\|\|(t=o(t)),t.isZero())throw Error("division by zero");if(g){if(!this.unsigned&&-2147483648===this.high&&-1===t.low&&-1===t.high)return this;return h((this.unsigned?g.div_u:g.div_s)(this.low,this.high,t.low,t.high),g.get_high(),this.unsigned)}if(this.isZero())return this.unsigned?p:m;var i,n,r;if(this.unsigned){if(t.unsigned\|\|(t=t.toUnsigned()),t.gt(this))return p;if(t.gt(this.shru(1)))return b;r=p}else{if(this.eq(_)){if(t.eq(y)\|\|t.eq(N))return _;if(t.eq(_))return y;return i=this.shr(1).div(t).shl(1),i.eq(m)?t.isNegative()?y:N:(n=this.sub(t.mul(i)),r=i.add(n.div(t)))}if(t.eq(_))return this.unsigned?p:m;if(this.isNegative())return t.isNegative()?this.neg().div(t.neg()):this.neg().div(t).neg();if(t.isNegative())return this.div(t.neg()).neg();r=m}for(n=this;n.gte(t);){i=Math.max(1,Math.floor(n.toNumber()/t.toNumber()));for(var u=Math.ceil(Math.log(i)/Math.LN2),f=u<=48?1:a(2,u-48),l=s(i),d=l.mul(t);d.isNegative()\|\|d.gt(n);)i-=f,l=s(i,this.unsigned),d=l.mul(t);l.isZero()&&(l=y),r=r.add(l),n=n.sub(d)}return r},B.div=B.divide,B.modulo=function(t){if(e(t)\|\|(t=o(t)),g){return h((this.unsigned?g.rem_u:g.rem_s)(this.low,this.high,t.low,t.high),g.get_high(),this.unsigned)}return this.sub(this.div(t).mul(t))},B.mod=B.modulo,B.rem=B.modulo,B.not=function(){return h(~this.low,~this.high,this.unsigned)},B.and=function(t){return e(t)\|\|(t=o(t)),h(this.low&t.low,this.high&t.high,this.unsigned)},B.or=function(t){return e(t)\|\|(t=o(t)),h(this.low\|t.low,this.high\|t.high,this.unsigned)},B.xor=function(t){return e(t)\|\|(t=o(t)),h(this.low^t.low,this.high^t.high,this.unsigned)},B.shiftLeft=function(t){return e(t)&&(t=t.toInt()),0==(t&=63)?this:t<32?h(this.low<<t,this.high<<t\|this.low>>>32-t,this.unsigned):h(0,this.low<<t-32,this.unsigned)},B.shl=B.shiftLeft,B.shiftRight=function(t){return e(t)&&(t=t.toInt()),0==(t&=63)?this:t<32?h(this.low>>>t\|this.high<<32-t,this.high>>t,this.unsigned):h(this.high>>t-32,this.high>=0?0:-1,this.unsigned)},B.shr=B.shiftRight,B.shiftRightUnsigned=function(t){if(e(t)&&(t=t.toInt()),0===(t&=63))return this;var i=this.high;if(t<32){return h(this.low>>>t\|i<<32-t,i>>>t,this.unsigned)}return 32===t?h(i,0,this.unsigned):h(i>>>t-32,0,this.unsigned)},B.shru=B.shiftRightUnsigned,B.shr_u=B.shiftRightUnsigned,B.toSigned=function(){return this.unsigned?h(this.low,this.high,!1):this},B.toUnsigned=function(){return this.unsigned?this:h(this.low,this.high,!0)},B.toBytes=function(t){return t?this.toBytesLE():this.toBytesBE()},B.toBytesLE=function(){var t=this.high,i=this.low;return[255&i,i>>>8&255,i>>>16&255,i>>>24,255&t,t>>>8&255,t>>>16&255,t>>>24]},B.toBytesBE=function(){var t=this.high,i=this.low;return[t>>>24,t>>>16&255,t>>>8&255,255&t,i>>>24,i>>>16&255,i>>>8&255,255&i]},n.fromBytes=function(t,i,e){return e?n.fromBytesLE(t,i):n.fromBytesBE(t,i)},n.fromBytesLE=function(t,i){return new n(t[0]\|t[1]<<8\|t[2]<<16\|t[3]<<24,t[4]\|t[5]<<8\|t[6]<<16\|t[7]<<24,i)},n.fromBytesBE=function(t,i){return new n(t[4]<<24\|t[5]<<16\|t[6]<<8\|t[7],t[0]<<24\|t[1]<<16\|t[2]<<8\|t[3],i)}}])});
		//# sourceMappingURL=long.js.map

index.js

		@@ -1,1 +0,1 @@
		module.exports = require("./dist/long.js");
		module.exports = require("./src/long");

package.json

		{
		"name": "long",
		"version": "3.2.0",
		"version": "4.0.0",
		"author": "Daniel Wirtz <dcode@dcode.io>",
		"description": "A Long class for representing a 64-bit two's-complement integer value.",
		"main": "dist/long.js",
		"main": "src/long.js",
		"repository": {
		@@ -14,21 +14,22 @@ "type": "git",
		},
		"keywords": ["math"],
		"dependencies": {
		},
		"keywords": [
		"math"
		],
		"dependencies": {},
		"devDependencies": {
		"testjs": "latest",
		"closurecompiler": "^1.6",
		"metascript": "~0"
		"webpack": "^3.10.0"
		},
		"license": "Apache-2.0",
		"engines": {
		"node": ">=0.6"
		"scripts": {
		"build": "webpack",
		"test": "node tests"
		},
		"scripts": {
		"build": "node scripts/build.js",
		"make": "npm run-script build && npm run-script compile && npm run-script compress && npm test",
		"compile": "ccjs dist/long.js --compilation_level=SIMPLE_OPTIMIZATIONS --create_source_map=dist/long.min.map > dist/long.min.js",
		"compress": "gzip -c -9 dist/long.min.js > dist/long.min.js.gz",
		"test": "node node_modules/testjs/bin/testjs tests/suite.js"
		}
		"files": [
		"index.js",
		"LICENSE",
		"README.md",
		"src/long.js",
		"dist/long.js",
		"dist/long.js.map"
		]
		}

551

README.md

		@@ -1,3 +0,4 @@
		![long.js - A Long class for representing a 64 bit two's-complement integer ](https://raw.github.com/dcodeIO/long.js/master/long.png)
		long.js
		=======

		A Long class for representing a 64 bit two's-complement integer value derived from the [Closure Library](https://github.com/google/closure-library)
		@@ -7,6 +8,6 @@ for stand-alone use and extended with unsigned support.
		[![Build Status](https://travis-ci.org/dcodeIO/long.js.svg)](https://travis-ci.org/dcodeIO/long.js)
		[![Donate](https://raw.githubusercontent.com/dcodeIO/long.js/master/donate.png)](https://www.paypal.com/cgi-bin/webscr?cmd=_donations&business=dcode%40dcode.io&item_name=%3C3%20long.js)

		Background
		----------

		As of [ECMA-262 5th Edition](http://ecma262-5.com/ELS5_HTML.htm#Section_8.5), "all the positive and negative integers
		@@ -18,3 +19,3 @@ whose magnitude is no greater than 2<sup>53</sup> are representable in the Number type", which is "representing the

		Example: 2<sup>64</sup>-1 is 18446744073709551615 but in JavaScript it evaluates to `18446744073709552000`.
		Example: 2<sup>64</sup>-1 is 18446744073709551615 but in JavaScript it evaluates to 18446744073709552000.

		@@ -30,4 +31,5 @@ Furthermore, bitwise operators in JavaScript "deal only with integers in the range −2<sup>31</sup> through
		-----
		The class is compatible with CommonJS and AMD loaders and is exposed globally as `dcodeIO.Long` if neither is available.

		The class is compatible with CommonJS and AMD loaders and is exposed globally as `Long` if neither is available.

		```javascript
		@@ -37,2 +39,3 @@ var Long = require("long");
		var longVal = new Long(0xFFFFFFFF, 0x7FFFFFFF);

		console.log(longVal.toString());
		@@ -45,474 +48,204 @@ ...

		#### new Long(low, high=, unsigned=)
		### Constructor

		Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as signed integers.
		See the from* functions below for more convenient ways of constructing Longs.
		* new Long(low: `number`, high: `number`, unsigned?: `boolean`)<br />
		Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as signed integers. See the from* functions below for more convenient ways of constructing Longs.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| low \| number \| The low (signed) 32 bits of the long
		\| high \| number \| The high (signed) 32 bits of the long
		\| unsigned \| boolean \| Whether unsigned or not, defaults to `false` for signed
		### Fields

		---
		* Long#low: `number`<br />
		The low 32 bits as a signed value.

		#### Long.MAX_UNSIGNED_VALUE
		* Long#high: `number`<br />
		The high 32 bits as a signed value.

		Maximum unsigned value.
		* Long#unsigned: `boolean`<br />
		Whether unsigned or not.

		\| \| \|
		\|-----------------\|-----------------\|
		\| @type \| !Long \|
		### Constants

		#### Long.MAX_VALUE
		* Long.ZERO: `Long`<br />
		Signed zero.

		Maximum signed value.
		* Long.ONE: `Long`<br />
		Signed one.

		\| \| \|
		\|-----------------\|-----------------\|
		\| @type \| !Long \|
		* Long.NEG_ONE: `Long`<br />
		Signed negative one.

		#### Long.MIN_VALUE
		* Long.UZERO: `Long`<br />
		Unsigned zero.

		Minimum signed value.
		* Long.UONE: `Long`<br />
		Unsigned one.

		\| \| \|
		\|-----------------\|-----------------\|
		\| @type \| !Long \|
		* Long.MAX_VALUE: `Long`<br />
		Maximum signed value.

		#### Long.NEG_ONE
		* Long.MIN_VALUE: `Long`<br />
		Minimum signed value.

		Signed negative one.
		* Long.MAX_UNSIGNED_VALUE: `Long`<br />
		Maximum unsigned value.

		\| \| \|
		\|-----------------\|-----------------\|
		\| @type \| !Long \|
		### Utility

		#### Long.ONE
		* Long.isLong(obj: `*`): `boolean`<br />
		Tests if the specified object is a Long.

		Signed one.
		* Long.fromBits(lowBits: `number`, highBits: `number`, unsigned?: `boolean`): `Long`<br />
		Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is assumed to use 32 bits.

		\| \| \|
		\|-----------------\|-----------------\|
		\| @type \| !Long \|
		* Long.fromBytes(bytes: `number[]`, unsigned?: `boolean`, le?: `boolean`): `Long`<br />
		Creates a Long from its byte representation.

		#### Long.UONE
		* Long.fromBytesLE(bytes: `number[]`, unsigned?: `boolean`): `Long`<br />
		Creates a Long from its little endian byte representation.

		Unsigned one.
		* Long.fromBytesBE(bytes: `number[]`, unsigned?: `boolean`): `Long`<br />
		Creates a Long from its big endian byte representation.

		\| \| \|
		\|-----------------\|-----------------\|
		\| @type \| !Long \|
		* Long.fromInt(value: `number`, unsigned?: `boolean`): `Long`<br />
		Returns a Long representing the given 32 bit integer value.

		#### Long.UZERO
		* Long.fromNumber(value: `number`, unsigned?: `boolean`): `Long`<br />
		Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.

		Unsigned zero.
		* Long.fromString(str: `string`, unsigned?: `boolean`, radix?: `number`)<br />
		Long.fromString(str: `string`, radix: `number`)<br />
		Returns a Long representation of the given string, written using the specified radix.

		\| \| \|
		\|-----------------\|-----------------\|
		\| @type \| !Long \|
		* Long.fromValue(val: `*`, unsigned?: `boolean`): `Long`<br />
		Converts the specified value to a Long using the appropriate from* function for its type.

		#### Long.ZERO
		### Methods

		Signed zero.
		* Long#add(addend: `Long \| number \| string`): `Long`<br />
		Returns the sum of this and the specified Long.

		\| \| \|
		\|-----------------\|-----------------\|
		\| @type \| !Long \|
		* Long#and(other: `Long \| number \| string`): `Long`<br />
		Returns the bitwise AND of this Long and the specified.

		#### Long.fromBits(lowBits, highBits, unsigned=)
		* Long#compare/comp(other: `Long \| number \| string`): `number`<br />
		Compares this Long's value with the specified's. Returns `0` if they are the same, `1` if the this is greater and `-1` if the given one is greater.

		Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is
		assumed to use 32 bits.
		* Long#divide/div(divisor: `Long \| number \| string`): `Long`<br />
		Returns this Long divided by the specified.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| lowBits \| number \| The low 32 bits
		\| highBits \| number \| The high 32 bits
		\| unsigned \| boolean \| Whether unsigned or not, defaults to `false` for signed
		\| @returns \| !Long \| The corresponding Long value
		* Long#equals/eq(other: `Long \| number \| string`): `boolean`<br />
		Tests if this Long's value equals the specified's.

		#### Long.fromInt(value, unsigned=)
		* Long#getHighBits(): `number`<br />
		Gets the high 32 bits as a signed integer.

		Returns a Long representing the given 32 bit integer value.
		* Long#getHighBitsUnsigned(): `number`<br />
		Gets the high 32 bits as an unsigned integer.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| value \| number \| The 32 bit integer in question
		\| unsigned \| boolean \| Whether unsigned or not, defaults to `false` for signed
		\| @returns \| !Long \| The corresponding Long value
		* Long#getLowBits(): `number`<br />
		Gets the low 32 bits as a signed integer.

		#### Long.fromNumber(value, unsigned=)
		* Long#getLowBitsUnsigned(): `number`<br />
		Gets the low 32 bits as an unsigned integer.

		Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.
		* Long#getNumBitsAbs(): `number`<br />
		Gets the number of bits needed to represent the absolute value of this Long.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| value \| number \| The number in question
		\| unsigned \| boolean \| Whether unsigned or not, defaults to `false` for signed
		\| @returns \| !Long \| The corresponding Long value
		* Long#greaterThan/gt(other: `Long \| number \| string`): `boolean`<br />
		Tests if this Long's value is greater than the specified's.

		#### Long.fromString(str, unsigned=, radix=)
		* Long#greaterThanOrEqual/gte/ge(other: `Long \| number \| string`): `boolean`<br />
		Tests if this Long's value is greater than or equal the specified's.

		Returns a Long representation of the given string, written using the specified radix.
		* Long#isEven(): `boolean`<br />
		Tests if this Long's value is even.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| str \| string \| The textual representation of the Long
		\| unsigned \| boolean \| number \| Whether unsigned or not, defaults to `false` for signed
		\| radix \| number \| The radix in which the text is written (2-36), defaults to 10
		\| @returns \| !Long \| The corresponding Long value
		* Long#isNegative(): `boolean`<br />
		Tests if this Long's value is negative.

		#### Long.isLong(obj)
		* Long#isOdd(): `boolean`<br />
		Tests if this Long's value is odd.

		Tests if the specified object is a Long.
		* Long#isPositive(): `boolean`<br />
		Tests if this Long's value is positive.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| obj \| *** \| Object
		\| @returns \| boolean \|
		* Long#isZero/eqz(): `boolean`<br />
		Tests if this Long's value equals zero.

		#### Long.fromValue(val)
		* Long#lessThan/lt(other: `Long \| number \| string`): `boolean`<br />
		Tests if this Long's value is less than the specified's.

		Converts the specified value to a Long.
		* Long#lessThanOrEqual/lte/le(other: `Long \| number \| string`): `boolean`<br />
		Tests if this Long's value is less than or equal the specified's.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| val \| !Long \| number \| string \| !{low: number, high: number, unsigned: boolean} \| Value
		\| @returns \| !Long \|
		* Long#modulo/mod/rem(divisor: `Long \| number \| string`): `Long`<br />
		Returns this Long modulo the specified.

		---
		* Long#multiply/mul(multiplier: `Long \| number \| string`): `Long`<br />
		Returns the product of this and the specified Long.

		#### Long#high
		* Long#negate/neg(): `Long`<br />
		Negates this Long's value.

		The high 32 bits as a signed value.
		* Long#not(): `Long`<br />
		Returns the bitwise NOT of this Long.

		\| \| \|
		\|-----------------\|-----------------\|
		\| @type \| number \|
		* Long#notEquals/neq/ne(other: `Long \| number \| string`): `boolean`<br />
		Tests if this Long's value differs from the specified's.

		#### Long#low
		* Long#or(other: `Long \| number \| string`): `Long`<br />
		Returns the bitwise OR of this Long and the specified.

		The low 32 bits as a signed value.
		* Long#shiftLeft/shl(numBits: `Long \| number \| string`): `Long`<br />
		Returns this Long with bits shifted to the left by the given amount.

		\| \| \|
		\|-----------------\|-----------------\|
		\| @type \| number \|
		* Long#shiftRight/shr(numBits: `Long \| number \| string`): `Long`<br />
		Returns this Long with bits arithmetically shifted to the right by the given amount.

		#### Long#unsigned
		* Long#shiftRightUnsigned/shru/shr_u(numBits: `Long \| number \| string`): `Long`<br />
		Returns this Long with bits logically shifted to the right by the given amount.

		Whether unsigned or not.
		* Long#subtract/sub(subtrahend: `Long \| number \| string`): `Long`<br />
		Returns the difference of this and the specified Long.

		\| \| \|
		\|-----------------\|-----------------\|
		\| @type \| boolean \|
		* Long#toBytes(le?: `boolean`): `number[]`<br />
		Converts this Long to its byte representation.

		#### Long#add(addend)
		* Long#toBytesLE(): `number[]`<br />
		Converts this Long to its little endian byte representation.

		Returns the sum of this and the specified Long.
		* Long#toBytesBE(): `number[]`<br />
		Converts this Long to its big endian byte representation.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| addend \| !Long \| number \| string \| Addend
		\| @returns \| !Long \| Sum
		* Long#toInt(): `number`<br />
		Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.

		#### Long#and(other)
		* Long#toNumber(): `number`<br />
		Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).

		Returns the bitwise AND of this Long and the specified.
		* Long#toSigned(): `Long`<br />
		Converts this Long to signed.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| other \| !Long \| number \| string \| Other Long
		\| @returns \| !Long \|
		* Long#toString(radix?: `number`): `string`<br />
		Converts the Long to a string written in the specified radix.

		#### Long#compare/comp(other)
		* Long#toUnsigned(): `Long`<br />
		Converts this Long to unsigned.

		Compares this Long's value with the specified's.
		* Long#xor(other: `Long \| number \| string`): `Long`<br />
		Returns the bitwise XOR of this Long and the given one.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| other \| !Long \| number \| string \| Other value
		\| @returns \| number \| 0 if they are the same, 1 if the this is greater and -1 if the given one is greater
		Building
		--------

		#### Long#divide/div(divisor)
		To build an UMD bundle to `dist/long.js`, run:

		Returns this Long divided by the specified.
		```
		$> npm install
		$> npm run build
		```

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| divisor \| !Long \| number \| string \| Divisor
		\| @returns \| !Long \| Quotient
		Running the [tests](./tests):

		#### Long#equals/eq(other)

		Tests if this Long's value equals the specified's.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| other \| !Long \| number \| string \| Other value
		\| @returns \| boolean \|

		#### Long#getHighBits()

		Gets the high 32 bits as a signed integer.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| number \| Signed high bits

		#### Long#getHighBitsUnsigned()

		Gets the high 32 bits as an unsigned integer.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| number \| Unsigned high bits

		#### Long#getLowBits()

		Gets the low 32 bits as a signed integer.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| number \| Signed low bits

		#### Long#getLowBitsUnsigned()

		Gets the low 32 bits as an unsigned integer.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| number \| Unsigned low bits

		#### Long#getNumBitsAbs()

		Gets the number of bits needed to represent the absolute value of this Long.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| number \|

		#### Long#greaterThan/gt(other)

		Tests if this Long's value is greater than the specified's.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| other \| !Long \| number \| string \| Other value
		\| @returns \| boolean \|

		#### Long#greaterThanOrEqual/gte(other)

		Tests if this Long's value is greater than or equal the specified's.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| other \| !Long \| number \| string \| Other value
		\| @returns \| boolean \|

		#### Long#isEven()

		Tests if this Long's value is even.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| boolean \|

		#### Long#isNegative()

		Tests if this Long's value is negative.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| boolean \|

		#### Long#isOdd()

		Tests if this Long's value is odd.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| boolean \|

		#### Long#isPositive()

		Tests if this Long's value is positive.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| boolean \|

		#### Long#isZero()

		Tests if this Long's value equals zero.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| boolean \|

		#### Long#lessThan/lt(other)

		Tests if this Long's value is less than the specified's.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| other \| !Long \| number \| string \| Other value
		\| @returns \| boolean \|

		#### Long#lessThanOrEqual/lte(other)

		Tests if this Long's value is less than or equal the specified's.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| other \| !Long \| number \| string \| Other value
		\| @returns \| boolean \|

		#### Long#modulo/mod(divisor)

		Returns this Long modulo the specified.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| divisor \| !Long \| number \| string \| Divisor
		\| @returns \| !Long \| Remainder

		#### Long#multiply/mul(multiplier)

		Returns the product of this and the specified Long.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| multiplier \| !Long \| number \| string \| Multiplier
		\| @returns \| !Long \| Product

		#### Long#negate/neg()

		Negates this Long's value.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| !Long \| Negated Long

		#### Long#not()

		Returns the bitwise NOT of this Long.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| !Long \|

		#### Long#notEquals/neq(other)

		Tests if this Long's value differs from the specified's.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| other \| !Long \| number \| string \| Other value
		\| @returns \| boolean \|

		#### Long#or(other)

		Returns the bitwise OR of this Long and the specified.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| other \| !Long \| number \| string \| Other Long
		\| @returns \| !Long \|

		#### Long#shiftLeft/shl(numBits)

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

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| numBits \| number \| !Long \| Number of bits
		\| @returns \| !Long \| Shifted Long

		#### Long#shiftRight/shr(numBits)

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

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| numBits \| number \| !Long \| Number of bits
		\| @returns \| !Long \| Shifted Long

		#### Long#shiftRightUnsigned/shru(numBits)

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

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| numBits \| number \| !Long \| Number of bits
		\| @returns \| !Long \| Shifted Long

		#### Long#subtract/sub(subtrahend)

		Returns the difference of this and the specified Long.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| subtrahend \| !Long \| number \| string \| Subtrahend
		\| @returns \| !Long \| Difference

		#### Long#toInt()

		Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| number \|

		#### Long#toNumber()

		Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| number \|

		#### Long#toSigned()

		Converts this Long to signed.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| !Long \| Signed long

		#### Long#toString(radix=)

		Converts the Long to a string written in the specified radix.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| radix \| number \| Radix (2-36), defaults to 10
		\| @returns \| string \|
		\| @throws \| RangeError \| If `radix` is out of range

		#### Long#toUnsigned()

		Converts this Long to unsigned.

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| @returns \| !Long \| Unsigned long

		#### Long#xor(other)

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

		\| Parameter \| Type \| Description
		\|-----------------\|-----------------\|---------------
		\| other \| !Long \| number \| string \| Other Long
		\| @returns \| !Long \|

		Downloads
		---------
		* [Distributions](https://github.com/dcodeIO/long.js/tree/master/dist)
		* [ZIP-Archive](https://github.com/dcodeIO/long.js/archive/master.zip)
		* [Tarball](https://github.com/dcodeIO/long.js/tarball/master)

		License
		-------
		Apache License, Version 2.0 - http://www.apache.org/licenses/LICENSE-2.0.html
		```
		$> npm test
		```

235

src/long.js

		@@ -0,2 +1,17 @@
		module.exports = Long;

		/**
		* wasm optimizations, to do native i64 multiplication and divide
		*/
		var wasm = null;

		try {
		wasm = new WebAssembly.Instance(new WebAssembly.Module(new Uint8Array([
		0, 97, 115, 109, 1, 0, 0, 0, 1, 13, 2, 96, 0, 1, 127, 96, 4, 127, 127, 127, 127, 1, 127, 3, 7, 6, 0, 1, 1, 1, 1, 1, 6, 6, 1, 127, 1, 65, 0, 11, 7, 50, 6, 3, 109, 117, 108, 0, 1, 5, 100, 105, 118, 95, 115, 0, 2, 5, 100, 105, 118, 95, 117, 0, 3, 5, 114, 101, 109, 95, 115, 0, 4, 5, 114, 101, 109, 95, 117, 0, 5, 8, 103, 101, 116, 95, 104, 105, 103, 104, 0, 0, 10, 191, 1, 6, 4, 0, 35, 0, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 126, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 127, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 128, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 129, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11, 36, 1, 1, 126, 32, 0, 173, 32, 1, 173, 66, 32, 134, 132, 32, 2, 173, 32, 3, 173, 66, 32, 134, 132, 130, 34, 4, 66, 32, 135, 167, 36, 0, 32, 4, 167, 11
		])), {}).exports;
		} catch (e) {
		// no wasm support :(
		}

		/**
		* Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as signed integers.
		@@ -8,3 +23,3 @@ * See the from* functions below for more convenient ways of constructing Longs.
		* @param {number} high The high (signed) 32 bits of the long
		* @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
		* @param {boolean=} unsigned Whether unsigned or not, defaults to signed
		* @constructor
		@@ -58,7 +73,3 @@ */

		Object.defineProperty(Long.prototype, "__isLong__", {
		value: true,
		enumerable: false,
		configurable: false
		});
		Object.defineProperty(Long.prototype, "__isLong__", { value: true });

		@@ -134,3 +145,3 @@ /**
		* @param {number} value The 32 bit integer in question
		* @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
		* @param {boolean=} unsigned Whether unsigned or not, defaults to signed
		* @returns {!Long} The corresponding Long value
		@@ -147,3 +158,3 @@ */
		function fromNumber(value, unsigned) {
		if (isNaN(value) \|\| !isFinite(value))
		if (isNaN(value))
		return unsigned ? UZERO : ZERO;
		@@ -170,3 +181,3 @@ if (unsigned) {
		* @param {number} value The number in question
		* @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
		* @param {boolean=} unsigned Whether unsigned or not, defaults to signed
		* @returns {!Long} The corresponding Long value
		@@ -193,3 +204,3 @@ */
		* @param {number} highBits The high 32 bits
		* @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed
		* @param {boolean=} unsigned Whether unsigned or not, defaults to signed
		* @returns {!Long} The corresponding Long value
		@@ -220,3 +231,3 @@ */
		return ZERO;
		if (typeof unsigned === 'number') {
		if (typeof unsigned === 'number') {
		// For goog.math.long compatibility
		@@ -263,3 +274,3 @@ radix = unsigned,
		* @param {string} str The textual representation of the Long
		* @param {(boolean\|number)=} unsigned Whether unsigned or not, defaults to `false` for signed
		* @param {(boolean\|number)=} unsigned Whether unsigned or not, defaults to signed
		* @param {number=} radix The radix in which the text is written (2-36), defaults to 10
		@@ -273,20 +284,20 @@ * @returns {!Long} The corresponding Long value
		* @param {!Long\|number\|string\|!{low: number, high: number, unsigned: boolean}} val
		* @param {boolean=} unsigned
		* @returns {!Long}
		* @inner
		*/
		function fromValue(val) {
		if (val /* is compatible */ instanceof Long)
		return val;
		function fromValue(val, unsigned) {
		if (typeof val === 'number')
		return fromNumber(val);
		return fromNumber(val, unsigned);
		if (typeof val === 'string')
		return fromString(val);
		return fromString(val, unsigned);
		// Throws for non-objects, converts non-instanceof Long:
		return fromBits(val.low, val.high, val.unsigned);
		return fromBits(val.low, val.high, typeof unsigned === 'boolean' ? unsigned : val.unsigned);
		}

		/**
		* Converts the specified value to a Long.
		* Converts the specified value to a Long using the appropriate from* function for its type.
		* @function
		* @param {!Long\|number\|string\|!{low: number, high: number, unsigned: boolean}} val Value
		* @param {boolean=} unsigned Whether unsigned or not, defaults to signed
		* @returns {!Long}
		@@ -561,2 +572,8 @@ */
		/**
		* Tests if this Long's value equals zero. This is an alias of {@link Long#isZero}.
		* @returns {boolean}
		*/
		LongPrototype.eqz = LongPrototype.isZero;

		/**
		* Tests if this Long's value is negative.
		@@ -632,2 +649,10 @@ * @returns {boolean}
		/**
		* Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.
		* @function
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.ne = LongPrototype.notEquals;

		/**
		* Tests if this Long's value is less than the specified's.
		@@ -667,2 +692,10 @@ * @param {!Long\|number\|string} other Other value
		/**
		* Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.
		* @function
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.le = LongPrototype.lessThanOrEqual;

		/**
		* Tests if this Long's value is greater than the specified's.
		@@ -702,2 +735,10 @@ * @param {!Long\|number\|string} other Other value
		/**
		* Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.
		* @function
		* @param {!Long\|number\|string} other Other value
		* @returns {boolean}
		*/
		LongPrototype.ge = LongPrototype.greaterThanOrEqual;

		/**
		* Compares this Long's value with the specified's.
		@@ -817,2 +858,12 @@ * @param {!Long\|number\|string} other Other value
		multiplier = fromValue(multiplier);

		// use wasm support if present
		if (wasm) {
		var low = wasm.mul(this.low,
		this.high,
		multiplier.low,
		multiplier.high);
		return fromBits(low, wasm.get_high(), this.unsigned);
		}

		if (multiplier.isZero())
		@@ -893,2 +944,23 @@ return ZERO;
		throw Error('division by zero');

		// use wasm support if present
		if (wasm) {
		// guard against signed division overflow: the largest
		// negative number / -1 would be 1 larger than the largest
		// positive number, due to two's complement.
		if (!this.unsigned &&
		this.high === -0x80000000 &&
		divisor.low === -1 && divisor.high === -1) {
		// be consistent with non-wasm code path
		return this;
		}
		var low = (this.unsigned ? wasm.div_u : wasm.div_s)(
		this.low,
		this.high,
		divisor.low,
		divisor.high
		);
		return fromBits(low, wasm.get_high(), this.unsigned);
		}

		if (this.isZero())
		@@ -937,3 +1009,3 @@ return this.unsigned ? UZERO : ZERO;
		}


		// Repeat the following until the remainder is less than other: find a
		@@ -992,2 +1064,14 @@ // floating-point that approximates remainder / other from below, add this
		divisor = fromValue(divisor);

		// use wasm support if present
		if (wasm) {
		var low = (this.unsigned ? wasm.rem_u : wasm.rem_s)(
		this.low,
		this.high,
		divisor.low,
		divisor.high
		);
		return fromBits(low, wasm.get_high(), this.unsigned);
		}

		return this.sub(this.div(divisor).mul(divisor));
		@@ -1005,2 +1089,10 @@ };
		/**
		* Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.
		* @function
		* @param {!Long\|number\|string} divisor Divisor
		* @returns {!Long} Remainder
		*/
		LongPrototype.rem = LongPrototype.modulo;

		/**
		* Returns the bitwise NOT of this Long.
		@@ -1126,2 +1218,10 @@ * @returns {!Long}
		/**
		* Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.
		* @function
		* @param {number\|!Long} numBits Number of bits
		* @returns {!Long} Shifted Long
		*/
		LongPrototype.shr_u = LongPrototype.shiftRightUnsigned;

		/**
		* Converts this Long to signed.
		@@ -1151,5 +1251,5 @@ * @returns {!Long} Signed long
		*/
		LongPrototype.toBytes = function(le) {
		LongPrototype.toBytes = function toBytes(le) {
		return le ? this.toBytesLE() : this.toBytesBE();
		}
		};

		@@ -1160,16 +1260,16 @@ /**
		*/
		LongPrototype.toBytesLE = function() {
		LongPrototype.toBytesLE = function toBytesLE() {
		var hi = this.high,
		lo = this.low;
		return [
		lo & 0xff,
		(lo >>> 8) & 0xff,
		(lo >>> 16) & 0xff,
		(lo >>> 24) & 0xff,
		hi & 0xff,
		(hi >>> 8) & 0xff,
		(hi >>> 16) & 0xff,
		(hi >>> 24) & 0xff
		lo & 0xff,
		lo >>> 8 & 0xff,
		lo >>> 16 & 0xff,
		lo >>> 24 ,
		hi & 0xff,
		hi >>> 8 & 0xff,
		hi >>> 16 & 0xff,
		hi >>> 24
		];
		}
		};

		@@ -1180,15 +1280,66 @@ /**
		*/
		LongPrototype.toBytesBE = function() {
		LongPrototype.toBytesBE = function toBytesBE() {
		var hi = this.high,
		lo = this.low;
		return [
		(hi >>> 24) & 0xff,
		(hi >>> 16) & 0xff,
		(hi >>> 8) & 0xff,
		hi & 0xff,
		(lo >>> 24) & 0xff,
		(lo >>> 16) & 0xff,
		(lo >>> 8) & 0xff,
		lo & 0xff
		hi >>> 24 ,
		hi >>> 16 & 0xff,
		hi >>> 8 & 0xff,
		hi & 0xff,
		lo >>> 24 ,
		lo >>> 16 & 0xff,
		lo >>> 8 & 0xff,
		lo & 0xff
		];
		}
		};

		/**
		* Creates a Long from its byte representation.
		* @param {!Array.<number>} bytes Byte representation
		* @param {boolean=} unsigned Whether unsigned or not, defaults to signed
		* @param {boolean=} le Whether little or big endian, defaults to big endian
		* @returns {Long} The corresponding Long value
		*/
		Long.fromBytes = function fromBytes(bytes, unsigned, le) {
		return le ? Long.fromBytesLE(bytes, unsigned) : Long.fromBytesBE(bytes, unsigned);
		};

		/**
		* Creates a Long from its little endian byte representation.
		* @param {!Array.<number>} bytes Little endian byte representation
		* @param {boolean=} unsigned Whether unsigned or not, defaults to signed
		* @returns {Long} The corresponding Long value
		*/
		Long.fromBytesLE = function fromBytesLE(bytes, unsigned) {
		return new Long(
		bytes[0] \|
		bytes[1] << 8 \|
		bytes[2] << 16 \|
		bytes[3] << 24,
		bytes[4] \|
		bytes[5] << 8 \|
		bytes[6] << 16 \|
		bytes[7] << 24,
		unsigned
		);
		};

		/**
		* Creates a Long from its big endian byte representation.
		* @param {!Array.<number>} bytes Big endian byte representation
		* @param {boolean=} unsigned Whether unsigned or not, defaults to signed
		* @returns {Long} The corresponding Long value
		*/
		Long.fromBytesBE = function fromBytesBE(bytes, unsigned) {
		return new Long(
		bytes[4] << 24 \|
		bytes[5] << 16 \|
		bytes[6] << 8 \|
		bytes[7],
		bytes[0] << 24 \|
		bytes[1] << 16 \|
		bytes[2] << 8 \|
		bytes[3],
		unsigned
		);
		};

.npmignore

.travis.yml

bower.json

dist/long.min.js

dist/long.min.js.gz

dist/long.min.map

dist/README.md

doco/INDEX.md

doco/Long.md

donate.png

externs/long.js

jsdoc.json

long.png

scripts/build.js

src/bower.json

src/wrap.js

tests/goog.math.long.js

tests/suite.js

New alerts

Fixed alerts

Improved metrics

Worsened metrics