{"version":3,"sources":["webpack:///./node_modules/bytebuffer/node_modules/long/dist/long.js"],"names":["Long","low","high","unsigned","this","isLong","obj","prototype","__isLong__","Object","defineProperty","value","enumerable","configurable","INT_CACHE","UINT_CACHE","fromInt","cachedObj","cache","fromBits","fromNumber","isNaN","isFinite","UZERO","ZERO","TWO_PWR_64_DBL","MAX_UNSIGNED_VALUE","TWO_PWR_63_DBL","MIN_VALUE","MAX_VALUE","neg","TWO_PWR_32_DBL","lowBits","highBits","pow_dbl","Math","pow","fromString","str","radix","length","Error","RangeError","p","indexOf","substring","radixToPower","result","i","size","min","parseInt","power","mul","add","fromValue","val","TWO_PWR_16_DBL","TWO_PWR_24","ONE","UONE","NEG_ONE","LongPrototype","toInt","toNumber","toString","isZero","isNegative","eq","radixLong","div","rem1","sub","rem","remDiv","digits","getHighBits","getHighBitsUnsigned","getLowBits","getLowBitsUnsigned","getNumBitsAbs","bit","isPositive","isOdd","isEven","equals","other","notEquals","neq","lessThan","comp","lt","lessThanOrEqual","lte","greaterThan","gt","greaterThanOrEqual","gte","compare","thisNeg","otherNeg","negate","not","addend","a48","a32","a16","a00","b48","b32","b16","c48","c32","c16","c00","subtract","subtrahend","multiply","multiplier","b00","divide","divisor","approx","res","toUnsigned","shru","shr","shl","max","floor","log2","ceil","log","LN2","delta","approxRes","approxRem","modulo","mod","and","or","xor","shiftLeft","numBits","shiftRight","shiftRightUnsigned","toSigned","toBytes","le","toBytesLE","toBytesBE","hi","lo"],"mappings":"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","file":"vendor.bytebuffer~d752661d.7c2a4f831ec27c016c4a.chunk.js","sourcesContent":["/*\r\n Copyright 2013 Daniel Wirtz <dcode@dcode.io>\r\n Copyright 2009 The Closure Library Authors. All Rights Reserved.\r\n\r\n Licensed under the Apache License, Version 2.0 (the \"License\");\r\n you may not use this file except in compliance with the License.\r\n You may obtain a copy of the License at\r\n\r\n http://www.apache.org/licenses/LICENSE-2.0\r\n\r\n Unless required by applicable law or agreed to in writing, software\r\n distributed under the License is distributed on an \"AS-IS\" BASIS,\r\n WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.\r\n See the License for the specific language governing permissions and\r\n limitations under the License.\r\n */\r\n\r\n/**\r\n * @license long.js (c) 2013 Daniel Wirtz <dcode@dcode.io>\r\n * Released under the Apache License, Version 2.0\r\n * see: https://github.com/dcodeIO/long.js for details\r\n */\r\n(function(global, factory) {\r\n\r\n    /* AMD */ if (typeof define === 'function' && define[\"amd\"])\r\n        define([], factory);\r\n    /* CommonJS */ else if (typeof require === 'function' && typeof module === \"object\" && module && module[\"exports\"])\r\n        module[\"exports\"] = factory();\r\n    /* Global */ else\r\n        (global[\"dcodeIO\"] = global[\"dcodeIO\"] || {})[\"Long\"] = factory();\r\n\r\n})(this, function() {\r\n    \"use strict\";\r\n\r\n    /**\r\n     * Constructs a 64 bit two's-complement integer, given its low and high 32 bit values as *signed* integers.\r\n     *  See the from* functions below for more convenient ways of constructing Longs.\r\n     * @exports Long\r\n     * @class A Long class for representing a 64 bit two's-complement integer value.\r\n     * @param {number} low The low (signed) 32 bits of the long\r\n     * @param {number} high The high (signed) 32 bits of the long\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @constructor\r\n     */\r\n    function Long(low, high, unsigned) {\r\n\r\n        /**\r\n         * The low 32 bits as a signed value.\r\n         * @type {number}\r\n         */\r\n        this.low = low | 0;\r\n\r\n        /**\r\n         * The high 32 bits as a signed value.\r\n         * @type {number}\r\n         */\r\n        this.high = high | 0;\r\n\r\n        /**\r\n         * Whether unsigned or not.\r\n         * @type {boolean}\r\n         */\r\n        this.unsigned = !!unsigned;\r\n    }\r\n\r\n    // The internal representation of a long is the two given signed, 32-bit values.\r\n    // We use 32-bit pieces because these are the size of integers on which\r\n    // Javascript performs bit-operations.  For operations like addition and\r\n    // multiplication, we split each number into 16 bit pieces, which can easily be\r\n    // multiplied within Javascript's floating-point representation without overflow\r\n    // or change in sign.\r\n    //\r\n    // In the algorithms below, we frequently reduce the negative case to the\r\n    // positive case by negating the input(s) and then post-processing the result.\r\n    // Note that we must ALWAYS check specially whether those values are MIN_VALUE\r\n    // (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\r\n    // a positive number, it overflows back into a negative).  Not handling this\r\n    // case would often result in infinite recursion.\r\n    //\r\n    // Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the from*\r\n    // methods on which they depend.\r\n\r\n    /**\r\n     * An indicator used to reliably determine if an object is a Long or not.\r\n     * @type {boolean}\r\n     * @const\r\n     * @private\r\n     */\r\n    Long.prototype.__isLong__;\r\n\r\n    Object.defineProperty(Long.prototype, \"__isLong__\", {\r\n        value: true,\r\n        enumerable: false,\r\n        configurable: false\r\n    });\r\n\r\n    /**\r\n     * @function\r\n     * @param {*} obj Object\r\n     * @returns {boolean}\r\n     * @inner\r\n     */\r\n    function isLong(obj) {\r\n        return (obj && obj[\"__isLong__\"]) === true;\r\n    }\r\n\r\n    /**\r\n     * Tests if the specified object is a Long.\r\n     * @function\r\n     * @param {*} obj Object\r\n     * @returns {boolean}\r\n     */\r\n    Long.isLong = isLong;\r\n\r\n    /**\r\n     * A cache of the Long representations of small integer values.\r\n     * @type {!Object}\r\n     * @inner\r\n     */\r\n    var INT_CACHE = {};\r\n\r\n    /**\r\n     * A cache of the Long representations of small unsigned integer values.\r\n     * @type {!Object}\r\n     * @inner\r\n     */\r\n    var UINT_CACHE = {};\r\n\r\n    /**\r\n     * @param {number} value\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromInt(value, unsigned) {\r\n        var obj, cachedObj, cache;\r\n        if (unsigned) {\r\n            value >>>= 0;\r\n            if (cache = (0 <= value && value < 256)) {\r\n                cachedObj = UINT_CACHE[value];\r\n                if (cachedObj)\r\n                    return cachedObj;\r\n            }\r\n            obj = fromBits(value, (value | 0) < 0 ? -1 : 0, true);\r\n            if (cache)\r\n                UINT_CACHE[value] = obj;\r\n            return obj;\r\n        } else {\r\n            value |= 0;\r\n            if (cache = (-128 <= value && value < 128)) {\r\n                cachedObj = INT_CACHE[value];\r\n                if (cachedObj)\r\n                    return cachedObj;\r\n            }\r\n            obj = fromBits(value, value < 0 ? -1 : 0, false);\r\n            if (cache)\r\n                INT_CACHE[value] = obj;\r\n            return obj;\r\n        }\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the given 32 bit integer value.\r\n     * @function\r\n     * @param {number} value The 32 bit integer in question\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromInt = fromInt;\r\n\r\n    /**\r\n     * @param {number} value\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromNumber(value, unsigned) {\r\n        if (isNaN(value) || !isFinite(value))\r\n            return unsigned ? UZERO : ZERO;\r\n        if (unsigned) {\r\n            if (value < 0)\r\n                return UZERO;\r\n            if (value >= TWO_PWR_64_DBL)\r\n                return MAX_UNSIGNED_VALUE;\r\n        } else {\r\n            if (value <= -TWO_PWR_63_DBL)\r\n                return MIN_VALUE;\r\n            if (value + 1 >= TWO_PWR_63_DBL)\r\n                return MAX_VALUE;\r\n        }\r\n        if (value < 0)\r\n            return fromNumber(-value, unsigned).neg();\r\n        return fromBits((value % TWO_PWR_32_DBL) | 0, (value / TWO_PWR_32_DBL) | 0, unsigned);\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the given value, provided that it is a finite number. Otherwise, zero is returned.\r\n     * @function\r\n     * @param {number} value The number in question\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromNumber = fromNumber;\r\n\r\n    /**\r\n     * @param {number} lowBits\r\n     * @param {number} highBits\r\n     * @param {boolean=} unsigned\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromBits(lowBits, highBits, unsigned) {\r\n        return new Long(lowBits, highBits, unsigned);\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representing the 64 bit integer that comes by concatenating the given low and high bits. Each is\r\n     *  assumed to use 32 bits.\r\n     * @function\r\n     * @param {number} lowBits The low 32 bits\r\n     * @param {number} highBits The high 32 bits\r\n     * @param {boolean=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromBits = fromBits;\r\n\r\n    /**\r\n     * @function\r\n     * @param {number} base\r\n     * @param {number} exponent\r\n     * @returns {number}\r\n     * @inner\r\n     */\r\n    var pow_dbl = Math.pow; // Used 4 times (4*8 to 15+4)\r\n\r\n    /**\r\n     * @param {string} str\r\n     * @param {(boolean|number)=} unsigned\r\n     * @param {number=} radix\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromString(str, unsigned, radix) {\r\n        if (str.length === 0)\r\n            throw Error('empty string');\r\n        if (str === \"NaN\" || str === \"Infinity\" || str === \"+Infinity\" || str === \"-Infinity\")\r\n            return ZERO;\r\n        if (typeof unsigned === 'number') {\r\n            // For goog.math.long compatibility\r\n            radix = unsigned,\r\n            unsigned = false;\r\n        } else {\r\n            unsigned = !! unsigned;\r\n        }\r\n        radix = radix || 10;\r\n        if (radix < 2 || 36 < radix)\r\n            throw RangeError('radix');\r\n\r\n        var p;\r\n        if ((p = str.indexOf('-')) > 0)\r\n            throw Error('interior hyphen');\r\n        else if (p === 0) {\r\n            return fromString(str.substring(1), unsigned, radix).neg();\r\n        }\r\n\r\n        // Do several (8) digits each time through the loop, so as to\r\n        // minimize the calls to the very expensive emulated div.\r\n        var radixToPower = fromNumber(pow_dbl(radix, 8));\r\n\r\n        var result = ZERO;\r\n        for (var i = 0; i < str.length; i += 8) {\r\n            var size = Math.min(8, str.length - i),\r\n                value = parseInt(str.substring(i, i + size), radix);\r\n            if (size < 8) {\r\n                var power = fromNumber(pow_dbl(radix, size));\r\n                result = result.mul(power).add(fromNumber(value));\r\n            } else {\r\n                result = result.mul(radixToPower);\r\n                result = result.add(fromNumber(value));\r\n            }\r\n        }\r\n        result.unsigned = unsigned;\r\n        return result;\r\n    }\r\n\r\n    /**\r\n     * Returns a Long representation of the given string, written using the specified radix.\r\n     * @function\r\n     * @param {string} str The textual representation of the Long\r\n     * @param {(boolean|number)=} unsigned Whether unsigned or not, defaults to `false` for signed\r\n     * @param {number=} radix The radix in which the text is written (2-36), defaults to 10\r\n     * @returns {!Long} The corresponding Long value\r\n     */\r\n    Long.fromString = fromString;\r\n\r\n    /**\r\n     * @function\r\n     * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val\r\n     * @returns {!Long}\r\n     * @inner\r\n     */\r\n    function fromValue(val) {\r\n        if (val /* is compatible */ instanceof Long)\r\n            return val;\r\n        if (typeof val === 'number')\r\n            return fromNumber(val);\r\n        if (typeof val === 'string')\r\n            return fromString(val);\r\n        // Throws for non-objects, converts non-instanceof Long:\r\n        return fromBits(val.low, val.high, val.unsigned);\r\n    }\r\n\r\n    /**\r\n     * Converts the specified value to a Long.\r\n     * @function\r\n     * @param {!Long|number|string|!{low: number, high: number, unsigned: boolean}} val Value\r\n     * @returns {!Long}\r\n     */\r\n    Long.fromValue = fromValue;\r\n\r\n    // NOTE: the compiler should inline these constant values below and then remove these variables, so there should be\r\n    // no runtime penalty for these.\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_16_DBL = 1 << 16;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_24_DBL = 1 << 24;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_32_DBL = TWO_PWR_16_DBL * TWO_PWR_16_DBL;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_64_DBL = TWO_PWR_32_DBL * TWO_PWR_32_DBL;\r\n\r\n    /**\r\n     * @type {number}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_63_DBL = TWO_PWR_64_DBL / 2;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @const\r\n     * @inner\r\n     */\r\n    var TWO_PWR_24 = fromInt(TWO_PWR_24_DBL);\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var ZERO = fromInt(0);\r\n\r\n    /**\r\n     * Signed zero.\r\n     * @type {!Long}\r\n     */\r\n    Long.ZERO = ZERO;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var UZERO = fromInt(0, true);\r\n\r\n    /**\r\n     * Unsigned zero.\r\n     * @type {!Long}\r\n     */\r\n    Long.UZERO = UZERO;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var ONE = fromInt(1);\r\n\r\n    /**\r\n     * Signed one.\r\n     * @type {!Long}\r\n     */\r\n    Long.ONE = ONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var UONE = fromInt(1, true);\r\n\r\n    /**\r\n     * Unsigned one.\r\n     * @type {!Long}\r\n     */\r\n    Long.UONE = UONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var NEG_ONE = fromInt(-1);\r\n\r\n    /**\r\n     * Signed negative one.\r\n     * @type {!Long}\r\n     */\r\n    Long.NEG_ONE = NEG_ONE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MAX_VALUE = fromBits(0xFFFFFFFF|0, 0x7FFFFFFF|0, false);\r\n\r\n    /**\r\n     * Maximum signed value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MAX_VALUE = MAX_VALUE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MAX_UNSIGNED_VALUE = fromBits(0xFFFFFFFF|0, 0xFFFFFFFF|0, true);\r\n\r\n    /**\r\n     * Maximum unsigned value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MAX_UNSIGNED_VALUE = MAX_UNSIGNED_VALUE;\r\n\r\n    /**\r\n     * @type {!Long}\r\n     * @inner\r\n     */\r\n    var MIN_VALUE = fromBits(0, 0x80000000|0, false);\r\n\r\n    /**\r\n     * Minimum signed value.\r\n     * @type {!Long}\r\n     */\r\n    Long.MIN_VALUE = MIN_VALUE;\r\n\r\n    /**\r\n     * @alias Long.prototype\r\n     * @inner\r\n     */\r\n    var LongPrototype = Long.prototype;\r\n\r\n    /**\r\n     * Converts the Long to a 32 bit integer, assuming it is a 32 bit integer.\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.toInt = function toInt() {\r\n        return this.unsigned ? this.low >>> 0 : this.low;\r\n    };\r\n\r\n    /**\r\n     * Converts the Long to a the nearest floating-point representation of this value (double, 53 bit mantissa).\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.toNumber = function toNumber() {\r\n        if (this.unsigned)\r\n            return ((this.high >>> 0) * TWO_PWR_32_DBL) + (this.low >>> 0);\r\n        return this.high * TWO_PWR_32_DBL + (this.low >>> 0);\r\n    };\r\n\r\n    /**\r\n     * Converts the Long to a string written in the specified radix.\r\n     * @param {number=} radix Radix (2-36), defaults to 10\r\n     * @returns {string}\r\n     * @override\r\n     * @throws {RangeError} If `radix` is out of range\r\n     */\r\n    LongPrototype.toString = function toString(radix) {\r\n        radix = radix || 10;\r\n        if (radix < 2 || 36 < radix)\r\n            throw RangeError('radix');\r\n        if (this.isZero())\r\n            return '0';\r\n        if (this.isNegative()) { // Unsigned Longs are never negative\r\n            if (this.eq(MIN_VALUE)) {\r\n                // We need to change the Long value before it can be negated, so we remove\r\n                // the bottom-most digit in this base and then recurse to do the rest.\r\n                var radixLong = fromNumber(radix),\r\n                    div = this.div(radixLong),\r\n                    rem1 = div.mul(radixLong).sub(this);\r\n                return div.toString(radix) + rem1.toInt().toString(radix);\r\n            } else\r\n                return '-' + this.neg().toString(radix);\r\n        }\r\n\r\n        // Do several (6) digits each time through the loop, so as to\r\n        // minimize the calls to the very expensive emulated div.\r\n        var radixToPower = fromNumber(pow_dbl(radix, 6), this.unsigned),\r\n            rem = this;\r\n        var result = '';\r\n        while (true) {\r\n            var remDiv = rem.div(radixToPower),\r\n                intval = rem.sub(remDiv.mul(radixToPower)).toInt() >>> 0,\r\n                digits = intval.toString(radix);\r\n            rem = remDiv;\r\n            if (rem.isZero())\r\n                return digits + result;\r\n            else {\r\n                while (digits.length < 6)\r\n                    digits = '0' + digits;\r\n                result = '' + digits + result;\r\n            }\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Gets the high 32 bits as a signed integer.\r\n     * @returns {number} Signed high bits\r\n     */\r\n    LongPrototype.getHighBits = function getHighBits() {\r\n        return this.high;\r\n    };\r\n\r\n    /**\r\n     * Gets the high 32 bits as an unsigned integer.\r\n     * @returns {number} Unsigned high bits\r\n     */\r\n    LongPrototype.getHighBitsUnsigned = function getHighBitsUnsigned() {\r\n        return this.high >>> 0;\r\n    };\r\n\r\n    /**\r\n     * Gets the low 32 bits as a signed integer.\r\n     * @returns {number} Signed low bits\r\n     */\r\n    LongPrototype.getLowBits = function getLowBits() {\r\n        return this.low;\r\n    };\r\n\r\n    /**\r\n     * Gets the low 32 bits as an unsigned integer.\r\n     * @returns {number} Unsigned low bits\r\n     */\r\n    LongPrototype.getLowBitsUnsigned = function getLowBitsUnsigned() {\r\n        return this.low >>> 0;\r\n    };\r\n\r\n    /**\r\n     * Gets the number of bits needed to represent the absolute value of this Long.\r\n     * @returns {number}\r\n     */\r\n    LongPrototype.getNumBitsAbs = function getNumBitsAbs() {\r\n        if (this.isNegative()) // Unsigned Longs are never negative\r\n            return this.eq(MIN_VALUE) ? 64 : this.neg().getNumBitsAbs();\r\n        var val = this.high != 0 ? this.high : this.low;\r\n        for (var bit = 31; bit > 0; bit--)\r\n            if ((val & (1 << bit)) != 0)\r\n                break;\r\n        return this.high != 0 ? bit + 33 : bit + 1;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals zero.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isZero = function isZero() {\r\n        return this.high === 0 && this.low === 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is negative.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isNegative = function isNegative() {\r\n        return !this.unsigned && this.high < 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is positive.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isPositive = function isPositive() {\r\n        return this.unsigned || this.high >= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is odd.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isOdd = function isOdd() {\r\n        return (this.low & 1) === 1;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is even.\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.isEven = function isEven() {\r\n        return (this.low & 1) === 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.equals = function equals(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        if (this.unsigned !== other.unsigned && (this.high >>> 31) === 1 && (other.high >>> 31) === 1)\r\n            return false;\r\n        return this.high === other.high && this.low === other.low;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value equals the specified's. This is an alias of {@link Long#equals}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.eq = LongPrototype.equals;\r\n\r\n    /**\r\n     * Tests if this Long's value differs from the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.notEquals = function notEquals(other) {\r\n        return !this.eq(/* validates */ other);\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value differs from the specified's. This is an alias of {@link Long#notEquals}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.neq = LongPrototype.notEquals;\r\n\r\n    /**\r\n     * Tests if this Long's value is less than the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lessThan = function lessThan(other) {\r\n        return this.comp(/* validates */ other) < 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is less than the specified's. This is an alias of {@link Long#lessThan}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lt = LongPrototype.lessThan;\r\n\r\n    /**\r\n     * Tests if this Long's value is less than or equal the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lessThanOrEqual = function lessThanOrEqual(other) {\r\n        return this.comp(/* validates */ other) <= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is less than or equal the specified's. This is an alias of {@link Long#lessThanOrEqual}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.lte = LongPrototype.lessThanOrEqual;\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.greaterThan = function greaterThan(other) {\r\n        return this.comp(/* validates */ other) > 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than the specified's. This is an alias of {@link Long#greaterThan}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.gt = LongPrototype.greaterThan;\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than or equal the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.greaterThanOrEqual = function greaterThanOrEqual(other) {\r\n        return this.comp(/* validates */ other) >= 0;\r\n    };\r\n\r\n    /**\r\n     * Tests if this Long's value is greater than or equal the specified's. This is an alias of {@link Long#greaterThanOrEqual}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {boolean}\r\n     */\r\n    LongPrototype.gte = LongPrototype.greaterThanOrEqual;\r\n\r\n    /**\r\n     * Compares this Long's value with the specified's.\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n     *  if the given one is greater\r\n     */\r\n    LongPrototype.compare = function compare(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        if (this.eq(other))\r\n            return 0;\r\n        var thisNeg = this.isNegative(),\r\n            otherNeg = other.isNegative();\r\n        if (thisNeg && !otherNeg)\r\n            return -1;\r\n        if (!thisNeg && otherNeg)\r\n            return 1;\r\n        // At this point the sign bits are the same\r\n        if (!this.unsigned)\r\n            return this.sub(other).isNegative() ? -1 : 1;\r\n        // Both are positive if at least one is unsigned\r\n        return (other.high >>> 0) > (this.high >>> 0) || (other.high === this.high && (other.low >>> 0) > (this.low >>> 0)) ? -1 : 1;\r\n    };\r\n\r\n    /**\r\n     * Compares this Long's value with the specified's. This is an alias of {@link Long#compare}.\r\n     * @function\r\n     * @param {!Long|number|string} other Other value\r\n     * @returns {number} 0 if they are the same, 1 if the this is greater and -1\r\n     *  if the given one is greater\r\n     */\r\n    LongPrototype.comp = LongPrototype.compare;\r\n\r\n    /**\r\n     * Negates this Long's value.\r\n     * @returns {!Long} Negated Long\r\n     */\r\n    LongPrototype.negate = function negate() {\r\n        if (!this.unsigned && this.eq(MIN_VALUE))\r\n            return MIN_VALUE;\r\n        return this.not().add(ONE);\r\n    };\r\n\r\n    /**\r\n     * Negates this Long's value. This is an alias of {@link Long#negate}.\r\n     * @function\r\n     * @returns {!Long} Negated Long\r\n     */\r\n    LongPrototype.neg = LongPrototype.negate;\r\n\r\n    /**\r\n     * Returns the sum of this and the specified Long.\r\n     * @param {!Long|number|string} addend Addend\r\n     * @returns {!Long} Sum\r\n     */\r\n    LongPrototype.add = function add(addend) {\r\n        if (!isLong(addend))\r\n            addend = fromValue(addend);\r\n\r\n        // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\r\n\r\n        var a48 = this.high >>> 16;\r\n        var a32 = this.high & 0xFFFF;\r\n        var a16 = this.low >>> 16;\r\n        var a00 = this.low & 0xFFFF;\r\n\r\n        var b48 = addend.high >>> 16;\r\n        var b32 = addend.high & 0xFFFF;\r\n        var b16 = addend.low >>> 16;\r\n        var b00 = addend.low & 0xFFFF;\r\n\r\n        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n        c00 += a00 + b00;\r\n        c16 += c00 >>> 16;\r\n        c00 &= 0xFFFF;\r\n        c16 += a16 + b16;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c32 += a32 + b32;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c48 += a48 + b48;\r\n        c48 &= 0xFFFF;\r\n        return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the difference of this and the specified Long.\r\n     * @param {!Long|number|string} subtrahend Subtrahend\r\n     * @returns {!Long} Difference\r\n     */\r\n    LongPrototype.subtract = function subtract(subtrahend) {\r\n        if (!isLong(subtrahend))\r\n            subtrahend = fromValue(subtrahend);\r\n        return this.add(subtrahend.neg());\r\n    };\r\n\r\n    /**\r\n     * Returns the difference of this and the specified Long. This is an alias of {@link Long#subtract}.\r\n     * @function\r\n     * @param {!Long|number|string} subtrahend Subtrahend\r\n     * @returns {!Long} Difference\r\n     */\r\n    LongPrototype.sub = LongPrototype.subtract;\r\n\r\n    /**\r\n     * Returns the product of this and the specified Long.\r\n     * @param {!Long|number|string} multiplier Multiplier\r\n     * @returns {!Long} Product\r\n     */\r\n    LongPrototype.multiply = function multiply(multiplier) {\r\n        if (this.isZero())\r\n            return ZERO;\r\n        if (!isLong(multiplier))\r\n            multiplier = fromValue(multiplier);\r\n        if (multiplier.isZero())\r\n            return ZERO;\r\n        if (this.eq(MIN_VALUE))\r\n            return multiplier.isOdd() ? MIN_VALUE : ZERO;\r\n        if (multiplier.eq(MIN_VALUE))\r\n            return this.isOdd() ? MIN_VALUE : ZERO;\r\n\r\n        if (this.isNegative()) {\r\n            if (multiplier.isNegative())\r\n                return this.neg().mul(multiplier.neg());\r\n            else\r\n                return this.neg().mul(multiplier).neg();\r\n        } else if (multiplier.isNegative())\r\n            return this.mul(multiplier.neg()).neg();\r\n\r\n        // If both longs are small, use float multiplication\r\n        if (this.lt(TWO_PWR_24) && multiplier.lt(TWO_PWR_24))\r\n            return fromNumber(this.toNumber() * multiplier.toNumber(), this.unsigned);\r\n\r\n        // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\r\n        // We can skip products that would overflow.\r\n\r\n        var a48 = this.high >>> 16;\r\n        var a32 = this.high & 0xFFFF;\r\n        var a16 = this.low >>> 16;\r\n        var a00 = this.low & 0xFFFF;\r\n\r\n        var b48 = multiplier.high >>> 16;\r\n        var b32 = multiplier.high & 0xFFFF;\r\n        var b16 = multiplier.low >>> 16;\r\n        var b00 = multiplier.low & 0xFFFF;\r\n\r\n        var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\r\n        c00 += a00 * b00;\r\n        c16 += c00 >>> 16;\r\n        c00 &= 0xFFFF;\r\n        c16 += a16 * b00;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c16 += a00 * b16;\r\n        c32 += c16 >>> 16;\r\n        c16 &= 0xFFFF;\r\n        c32 += a32 * b00;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c32 += a16 * b16;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c32 += a00 * b32;\r\n        c48 += c32 >>> 16;\r\n        c32 &= 0xFFFF;\r\n        c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\r\n        c48 &= 0xFFFF;\r\n        return fromBits((c16 << 16) | c00, (c48 << 16) | c32, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the product of this and the specified Long. This is an alias of {@link Long#multiply}.\r\n     * @function\r\n     * @param {!Long|number|string} multiplier Multiplier\r\n     * @returns {!Long} Product\r\n     */\r\n    LongPrototype.mul = LongPrototype.multiply;\r\n\r\n    /**\r\n     * Returns this Long divided by the specified. The result is signed if this Long is signed or\r\n     *  unsigned if this Long is unsigned.\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Quotient\r\n     */\r\n    LongPrototype.divide = function divide(divisor) {\r\n        if (!isLong(divisor))\r\n            divisor = fromValue(divisor);\r\n        if (divisor.isZero())\r\n            throw Error('division by zero');\r\n        if (this.isZero())\r\n            return this.unsigned ? UZERO : ZERO;\r\n        var approx, rem, res;\r\n        if (!this.unsigned) {\r\n            // This section is only relevant for signed longs and is derived from the\r\n            // closure library as a whole.\r\n            if (this.eq(MIN_VALUE)) {\r\n                if (divisor.eq(ONE) || divisor.eq(NEG_ONE))\r\n                    return MIN_VALUE;  // recall that -MIN_VALUE == MIN_VALUE\r\n                else if (divisor.eq(MIN_VALUE))\r\n                    return ONE;\r\n                else {\r\n                    // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\r\n                    var halfThis = this.shr(1);\r\n                    approx = halfThis.div(divisor).shl(1);\r\n                    if (approx.eq(ZERO)) {\r\n                        return divisor.isNegative() ? ONE : NEG_ONE;\r\n                    } else {\r\n                        rem = this.sub(divisor.mul(approx));\r\n                        res = approx.add(rem.div(divisor));\r\n                        return res;\r\n                    }\r\n                }\r\n            } else if (divisor.eq(MIN_VALUE))\r\n                return this.unsigned ? UZERO : ZERO;\r\n            if (this.isNegative()) {\r\n                if (divisor.isNegative())\r\n                    return this.neg().div(divisor.neg());\r\n                return this.neg().div(divisor).neg();\r\n            } else if (divisor.isNegative())\r\n                return this.div(divisor.neg()).neg();\r\n            res = ZERO;\r\n        } else {\r\n            // The algorithm below has not been made for unsigned longs. It's therefore\r\n            // required to take special care of the MSB prior to running it.\r\n            if (!divisor.unsigned)\r\n                divisor = divisor.toUnsigned();\r\n            if (divisor.gt(this))\r\n                return UZERO;\r\n            if (divisor.gt(this.shru(1))) // 15 >>> 1 = 7 ; with divisor = 8 ; true\r\n                return UONE;\r\n            res = UZERO;\r\n        }\r\n\r\n        // Repeat the following until the remainder is less than other:  find a\r\n        // floating-point that approximates remainder / other *from below*, add this\r\n        // into the result, and subtract it from the remainder.  It is critical that\r\n        // the approximate value is less than or equal to the real value so that the\r\n        // remainder never becomes negative.\r\n        rem = this;\r\n        while (rem.gte(divisor)) {\r\n            // Approximate the result of division. This may be a little greater or\r\n            // smaller than the actual value.\r\n            approx = Math.max(1, Math.floor(rem.toNumber() / divisor.toNumber()));\r\n\r\n            // We will tweak the approximate result by changing it in the 48-th digit or\r\n            // the smallest non-fractional digit, whichever is larger.\r\n            var log2 = Math.ceil(Math.log(approx) / Math.LN2),\r\n                delta = (log2 <= 48) ? 1 : pow_dbl(2, log2 - 48),\r\n\r\n            // Decrease the approximation until it is smaller than the remainder.  Note\r\n            // that if it is too large, the product overflows and is negative.\r\n                approxRes = fromNumber(approx),\r\n                approxRem = approxRes.mul(divisor);\r\n            while (approxRem.isNegative() || approxRem.gt(rem)) {\r\n                approx -= delta;\r\n                approxRes = fromNumber(approx, this.unsigned);\r\n                approxRem = approxRes.mul(divisor);\r\n            }\r\n\r\n            // We know the answer can't be zero... and actually, zero would cause\r\n            // infinite recursion since we would make no progress.\r\n            if (approxRes.isZero())\r\n                approxRes = ONE;\r\n\r\n            res = res.add(approxRes);\r\n            rem = rem.sub(approxRem);\r\n        }\r\n        return res;\r\n    };\r\n\r\n    /**\r\n     * Returns this Long divided by the specified. This is an alias of {@link Long#divide}.\r\n     * @function\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Quotient\r\n     */\r\n    LongPrototype.div = LongPrototype.divide;\r\n\r\n    /**\r\n     * Returns this Long modulo the specified.\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Remainder\r\n     */\r\n    LongPrototype.modulo = function modulo(divisor) {\r\n        if (!isLong(divisor))\r\n            divisor = fromValue(divisor);\r\n        return this.sub(this.div(divisor).mul(divisor));\r\n    };\r\n\r\n    /**\r\n     * Returns this Long modulo the specified. This is an alias of {@link Long#modulo}.\r\n     * @function\r\n     * @param {!Long|number|string} divisor Divisor\r\n     * @returns {!Long} Remainder\r\n     */\r\n    LongPrototype.mod = LongPrototype.modulo;\r\n\r\n    /**\r\n     * Returns the bitwise NOT of this Long.\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.not = function not() {\r\n        return fromBits(~this.low, ~this.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise AND of this Long and the specified.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.and = function and(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low & other.low, this.high & other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise OR of this Long and the specified.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.or = function or(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low | other.low, this.high | other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns the bitwise XOR of this Long and the given one.\r\n     * @param {!Long|number|string} other Other Long\r\n     * @returns {!Long}\r\n     */\r\n    LongPrototype.xor = function xor(other) {\r\n        if (!isLong(other))\r\n            other = fromValue(other);\r\n        return fromBits(this.low ^ other.low, this.high ^ other.high, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits shifted to the left by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftLeft = function shiftLeft(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        if ((numBits &= 63) === 0)\r\n            return this;\r\n        else if (numBits < 32)\r\n            return fromBits(this.low << numBits, (this.high << numBits) | (this.low >>> (32 - numBits)), this.unsigned);\r\n        else\r\n            return fromBits(0, this.low << (numBits - 32), this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits shifted to the left by the given amount. This is an alias of {@link Long#shiftLeft}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shl = LongPrototype.shiftLeft;\r\n\r\n    /**\r\n     * Returns this Long with bits arithmetically shifted to the right by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftRight = function shiftRight(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        if ((numBits &= 63) === 0)\r\n            return this;\r\n        else if (numBits < 32)\r\n            return fromBits((this.low >>> numBits) | (this.high << (32 - numBits)), this.high >> numBits, this.unsigned);\r\n        else\r\n            return fromBits(this.high >> (numBits - 32), this.high >= 0 ? 0 : -1, this.unsigned);\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits arithmetically shifted to the right by the given amount. This is an alias of {@link Long#shiftRight}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shr = LongPrototype.shiftRight;\r\n\r\n    /**\r\n     * Returns this Long with bits logically shifted to the right by the given amount.\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shiftRightUnsigned = function shiftRightUnsigned(numBits) {\r\n        if (isLong(numBits))\r\n            numBits = numBits.toInt();\r\n        numBits &= 63;\r\n        if (numBits === 0)\r\n            return this;\r\n        else {\r\n            var high = this.high;\r\n            if (numBits < 32) {\r\n                var low = this.low;\r\n                return fromBits((low >>> numBits) | (high << (32 - numBits)), high >>> numBits, this.unsigned);\r\n            } else if (numBits === 32)\r\n                return fromBits(high, 0, this.unsigned);\r\n            else\r\n                return fromBits(high >>> (numBits - 32), 0, this.unsigned);\r\n        }\r\n    };\r\n\r\n    /**\r\n     * Returns this Long with bits logically shifted to the right by the given amount. This is an alias of {@link Long#shiftRightUnsigned}.\r\n     * @function\r\n     * @param {number|!Long} numBits Number of bits\r\n     * @returns {!Long} Shifted Long\r\n     */\r\n    LongPrototype.shru = LongPrototype.shiftRightUnsigned;\r\n\r\n    /**\r\n     * Converts this Long to signed.\r\n     * @returns {!Long} Signed long\r\n     */\r\n    LongPrototype.toSigned = function toSigned() {\r\n        if (!this.unsigned)\r\n            return this;\r\n        return fromBits(this.low, this.high, false);\r\n    };\r\n\r\n    /**\r\n     * Converts this Long to unsigned.\r\n     * @returns {!Long} Unsigned long\r\n     */\r\n    LongPrototype.toUnsigned = function toUnsigned() {\r\n        if (this.unsigned)\r\n            return this;\r\n        return fromBits(this.low, this.high, true);\r\n    };\r\n\r\n    /**\r\n     * Converts this Long to its byte representation.\r\n     * @param {boolean=} le Whether little or big endian, defaults to big endian\r\n     * @returns {!Array.<number>} Byte representation\r\n     */\r\n    LongPrototype.toBytes = function(le) {\r\n        return le ? this.toBytesLE() : this.toBytesBE();\r\n    }\r\n\r\n    /**\r\n     * Converts this Long to its little endian byte representation.\r\n     * @returns {!Array.<number>} Little endian byte representation\r\n     */\r\n    LongPrototype.toBytesLE = function() {\r\n        var hi = this.high,\r\n            lo = this.low;\r\n        return [\r\n             lo         & 0xff,\r\n            (lo >>>  8) & 0xff,\r\n            (lo >>> 16) & 0xff,\r\n            (lo >>> 24) & 0xff,\r\n             hi         & 0xff,\r\n            (hi >>>  8) & 0xff,\r\n            (hi >>> 16) & 0xff,\r\n            (hi >>> 24) & 0xff\r\n        ];\r\n    }\r\n\r\n    /**\r\n     * Converts this Long to its big endian byte representation.\r\n     * @returns {!Array.<number>} Big endian byte representation\r\n     */\r\n    LongPrototype.toBytesBE = function() {\r\n        var hi = this.high,\r\n            lo = this.low;\r\n        return [\r\n            (hi >>> 24) & 0xff,\r\n            (hi >>> 16) & 0xff,\r\n            (hi >>>  8) & 0xff,\r\n             hi         & 0xff,\r\n            (lo >>> 24) & 0xff,\r\n            (lo >>> 16) & 0xff,\r\n            (lo >>>  8) & 0xff,\r\n             lo         & 0xff\r\n        ];\r\n    }\r\n\r\n    return Long;\r\n});\r\n"],"sourceRoot":""}