gaussian-id 2.34.1 → 2.34.3

package/dist/mapillary-js/mapillary.unminified.js

@@ -4,132 +4,132 @@
     (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.mapillary = {}));
 })(this, (function (exports) { 'use strict';
 
-    /*! *****************************************************************************
-    Copyright (c) Microsoft Corporation.
-
-    Permission to use, copy, modify, and/or distribute this software for any
-    purpose with or without fee is hereby granted.
-
-    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-    PERFORMANCE OF THIS SOFTWARE.
-    ***************************************************************************** */
-    /* global Reflect, Promise */
-
-    var extendStatics = function(d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    };
-
-    function __extends(d, b) {
-        if (typeof b !== "function" && b !== null)
-            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    }
-
-    function __awaiter(thisArg, _arguments, P, generator) {
-        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-        return new (P || (P = Promise))(function (resolve, reject) {
-            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-            step((generator = generator.apply(thisArg, _arguments || [])).next());
-        });
-    }
-
-    function __generator(thisArg, body) {
-        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
-        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
-        function verb(n) { return function (v) { return step([n, v]); }; }
-        function step(op) {
-            if (f) throw new TypeError("Generator is already executing.");
-            while (_) try {
-                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
-                if (y = 0, t) op = [op[0] & 2, t.value];
-                switch (op[0]) {
-                    case 0: case 1: t = op; break;
-                    case 4: _.label++; return { value: op[1], done: false };
-                    case 5: _.label++; y = op[1]; op = [0]; continue;
-                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
-                    default:
-                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
-                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
-                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
-                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
-                        if (t[2]) _.ops.pop();
-                        _.trys.pop(); continue;
-                }
-                op = body.call(thisArg, _);
-            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
-            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
-        }
-    }
-
-    function __values(o) {
-        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-        if (m) return m.call(o);
-        if (o && typeof o.length === "number") return {
-            next: function () {
-                if (o && i >= o.length) o = void 0;
-                return { value: o && o[i++], done: !o };
-            }
-        };
-        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-    }
-
-    function __read(o, n) {
-        var m = typeof Symbol === "function" && o[Symbol.iterator];
-        if (!m) return o;
-        var i = m.call(o), r, ar = [], e;
-        try {
-            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
-        }
-        catch (error) { e = { error: error }; }
-        finally {
-            try {
-                if (r && !r.done && (m = i["return"])) m.call(i);
-            }
-            finally { if (e) throw e.error; }
-        }
-        return ar;
-    }
-
-    function __spreadArray(to, from) {
-        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
-            to[j] = from[i];
-        return to;
-    }
-
-    function __await(v) {
-        return this instanceof __await ? (this.v = v, this) : new __await(v);
-    }
-
-    function __asyncGenerator(thisArg, _arguments, generator) {
-        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-        var g = generator.apply(thisArg, _arguments || []), i, q = [];
-        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
-        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
-        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-        function fulfill(value) { resume("next", value); }
-        function reject(value) { resume("throw", value); }
-        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-    }
-
-    function __asyncValues(o) {
-        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-        var m = o[Symbol.asyncIterator], i;
-        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+    /*! *****************************************************************************
+    Copyright (c) Microsoft Corporation.
+
+    Permission to use, copy, modify, and/or distribute this software for any
+    purpose with or without fee is hereby granted.
+
+    THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+    REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+    AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+    INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+    LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+    OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+    PERFORMANCE OF THIS SOFTWARE.
+    ***************************************************************************** */
+    /* global Reflect, Promise */
+
+    var extendStatics = function(d, b) {
+        extendStatics = Object.setPrototypeOf ||
+            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+            function (d, b) { for (var p in b) if (Object.prototype.hasOwnProperty.call(b, p)) d[p] = b[p]; };
+        return extendStatics(d, b);
+    };
+
+    function __extends(d, b) {
+        if (typeof b !== "function" && b !== null)
+            throw new TypeError("Class extends value " + String(b) + " is not a constructor or null");
+        extendStatics(d, b);
+        function __() { this.constructor = d; }
+        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+    }
+
+    function __awaiter(thisArg, _arguments, P, generator) {
+        function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+        return new (P || (P = Promise))(function (resolve, reject) {
+            function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+            function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+            function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+            step((generator = generator.apply(thisArg, _arguments || [])).next());
+        });
+    }
+
+    function __generator(thisArg, body) {
+        var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+        return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+        function verb(n) { return function (v) { return step([n, v]); }; }
+        function step(op) {
+            if (f) throw new TypeError("Generator is already executing.");
+            while (_) try {
+                if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+                if (y = 0, t) op = [op[0] & 2, t.value];
+                switch (op[0]) {
+                    case 0: case 1: t = op; break;
+                    case 4: _.label++; return { value: op[1], done: false };
+                    case 5: _.label++; y = op[1]; op = [0]; continue;
+                    case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                    default:
+                        if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                        if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                        if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                        if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                        if (t[2]) _.ops.pop();
+                        _.trys.pop(); continue;
+                }
+                op = body.call(thisArg, _);
+            } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+            if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+        }
+    }
+
+    function __values(o) {
+        var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
+        if (m) return m.call(o);
+        if (o && typeof o.length === "number") return {
+            next: function () {
+                if (o && i >= o.length) o = void 0;
+                return { value: o && o[i++], done: !o };
+            }
+        };
+        throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
+    }
+
+    function __read(o, n) {
+        var m = typeof Symbol === "function" && o[Symbol.iterator];
+        if (!m) return o;
+        var i = m.call(o), r, ar = [], e;
+        try {
+            while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+        }
+        catch (error) { e = { error: error }; }
+        finally {
+            try {
+                if (r && !r.done && (m = i["return"])) m.call(i);
+            }
+            finally { if (e) throw e.error; }
+        }
+        return ar;
+    }
+
+    function __spreadArray(to, from) {
+        for (var i = 0, il = from.length, j = to.length; i < il; i++, j++)
+            to[j] = from[i];
+        return to;
+    }
+
+    function __await(v) {
+        return this instanceof __await ? (this.v = v, this) : new __await(v);
+    }
+
+    function __asyncGenerator(thisArg, _arguments, generator) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var g = generator.apply(thisArg, _arguments || []), i, q = [];
+        return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+        function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+        function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+        function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+        function fulfill(value) { resume("next", value); }
+        function reject(value) { resume("throw", value); }
+        function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+    }
+
+    function __asyncValues(o) {
+        if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+        var m = o[Symbol.asyncIterator], i;
+        return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+        function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+        function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
     }
 
     function isFunction(value) {
@@ -49748,10 +49748,10 @@
         return w && w.type === "Widget"
     }
 
-    var isThunk_1 = isThunk$3;
-
-    function isThunk$3(t) {
-        return t && t.type === "Thunk"
+    var isThunk_1 = isThunk$3;
+
+    function isThunk$3(t) {
+        return t && t.type === "Thunk"
     }
 
     var isVNode$4 = isVnode;
@@ -51899,20 +51899,20 @@
 
     var createElement_1 = createElement;
 
-    var diff = diff_1;
-    var patch = patch_1;
-    var h = h_1;
-    var create = createElement_1;
-    var VNode = vnode;
-    var VText = vtext;
-
-    var virtualDom = {
-        diff: diff,
-        patch: patch,
-        h: h,
-        create: create,
-        VNode: VNode,
-        VText: VText
+    var diff = diff_1;
+    var patch = patch_1;
+    var h = h_1;
+    var create = createElement_1;
+    var VNode = vnode;
+    var VText = vtext;
+
+    var virtualDom = {
+        diff: diff,
+        patch: patch,
+        h: h,
+        create: create,
+        VNode: VNode,
+        VText: VText
     };
 
     class EventEmitter {
@@ -77358,1212 +77358,1212 @@ void main()
 
     var long = {exports: {}};
 
-    /*
-     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.
+    /*
+     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.
      */
 
     (function (module) {
-    /**
-     * @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 commonjsRequire === 'function' && 'object' === "object" && module && module["exports"])
-            module["exports"] = factory();
-        /* Global */ else
-            (global["dcodeIO"] = global["dcodeIO"] || {})["Long"] = factory();
-
-    })(commonjsGlobal, function() {
-
-        /**
-         * 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;
+    /**
+     * @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 commonjsRequire === 'function' && 'object' === "object" && module && module["exports"])
+            module["exports"] = factory();
+        /* Global */ else
+            (global["dcodeIO"] = global["dcodeIO"] || {})["Long"] = factory();
+
+    })(commonjsGlobal, function() {
+
+        /**
+         * 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;
     });
     }(long));