@p4ulcristian/iris-layout 0.2.0 → 0.2.2

package/dist/cljs-runtime/goog.math.long.js

@@ -0,0 +1,437 @@
+import "./cljs_env.js";
+import "./goog.asserts.asserts.js";
+import "./goog.reflect.reflect.js";
+goog.loadModule(function(exports) {
+  function getCachedIntValue_(value) {
+    return reflect.cache(IntCache_, value, function(val) {
+      return new Long(val, val < 0 ? -1 : 0);
+    });
+  }
+  "use strict";
+  goog.module("goog.math.Long");
+  goog.module.declareLegacyNamespace();
+  const asserts = goog.require("goog.asserts");
+  const reflect = goog.require("goog.reflect");
+  class Long {
+    constructor(low, high) {
+      this.low_ = low | 0;
+      this.high_ = high | 0;
+    }
+    toInt() {
+      return this.low_;
+    }
+    toNumber() {
+      return this.high_ * TWO_PWR_32_DBL_ + this.getLowBitsUnsigned();
+    }
+    isSafeInteger() {
+      var top11Bits = this.high_ >> 21;
+      return top11Bits == 0 || top11Bits == -1 && !(this.low_ == 0 && this.high_ == (4292870144 | 0));
+    }
+    toString(opt_radix) {
+      var radix = opt_radix || 10;
+      if (radix < 2 || 36 < radix) {
+        throw new Error("radix out of range: " + radix);
+      }
+      if (this.isSafeInteger()) {
+        var asNumber = this.toNumber();
+        return radix == 10 ? "" + asNumber : asNumber.toString(radix);
+      }
+      var safeDigits = 14 - (radix >> 2);
+      var radixPowSafeDigits = Math.pow(radix, safeDigits);
+      var radixToPower = Long.fromBits(radixPowSafeDigits, radixPowSafeDigits / TWO_PWR_32_DBL_);
+      var remDiv = this.div(radixToPower);
+      var val = Math.abs(this.subtract(remDiv.multiply(radixToPower)).toNumber());
+      var digits = radix == 10 ? "" + val : val.toString(radix);
+      if (digits.length < safeDigits) {
+        digits = "0000000000000".slice(digits.length - safeDigits) + digits;
+      }
+      val = remDiv.toNumber();
+      return (radix == 10 ? val : val.toString(radix)) + digits;
+    }
+    toUnsignedString(opt_radix) {
+      if (this.high_ >= 0) {
+        return this.toString(opt_radix);
+      }
+      var radix = opt_radix || 10;
+      if (radix < 2 || 36 < radix) {
+        throw new Error("radix out of range: " + radix);
+      }
+      var longRadix = Long.fromInt(radix);
+      var quotient = this.shiftRightUnsigned(1).div(longRadix).shiftLeft(1);
+      var remainder = this.subtract(quotient.multiply(longRadix));
+      if (remainder.greaterThanOrEqual(longRadix)) {
+        quotient = quotient.add(Long.getOne());
+        remainder = this.subtract(quotient.multiply(longRadix));
+      }
+      return quotient.toString(radix) + remainder.toString(radix);
+    }
+    getHighBits() {
+      return this.high_;
+    }
+    getLowBits() {
+      return this.low_;
+    }
+    getLowBitsUnsigned() {
+      return this.low_ >>> 0;
+    }
+    getNumBitsAbs() {
+      if (this.isNegative()) {
+        if (this.equals(Long.getMinValue())) {
+          return 64;
+        } else {
+          return this.negate().getNumBitsAbs();
+        }
+      } else {
+        var val = this.high_ != 0 ? this.high_ : this.low_;
+        var bit = 31;
+        for (; bit > 0; bit--) {
+          if ((val & 1 << bit) != 0) {
+            break;
+          }
+        }
+        return this.high_ != 0 ? bit + 33 : bit + 1;
+      }
+    }
+    isZero() {
+      return this.low_ == 0 && this.high_ == 0;
+    }
+    isNegative() {
+      return this.high_ < 0;
+    }
+    isOdd() {
+      return (this.low_ & 1) == 1;
+    }
+    hashCode() {
+      return this.getLowBits() ^ this.getHighBits();
+    }
+    equals(other) {
+      return this.low_ == other.low_ && this.high_ == other.high_;
+    }
+    notEquals(other) {
+      return !this.equals(other);
+    }
+    lessThan(other) {
+      return this.compare(other) < 0;
+    }
+    lessThanOrEqual(other) {
+      return this.compare(other) <= 0;
+    }
+    greaterThan(other) {
+      return this.compare(other) > 0;
+    }
+    greaterThanOrEqual(other) {
+      return this.compare(other) >= 0;
+    }
+    compare(other) {
+      if (this.high_ == other.high_) {
+        if (this.low_ == other.low_) {
+          return 0;
+        }
+        return this.getLowBitsUnsigned() > other.getLowBitsUnsigned() ? 1 : -1;
+      }
+      return this.high_ > other.high_ ? 1 : -1;
+    }
+    negate() {
+      var negLow = ~this.low_ + 1 | 0;
+      var overflowFromLow = !negLow;
+      var negHigh = ~this.high_ + overflowFromLow | 0;
+      return Long.fromBits(negLow, negHigh);
+    }
+    add(other) {
+      var a48 = this.high_ >>> 16;
+      var a32 = this.high_ & 65535;
+      var a16 = this.low_ >>> 16;
+      var a00 = this.low_ & 65535;
+      var b48 = other.high_ >>> 16;
+      var b32 = other.high_ & 65535;
+      var b16 = other.low_ >>> 16;
+      var b00 = other.low_ & 65535;
+      var c48 = 0;
+      var c32 = 0;
+      var c16 = 0;
+      var c00 = 0;
+      c00 = c00 + (a00 + b00);
+      c16 = c16 + (c00 >>> 16);
+      c00 = c00 & 65535;
+      c16 = c16 + (a16 + b16);
+      c32 = c32 + (c16 >>> 16);
+      c16 = c16 & 65535;
+      c32 = c32 + (a32 + b32);
+      c48 = c48 + (c32 >>> 16);
+      c32 = c32 & 65535;
+      c48 = c48 + (a48 + b48);
+      c48 = c48 & 65535;
+      return Long.fromBits(c16 << 16 | c00, c48 << 16 | c32);
+    }
+    subtract(other) {
+      return this.add(other.negate());
+    }
+    multiply(other) {
+      if (this.isZero()) {
+        return this;
+      }
+      if (other.isZero()) {
+        return other;
+      }
+      var a48 = this.high_ >>> 16;
+      var a32 = this.high_ & 65535;
+      var a16 = this.low_ >>> 16;
+      var a00 = this.low_ & 65535;
+      var b48 = other.high_ >>> 16;
+      var b32 = other.high_ & 65535;
+      var b16 = other.low_ >>> 16;
+      var b00 = other.low_ & 65535;
+      var c48 = 0;
+      var c32 = 0;
+      var c16 = 0;
+      var c00 = 0;
+      c00 = c00 + a00 * b00;
+      c16 = c16 + (c00 >>> 16);
+      c00 = c00 & 65535;
+      c16 = c16 + a16 * b00;
+      c32 = c32 + (c16 >>> 16);
+      c16 = c16 & 65535;
+      c16 = c16 + a00 * b16;
+      c32 = c32 + (c16 >>> 16);
+      c16 = c16 & 65535;
+      c32 = c32 + a32 * b00;
+      c48 = c48 + (c32 >>> 16);
+      c32 = c32 & 65535;
+      c32 = c32 + a16 * b16;
+      c48 = c48 + (c32 >>> 16);
+      c32 = c32 & 65535;
+      c32 = c32 + a00 * b32;
+      c48 = c48 + (c32 >>> 16);
+      c32 = c32 & 65535;
+      c48 = c48 + (a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48);
+      c48 = c48 & 65535;
+      return Long.fromBits(c16 << 16 | c00, c48 << 16 | c32);
+    }
+    div(other) {
+      if (other.isZero()) {
+        throw new Error("division by zero");
+      }
+      if (this.isNegative()) {
+        if (this.equals(Long.getMinValue())) {
+          if (other.equals(Long.getOne()) || other.equals(Long.getNegOne())) {
+            return Long.getMinValue();
+          }
+          if (other.equals(Long.getMinValue())) {
+            return Long.getOne();
+          }
+          var halfThis = this.shiftRight(1);
+          var approx = halfThis.div(other).shiftLeft(1);
+          if (approx.equals(Long.getZero())) {
+            return other.isNegative() ? Long.getOne() : Long.getNegOne();
+          }
+          var rem = this.subtract(other.multiply(approx));
+          var result = approx.add(rem.div(other));
+          return result;
+        }
+        if (other.isNegative()) {
+          return this.negate().div(other.negate());
+        }
+        return this.negate().div(other).negate();
+      }
+      if (this.isZero()) {
+        return Long.getZero();
+      }
+      if (other.isNegative()) {
+        if (other.equals(Long.getMinValue())) {
+          return Long.getZero();
+        }
+        return this.div(other.negate()).negate();
+      }
+      var res = Long.getZero();
+      rem = this;
+      for (; rem.greaterThanOrEqual(other);) {
+        approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));
+        var log2 = Math.ceil(Math.log(approx) / Math.LN2);
+        var delta = log2 <= 48 ? 1 : Math.pow(2, log2 - 48);
+        var approxRes = Long.fromNumber(approx);
+        var approxRem = approxRes.multiply(other);
+        for (; approxRem.isNegative() || approxRem.greaterThan(rem);) {
+          approx = approx - delta;
+          approxRes = Long.fromNumber(approx);
+          approxRem = approxRes.multiply(other);
+        }
+        if (approxRes.isZero()) {
+          approxRes = Long.getOne();
+        }
+        res = res.add(approxRes);
+        rem = rem.subtract(approxRem);
+      }
+      return res;
+    }
+    modulo(other) {
+      return this.subtract(this.div(other).multiply(other));
+    }
+    not() {
+      return Long.fromBits(~this.low_, ~this.high_);
+    }
+    and(other) {
+      return Long.fromBits(this.low_ & other.low_, this.high_ & other.high_);
+    }
+    or(other) {
+      return Long.fromBits(this.low_ | other.low_, this.high_ | other.high_);
+    }
+    xor(other) {
+      return Long.fromBits(this.low_ ^ other.low_, this.high_ ^ other.high_);
+    }
+    shiftLeft(numBits) {
+      numBits = numBits & 63;
+      if (numBits == 0) {
+        return this;
+      } else {
+        var low = this.low_;
+        if (numBits < 32) {
+          var high = this.high_;
+          return Long.fromBits(low << numBits, high << numBits | low >>> 32 - numBits);
+        } else {
+          return Long.fromBits(0, low << numBits - 32);
+        }
+      }
+    }
+    shiftRight(numBits) {
+      numBits = numBits & 63;
+      if (numBits == 0) {
+        return this;
+      } else {
+        var high = this.high_;
+        if (numBits < 32) {
+          var low = this.low_;
+          return Long.fromBits(low >>> numBits | high << 32 - numBits, high >> numBits);
+        } else {
+          return Long.fromBits(high >> numBits - 32, high >= 0 ? 0 : -1);
+        }
+      }
+    }
+    shiftRightUnsigned(numBits) {
+      numBits = numBits & 63;
+      if (numBits == 0) {
+        return this;
+      } else {
+        var high = this.high_;
+        if (numBits < 32) {
+          var low = this.low_;
+          return Long.fromBits(low >>> numBits | high << 32 - numBits, high >>> numBits);
+        } else if (numBits == 32) {
+          return Long.fromBits(high, 0);
+        } else {
+          return Long.fromBits(high >>> numBits - 32, 0);
+        }
+      }
+    }
+    static fromInt(value) {
+      var intValue = value | 0;
+      asserts.assert(value === intValue, "value should be a 32-bit integer");
+      if (-128 <= intValue && intValue < 128) {
+        return getCachedIntValue_(intValue);
+      } else {
+        return new Long(intValue, intValue < 0 ? -1 : 0);
+      }
+    }
+    static fromNumber(value) {
+      if (value > 0) {
+        if (value >= TWO_PWR_63_DBL_) {
+          return Long.getMaxValue();
+        }
+        return new Long(value, value / TWO_PWR_32_DBL_);
+      } else if (value < 0) {
+        if (value <= -TWO_PWR_63_DBL_) {
+          return Long.getMinValue();
+        }
+        return (new Long(-value, -value / TWO_PWR_32_DBL_)).negate();
+      } else {
+        return Long.getZero();
+      }
+    }
+    static fromBits(lowBits, highBits) {
+      return new Long(lowBits, highBits);
+    }
+    static fromString(str, opt_radix) {
+      if (str.charAt(0) == "-") {
+        return Long.fromString(str.substring(1), opt_radix).negate();
+      }
+      var numberValue = parseInt(str, opt_radix || 10);
+      if (numberValue <= MAX_SAFE_INTEGER_) {
+        return new Long(numberValue % TWO_PWR_32_DBL_ | 0, numberValue / TWO_PWR_32_DBL_ | 0);
+      }
+      if (str.length == 0) {
+        throw new Error("number format error: empty string");
+      }
+      if (str.indexOf("-") >= 0) {
+        throw new Error('number format error: interior "-" character: ' + str);
+      }
+      var radix = opt_radix || 10;
+      if (radix < 2 || 36 < radix) {
+        throw new Error("radix out of range: " + radix);
+      }
+      var radixToPower = Long.fromNumber(Math.pow(radix, 8));
+      var result = Long.getZero();
+      var i = 0;
+      for (; i < str.length; i = i + 8) {
+        var size = Math.min(8, str.length - i);
+        var value = parseInt(str.substring(i, i + size), radix);
+        if (size < 8) {
+          var power = Long.fromNumber(Math.pow(radix, size));
+          result = result.multiply(power).add(Long.fromNumber(value));
+        } else {
+          result = result.multiply(radixToPower);
+          result = result.add(Long.fromNumber(value));
+        }
+      }
+      return result;
+    }
+    static isStringInRange(str, opt_radix) {
+      var radix = opt_radix || 10;
+      if (radix < 2 || 36 < radix) {
+        throw new Error("radix out of range: " + radix);
+      }
+      var extremeValue = str.charAt(0) == "-" ? MIN_VALUE_FOR_RADIX_[radix] : MAX_VALUE_FOR_RADIX_[radix];
+      if (str.length < extremeValue.length) {
+        return true;
+      } else if (str.length == extremeValue.length && str <= extremeValue) {
+        return true;
+      } else {
+        return false;
+      }
+    }
+    static getZero() {
+      return ZERO_;
+    }
+    static getOne() {
+      return ONE_;
+    }
+    static getNegOne() {
+      return NEG_ONE_;
+    }
+    static getMaxValue() {
+      return MAX_VALUE_;
+    }
+    static getMinValue() {
+      return MIN_VALUE_;
+    }
+    static getTwoPwr24() {
+      return TWO_PWR_24_;
+    }
+  }
+  exports = Long;
+  const IntCache_ = {};
+  const MAX_VALUE_FOR_RADIX_ = ["", "", "111111111111111111111111111111111111111111111111111111111111111", "2021110011022210012102010021220101220221", "13333333333333333333333333333333", "1104332401304422434310311212", "1540241003031030222122211", "22341010611245052052300", "777777777777777777777", "67404283172107811827", "9223372036854775807", "1728002635214590697", "41a792678515120367", "10b269549075433c37", "4340724c6c71dc7a7", "160e2ad3246366807", "7fffffffffffffff", "33d3d8307b214008", "16agh595df825fa7", 
+  "ba643dci0ffeehh", "5cbfjia3fh26ja7", "2heiciiie82dh97", "1adaibb21dckfa7", "i6k448cf4192c2", "acd772jnc9l0l7", "64ie1focnn5g77", "3igoecjbmca687", "27c48l5b37oaop", "1bk39f3ah3dmq7", "q1se8f0m04isb", "hajppbc1fc207", "bm03i95hia437", "7vvvvvvvvvvvv", "5hg4ck9jd4u37", "3tdtk1v8j6tpp", "2pijmikexrxp7", "1y2p0ij32e8e7"];
+  const MIN_VALUE_FOR_RADIX_ = ["", "", "-1000000000000000000000000000000000000000000000000000000000000000", "-2021110011022210012102010021220101220222", "-20000000000000000000000000000000", "-1104332401304422434310311213", "-1540241003031030222122212", "-22341010611245052052301", "-1000000000000000000000", "-67404283172107811828", "-9223372036854775808", "-1728002635214590698", "-41a792678515120368", "-10b269549075433c38", "-4340724c6c71dc7a8", "-160e2ad3246366808", "-8000000000000000", "-33d3d8307b214009", 
+  "-16agh595df825fa8", "-ba643dci0ffeehi", "-5cbfjia3fh26ja8", "-2heiciiie82dh98", "-1adaibb21dckfa8", "-i6k448cf4192c3", "-acd772jnc9l0l8", "-64ie1focnn5g78", "-3igoecjbmca688", "-27c48l5b37oaoq", "-1bk39f3ah3dmq8", "-q1se8f0m04isc", "-hajppbc1fc208", "-bm03i95hia438", "-8000000000000", "-5hg4ck9jd4u38", "-3tdtk1v8j6tpq", "-2pijmikexrxp8", "-1y2p0ij32e8e8"];
+  const MAX_SAFE_INTEGER_ = 9007199254740991;
+  const TWO_PWR_32_DBL_ = 4294967296;
+  const TWO_PWR_63_DBL_ = 0x7fffffffffffffff;
+  const ZERO_ = Long.fromBits(0, 0);
+  const ONE_ = Long.fromBits(1, 0);
+  const NEG_ONE_ = Long.fromBits(-1, -1);
+  const MAX_VALUE_ = Long.fromBits(4294967295, 2147483647);
+  const MIN_VALUE_ = Long.fromBits(0, 2147483648);
+  const TWO_PWR_24_ = Long.fromBits(1 << 24, 0);
+  return exports;
+});
+
+//# sourceMappingURL=goog.math.long.js.map

package/dist/cljs-runtime/goog.math.long.js.map

@@ -0,0 +1,9 @@
+{
+"version":3,
+"file":"goog.math.long.js",
+"lineCount":433,
+"mappings":"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",
+"sources":["goog/math/long.js"],
+"sourcesContent":["/**\n * @license\n * Copyright The Closure Library Authors.\n * SPDX-License-Identifier: Apache-2.0\n */\n\n/**\n * @fileoverview Defines a Long class for representing a 64-bit two's-complement\n * integer value, which faithfully simulates the behavior of a Java \"long\". This\n * implementation is derived from LongLib in GWT.\n */\n\ngoog.module('goog.math.Long');\ngoog.module.declareLegacyNamespace();\n\nconst asserts = goog.require('goog.asserts');\nconst reflect = goog.require('goog.reflect');\n\n/**\n * Represents a 64-bit two's-complement integer, given its low and high 32-bit\n * values as *signed* integers.  See the from* functions below for more\n * convenient ways of constructing Longs.\n *\n * The internal representation of a long is the two given signed, 32-bit values.\n * We use 32-bit pieces because these are the size of integers on which\n * JavaScript performs bit-operations.  For operations like addition and\n * multiplication, we split each number into 16-bit pieces, which can easily be\n * multiplied within JavaScript's floating-point representation without overflow\n * or change in sign.\n *\n * In the algorithms below, we frequently reduce the negative case to the\n * positive case by negating the input(s) and then post-processing the result.\n * Note that we must ALWAYS check specially whether those values are MIN_VALUE\n * (-2^63) because -MIN_VALUE == MIN_VALUE (since 2^63 cannot be represented as\n * a positive number, it overflows back into a negative).  Not handling this\n * case would often result in infinite recursion.\n * @final\n */\nclass Long {\n  /**\n   * @param {number} low  The low (signed) 32 bits of the long.\n   * @param {number} high  The high (signed) 32 bits of the long.\n   */\n  constructor(low, high) {\n    /**\n     * @const {number}\n     * @private\n     */\n    this.low_ = low | 0;  // force into 32 signed bits.\n\n    /**\n     * @const {number}\n     * @private\n     */\n    this.high_ = high | 0;  // force into 32 signed bits.\n  }\n\n  /** @return {number} The value, assuming it is a 32-bit integer. */\n  toInt() {\n    return this.low_;\n  }\n\n  /**\n   * @return {number} The closest floating-point representation to this value.\n   */\n  toNumber() {\n    return this.high_ * TWO_PWR_32_DBL_ + this.getLowBitsUnsigned();\n  }\n\n  /**\n   * @return {boolean} if can be exactly represented using number (i.e.\n   *     abs(value) < 2^53).\n   */\n  isSafeInteger() {\n    var top11Bits = this.high_ >> 21;\n    // If top11Bits are all 0s, then the number is between [0, 2^53-1]\n    return top11Bits == 0\n        // If top11Bits are all 1s, then the number is between [-1, -2^53]\n        || (top11Bits == -1\n            // and exclude -2^53\n            && !(this.low_ == 0 && this.high_ == (0xffe00000 | 0)));\n  }\n\n  /**\n   * @param {number=} opt_radix The radix in which the text should be written.\n   * @return {string} The textual representation of this value.\n   * @override\n   */\n  toString(opt_radix) {\n    var radix = opt_radix || 10;\n    if (radix < 2 || 36 < radix) {\n      throw new Error('radix out of range: ' + radix);\n    }\n\n    // We can avoid very expensive division based code path for some common\n    // cases.\n    if (this.isSafeInteger()) {\n      var asNumber = this.toNumber();\n      // Shortcutting for radix 10 (common case) to avoid boxing via toString:\n      // https://jsperf.com/tostring-vs-vs-if\n      return radix == 10 ? ('' + asNumber) : asNumber.toString(radix);\n    }\n\n    // We need to split 64bit integer into: `a * radix**safeDigits + b` where\n    // neither `a` nor `b` exceeds 53 bits, meaning that safeDigits can be any\n    // number in a range: [(63 - 53) / log2(radix); 53 / log2(radix)].\n\n    // Other options that need to be benchmarked:\n    //   11..16 - (radix >> 2);\n    //   10..13 - (radix >> 3);\n    //   10..11 - (radix >> 4);\n    var safeDigits = 14 - (radix >> 2);\n\n    var radixPowSafeDigits = Math.pow(radix, safeDigits);\n    var radixToPower =\n        Long.fromBits(radixPowSafeDigits, radixPowSafeDigits / TWO_PWR_32_DBL_);\n\n    var remDiv = this.div(radixToPower);\n    var val = Math.abs(this.subtract(remDiv.multiply(radixToPower)).toNumber());\n    var digits = radix == 10 ? ('' + val) : val.toString(radix);\n\n    if (digits.length < safeDigits) {\n      // Up to 13 leading 0s we might need to insert as the greatest safeDigits\n      // value is 14 (for radix 2).\n      digits = '0000000000000'.slice(digits.length - safeDigits) + digits;\n    }\n\n    val = remDiv.toNumber();\n    return (radix == 10 ? val : val.toString(radix)) + digits;\n  }\n\n  /**\n   * @param {number=} opt_radix The radix in which the text should be written.\n   * @return {string} The unsigned textual representation of this value.\n   */\n  toUnsignedString(opt_radix) {\n    // If the sign bit isn't even set just use the normal flow\n    if (this.high_ >= 0) {\n      return this.toString(opt_radix);\n    }\n\n    var radix = opt_radix || 10;\n    if (radix < 2 || 36 < radix) {\n      throw new Error('radix out of range: ' + radix);\n    }\n    // Use fromInt() to get the 64-bit representation of the radix as the entire\n    // radix range should be cached.\n    var longRadix = Long.fromInt(radix);\n    // Divide as unsigned 64-bit numbers.\n    var quotient = this.shiftRightUnsigned(1).div(longRadix).shiftLeft(1);\n    var remainder = this.subtract(quotient.multiply(longRadix));\n    // Check if we need to sign adjust the quotient.\n    if (remainder.greaterThanOrEqual(longRadix)) {\n      quotient = quotient.add(Long.getOne());\n      remainder = this.subtract(quotient.multiply(longRadix));\n    }\n    return quotient.toString(radix) + remainder.toString(radix);\n  }\n\n  /** @return {number} The high 32-bits as a signed value. */\n  getHighBits() {\n    return this.high_;\n  }\n\n  /** @return {number} The low 32-bits as a signed value. */\n  getLowBits() {\n    return this.low_;\n  }\n\n  /** @return {number} The low 32-bits as an unsigned value. */\n  getLowBitsUnsigned() {\n    // The right shifting fixes negative values in the case when\n    // intval >= 2^31; for more details see\n    // https://github.com/google/closure-library/pull/498\n    return this.low_ >>> 0;\n  }\n\n  /**\n   * @return {number} Returns the number of bits needed to represent the\n   *     absolute value of this Long.\n   */\n  getNumBitsAbs() {\n    if (this.isNegative()) {\n      if (this.equals(Long.getMinValue())) {\n        return 64;\n      } else {\n        return this.negate().getNumBitsAbs();\n      }\n    } else {\n      var val = this.high_ != 0 ? this.high_ : this.low_;\n      for (var bit = 31; bit > 0; bit--) {\n        if ((val & (1 << bit)) != 0) {\n          break;\n        }\n      }\n      return this.high_ != 0 ? bit + 33 : bit + 1;\n    }\n  }\n\n  /** @return {boolean} Whether this value is zero. */\n  isZero() {\n    // Check low part first as there is high chance it's not 0.\n    return this.low_ == 0 && this.high_ == 0;\n  }\n\n  /** @return {boolean} Whether this value is negative. */\n  isNegative() {\n    return this.high_ < 0;\n  }\n\n  /** @return {boolean} Whether this value is odd. */\n  isOdd() {\n    return (this.low_ & 1) == 1;\n  }\n\n  /**\n   * Returns a hash code for this long object that similar java.lang.Long one.\n   *\n   * @return {number} 32 bit hash code for this object.\n   */\n  hashCode() {\n    return this.getLowBits() ^ this.getHighBits();\n  }\n\n  /**\n   * @param {?Long} other Long to compare against.\n   * @return {boolean} Whether this Long equals the other.\n   */\n  equals(other) {\n    // Compare low parts first as there is higher chance they are different.\n    return (this.low_ == other.low_) && (this.high_ == other.high_);\n  }\n\n  /**\n   * @param {?Long} other Long to compare against.\n   * @return {boolean} Whether this Long does not equal the other.\n   */\n  notEquals(other) {\n    return !this.equals(other);\n  }\n\n  /**\n   * @param {?Long} other Long to compare against.\n   * @return {boolean} Whether this Long is less than the other.\n   */\n  lessThan(other) {\n    return this.compare(other) < 0;\n  }\n\n  /**\n   * @param {?Long} other Long to compare against.\n   * @return {boolean} Whether this Long is less than or equal to the other.\n   */\n  lessThanOrEqual(other) {\n    return this.compare(other) <= 0;\n  }\n\n  /**\n   * @param {?Long} other Long to compare against.\n   * @return {boolean} Whether this Long is greater than the other.\n   */\n  greaterThan(other) {\n    return this.compare(other) > 0;\n  }\n\n  /**\n   * @param {?Long} other Long to compare against.\n   * @return {boolean} Whether this Long is greater than or equal to the other.\n   */\n  greaterThanOrEqual(other) {\n    return this.compare(other) >= 0;\n  }\n\n  /**\n   * Compares this Long with the given one.\n   * @param {?Long} other Long to compare against.\n   * @return {number} 0 if they are the same, 1 if the this is greater, and -1\n   *     if the given one is greater.\n   */\n  compare(other) {\n    if (this.high_ == other.high_) {\n      if (this.low_ == other.low_) {\n        return 0;\n      }\n      return this.getLowBitsUnsigned() > other.getLowBitsUnsigned() ? 1 : -1;\n    }\n    return this.high_ > other.high_ ? 1 : -1;\n  }\n\n  /** @return {!Long} The negation of this value. */\n  negate() {\n    var negLow = (~this.low_ + 1) | 0;\n    var overflowFromLow = !negLow;\n    var negHigh = (~this.high_ + overflowFromLow) | 0;\n    return Long.fromBits(negLow, negHigh);\n  }\n\n  /**\n   * Returns the sum of this and the given Long.\n   * @param {?Long} other Long to add to this one.\n   * @return {!Long} The sum of this and the given Long.\n   */\n  add(other) {\n    // Divide each number into 4 chunks of 16 bits, and then sum the chunks.\n\n    var a48 = this.high_ >>> 16;\n    var a32 = this.high_ & 0xFFFF;\n    var a16 = this.low_ >>> 16;\n    var a00 = this.low_ & 0xFFFF;\n\n    var b48 = other.high_ >>> 16;\n    var b32 = other.high_ & 0xFFFF;\n    var b16 = other.low_ >>> 16;\n    var b00 = other.low_ & 0xFFFF;\n\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\n    c00 += a00 + b00;\n    c16 += c00 >>> 16;\n    c00 &= 0xFFFF;\n    c16 += a16 + b16;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c32 += a32 + b32;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c48 += a48 + b48;\n    c48 &= 0xFFFF;\n    return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);\n  }\n\n  /**\n   * Returns the difference of this and the given Long.\n   * @param {?Long} other Long to subtract from this.\n   * @return {!Long} The difference of this and the given Long.\n   */\n  subtract(other) {\n    return this.add(other.negate());\n  }\n\n  /**\n   * Returns the product of this and the given long.\n   * @param {?Long} other Long to multiply with this.\n   * @return {!Long} The product of this and the other.\n   */\n  multiply(other) {\n    if (this.isZero()) {\n      return this;\n    }\n    if (other.isZero()) {\n      return other;\n    }\n\n    // Divide each long into 4 chunks of 16 bits, and then add up 4x4 products.\n    // We can skip products that would overflow.\n\n    var a48 = this.high_ >>> 16;\n    var a32 = this.high_ & 0xFFFF;\n    var a16 = this.low_ >>> 16;\n    var a00 = this.low_ & 0xFFFF;\n\n    var b48 = other.high_ >>> 16;\n    var b32 = other.high_ & 0xFFFF;\n    var b16 = other.low_ >>> 16;\n    var b00 = other.low_ & 0xFFFF;\n\n    var c48 = 0, c32 = 0, c16 = 0, c00 = 0;\n    c00 += a00 * b00;\n    c16 += c00 >>> 16;\n    c00 &= 0xFFFF;\n    c16 += a16 * b00;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c16 += a00 * b16;\n    c32 += c16 >>> 16;\n    c16 &= 0xFFFF;\n    c32 += a32 * b00;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c32 += a16 * b16;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c32 += a00 * b32;\n    c48 += c32 >>> 16;\n    c32 &= 0xFFFF;\n    c48 += a48 * b00 + a32 * b16 + a16 * b32 + a00 * b48;\n    c48 &= 0xFFFF;\n    return Long.fromBits((c16 << 16) | c00, (c48 << 16) | c32);\n  }\n\n  /**\n   * Returns this Long divided by the given one.\n   * @param {?Long} other Long by which to divide.\n   * @return {!Long} This Long divided by the given one.\n   */\n  div(other) {\n    if (other.isZero()) {\n      throw new Error('division by zero');\n    }\n    if (this.isNegative()) {\n      if (this.equals(Long.getMinValue())) {\n        if (other.equals(Long.getOne()) || other.equals(Long.getNegOne())) {\n          return Long.getMinValue();  // recall -MIN_VALUE == MIN_VALUE\n        }\n        if (other.equals(Long.getMinValue())) {\n          return Long.getOne();\n        }\n        // At this point, we have |other| >= 2, so |this/other| < |MIN_VALUE|.\n        var halfThis = this.shiftRight(1);\n        var approx = halfThis.div(other).shiftLeft(1);\n        if (approx.equals(Long.getZero())) {\n          return other.isNegative() ? Long.getOne() : Long.getNegOne();\n        }\n        var rem = this.subtract(other.multiply(approx));\n        var result = approx.add(rem.div(other));\n        return result;\n      }\n      if (other.isNegative()) {\n        return this.negate().div(other.negate());\n      }\n      return this.negate().div(other).negate();\n    }\n    if (this.isZero()) {\n      return Long.getZero();\n    }\n    if (other.isNegative()) {\n      if (other.equals(Long.getMinValue())) {\n        return Long.getZero();\n      }\n      return this.div(other.negate()).negate();\n    }\n\n    // Repeat the following until the remainder is less than other:  find a\n    // floating-point that approximates remainder / other *from below*, add this\n    // into the result, and subtract it from the remainder.  It is critical that\n    // the approximate value is less than or equal to the real value so that the\n    // remainder never becomes negative.\n    var res = Long.getZero();\n    var rem = this;\n    while (rem.greaterThanOrEqual(other)) {\n      // Approximate the result of division. This may be a little greater or\n      // smaller than the actual value.\n      var approx = Math.max(1, Math.floor(rem.toNumber() / other.toNumber()));\n\n      // We will tweak the approximate result by changing it in the 48-th digit\n      // or the smallest non-fractional digit, whichever is larger.\n      var log2 = Math.ceil(Math.log(approx) / Math.LN2);\n      var delta = (log2 <= 48) ? 1 : Math.pow(2, log2 - 48);\n\n      // Decrease the approximation until it is smaller than the remainder. Note\n      // that if it is too large, the product overflows and is negative.\n      var approxRes = Long.fromNumber(approx);\n      var approxRem = approxRes.multiply(other);\n      while (approxRem.isNegative() || approxRem.greaterThan(rem)) {\n        approx -= delta;\n        approxRes = Long.fromNumber(approx);\n        approxRem = approxRes.multiply(other);\n      }\n\n      // We know the answer can't be zero... and actually, zero would cause\n      // infinite recursion since we would make no progress.\n      if (approxRes.isZero()) {\n        approxRes = Long.getOne();\n      }\n\n      res = res.add(approxRes);\n      rem = rem.subtract(approxRem);\n    }\n    return res;\n  }\n\n  /**\n   * Returns this Long modulo the given one.\n   * @param {?Long} other Long by which to mod.\n   * @return {!Long} This Long modulo the given one.\n   */\n  modulo(other) {\n    return this.subtract(this.div(other).multiply(other));\n  }\n\n  /** @return {!Long} The bitwise-NOT of this value. */\n  not() {\n    return Long.fromBits(~this.low_, ~this.high_);\n  }\n\n  /**\n   * Returns the bitwise-AND of this Long and the given one.\n   * @param {?Long} other The Long with which to AND.\n   * @return {!Long} The bitwise-AND of this and the other.\n   */\n  and(other) {\n    return Long.fromBits(this.low_ & other.low_, this.high_ & other.high_);\n  }\n\n  /**\n   * Returns the bitwise-OR of this Long and the given one.\n   * @param {?Long} other The Long with which to OR.\n   * @return {!Long} The bitwise-OR of this and the other.\n   */\n  or(other) {\n    return Long.fromBits(this.low_ | other.low_, this.high_ | other.high_);\n  }\n\n  /**\n   * Returns the bitwise-XOR of this Long and the given one.\n   * @param {?Long} other The Long with which to XOR.\n   * @return {!Long} The bitwise-XOR of this and the other.\n   */\n  xor(other) {\n    return Long.fromBits(this.low_ ^ other.low_, this.high_ ^ other.high_);\n  }\n\n  /**\n   * Returns this Long with bits shifted to the left by the given amount.\n   * @param {number} numBits The number of bits by which to shift.\n   * @return {!Long} This shifted to the left by the given amount.\n   */\n  shiftLeft(numBits) {\n    numBits &= 63;\n    if (numBits == 0) {\n      return this;\n    } else {\n      var low = this.low_;\n      if (numBits < 32) {\n        var high = this.high_;\n        return Long.fromBits(\n            low << numBits, (high << numBits) | (low >>> (32 - numBits)));\n      } else {\n        return Long.fromBits(0, low << (numBits - 32));\n      }\n    }\n  }\n\n  /**\n   * Returns this Long with bits shifted to the right by the given amount.\n   * The new leading bits match the current sign bit.\n   * @param {number} numBits The number of bits by which to shift.\n   * @return {!Long} This shifted to the right by the given amount.\n   */\n  shiftRight(numBits) {\n    numBits &= 63;\n    if (numBits == 0) {\n      return this;\n    } else {\n      var high = this.high_;\n      if (numBits < 32) {\n        var low = this.low_;\n        return Long.fromBits(\n            (low >>> numBits) | (high << (32 - numBits)), high >> numBits);\n      } else {\n        return Long.fromBits(high >> (numBits - 32), high >= 0 ? 0 : -1);\n      }\n    }\n  }\n\n  /**\n   * Returns this Long with bits shifted to the right by the given amount, with\n   * zeros placed into the new leading bits.\n   * @param {number} numBits The number of bits by which to shift.\n   * @return {!Long} This shifted to the right by the given amount,\n   *     with zeros placed into the new leading bits.\n   */\n  shiftRightUnsigned(numBits) {\n    numBits &= 63;\n    if (numBits == 0) {\n      return this;\n    } else {\n      var high = this.high_;\n      if (numBits < 32) {\n        var low = this.low_;\n        return Long.fromBits(\n            (low >>> numBits) | (high << (32 - numBits)), high >>> numBits);\n      } else if (numBits == 32) {\n        return Long.fromBits(high, 0);\n      } else {\n        return Long.fromBits(high >>> (numBits - 32), 0);\n      }\n    }\n  }\n\n  /**\n   * Returns a Long representing the given (32-bit) integer value.\n   * @param {number} value The 32-bit integer in question.\n   * @return {!Long} The corresponding Long value.\n   */\n  static fromInt(value) {\n    var intValue = value | 0;\n    asserts.assert(value === intValue, 'value should be a 32-bit integer');\n\n    if (-128 <= intValue && intValue < 128) {\n      return getCachedIntValue_(intValue);\n    } else {\n      return new Long(intValue, intValue < 0 ? -1 : 0);\n    }\n  }\n\n  /**\n   * Returns a Long representing the given value.\n   * NaN will be returned as zero. Infinity is converted to max value and\n   * -Infinity to min value.\n   * @param {number} value The number in question.\n   * @return {!Long} The corresponding Long value.\n   */\n  static fromNumber(value) {\n    if (value > 0) {\n      if (value >= TWO_PWR_63_DBL_) {\n        return Long.getMaxValue();\n      }\n      return new Long(value, value / TWO_PWR_32_DBL_);\n    } else if (value < 0) {\n      if (value <= -TWO_PWR_63_DBL_) {\n        return Long.getMinValue();\n      }\n      return new Long(-value, -value / TWO_PWR_32_DBL_).negate();\n    } else {\n      // NaN or 0.\n      return Long.getZero();\n    }\n  }\n\n  /**\n   * Returns a Long representing the 64-bit integer that comes by concatenating\n   * the given high and low bits.  Each is assumed to use 32 bits.\n   * @param {number} lowBits The low 32-bits.\n   * @param {number} highBits The high 32-bits.\n   * @return {!Long} The corresponding Long value.\n   */\n  static fromBits(lowBits, highBits) {\n    return new Long(lowBits, highBits);\n  }\n\n  /**\n   * Returns a Long representation of the given string, written using the given\n   * radix.\n   * @param {string} str The textual representation of the Long.\n   * @param {number=} opt_radix The radix in which the text is written.\n   * @return {!Long} The corresponding Long value.\n   */\n  static fromString(str, opt_radix) {\n    if (str.charAt(0) == '-') {\n      return Long.fromString(str.substring(1), opt_radix).negate();\n    }\n\n    // We can avoid very expensive multiply based code path for some common\n    // cases.\n    var numberValue = parseInt(str, opt_radix || 10);\n    if (numberValue <= MAX_SAFE_INTEGER_) {\n      return new Long(\n          (numberValue % TWO_PWR_32_DBL_) | 0,\n          (numberValue / TWO_PWR_32_DBL_) | 0);\n    }\n\n    if (str.length == 0) {\n      throw new Error('number format error: empty string');\n    }\n    if (str.indexOf('-') >= 0) {\n      throw new Error('number format error: interior \"-\" character: ' + str);\n    }\n\n    var radix = opt_radix || 10;\n    if (radix < 2 || 36 < radix) {\n      throw new Error('radix out of range: ' + radix);\n    }\n\n    // Do several (8) digits each time through the loop, so as to\n    // minimize the calls to the very expensive emulated multiply.\n    var radixToPower = Long.fromNumber(Math.pow(radix, 8));\n\n    var result = Long.getZero();\n    for (var i = 0; i < str.length; i += 8) {\n      var size = Math.min(8, str.length - i);\n      var value = parseInt(str.substring(i, i + size), radix);\n      if (size < 8) {\n        var power = Long.fromNumber(Math.pow(radix, size));\n        result = result.multiply(power).add(Long.fromNumber(value));\n      } else {\n        result = result.multiply(radixToPower);\n        result = result.add(Long.fromNumber(value));\n      }\n    }\n    return result;\n  }\n\n  /**\n   * Returns the boolean value of whether the input string is within a Long's\n   * range. Assumes an input string containing only numeric characters with an\n   * optional preceding '-'.\n   * @param {string} str The textual representation of the Long.\n   * @param {number=} opt_radix The radix in which the text is written.\n   * @return {boolean} Whether the string is within the range of a Long.\n   */\n  static isStringInRange(str, opt_radix) {\n    var radix = opt_radix || 10;\n    if (radix < 2 || 36 < radix) {\n      throw new Error('radix out of range: ' + radix);\n    }\n\n    var extremeValue = (str.charAt(0) == '-') ? MIN_VALUE_FOR_RADIX_[radix] :\n                                                MAX_VALUE_FOR_RADIX_[radix];\n\n    if (str.length < extremeValue.length) {\n      return true;\n    } else if (str.length == extremeValue.length && str <= extremeValue) {\n      return true;\n    } else {\n      return false;\n    }\n  }\n\n  /**\n   * @return {!Long}\n   * @public\n   */\n  static getZero() {\n    return ZERO_;\n  }\n\n  /**\n   * @return {!Long}\n   * @public\n   */\n  static getOne() {\n    return ONE_;\n  }\n\n  /**\n   * @return {!Long}\n   * @public\n   */\n  static getNegOne() {\n    return NEG_ONE_;\n  }\n\n  /**\n   * @return {!Long}\n   * @public\n   */\n  static getMaxValue() {\n    return MAX_VALUE_;\n  }\n\n  /**\n   * @return {!Long}\n   * @public\n   */\n  static getMinValue() {\n    return MIN_VALUE_;\n  }\n\n  /**\n   * @return {!Long}\n   * @public\n   */\n  static getTwoPwr24() {\n    return TWO_PWR_24_;\n  }\n}\n\nexports = Long;\n\n// NOTE: Common constant values ZERO, ONE, NEG_ONE, etc. are defined below the\n// from* methods on which they depend.\n\n\n/**\n * A cache of the Long representations of small integer values.\n * @type {!Object<number, !Long>}\n * @private @const\n */\nconst IntCache_ = {};\n\n\n/**\n * Returns a cached long number representing the given (32-bit) integer value.\n * @param {number} value The 32-bit integer in question.\n * @return {!Long} The corresponding Long value.\n * @private\n */\nfunction getCachedIntValue_(value) {\n  return reflect.cache(IntCache_, value, function(val) {\n    return new Long(val, val < 0 ? -1 : 0);\n  });\n}\n\n/**\n * The array of maximum values of a Long in string representation for a given\n * radix between 2 and 36, inclusive.\n * @private @const {!Array<string>}\n */\nconst MAX_VALUE_FOR_RADIX_ = [\n  '', '',  // unused\n  '111111111111111111111111111111111111111111111111111111111111111',\n  // base 2\n  '2021110011022210012102010021220101220221',  // base 3\n  '13333333333333333333333333333333',          // base 4\n  '1104332401304422434310311212',              // base 5\n  '1540241003031030222122211',                 // base 6\n  '22341010611245052052300',                   // base 7\n  '777777777777777777777',                     // base 8\n  '67404283172107811827',                      // base 9\n  '9223372036854775807',                       // base 10\n  '1728002635214590697',                       // base 11\n  '41a792678515120367',                        // base 12\n  '10b269549075433c37',                        // base 13\n  '4340724c6c71dc7a7',                         // base 14\n  '160e2ad3246366807',                         // base 15\n  '7fffffffffffffff',                          // base 16\n  '33d3d8307b214008',                          // base 17\n  '16agh595df825fa7',                          // base 18\n  'ba643dci0ffeehh',                           // base 19\n  '5cbfjia3fh26ja7',                           // base 20\n  '2heiciiie82dh97',                           // base 21\n  '1adaibb21dckfa7',                           // base 22\n  'i6k448cf4192c2',                            // base 23\n  'acd772jnc9l0l7',                            // base 24\n  '64ie1focnn5g77',                            // base 25\n  '3igoecjbmca687',                            // base 26\n  '27c48l5b37oaop',                            // base 27\n  '1bk39f3ah3dmq7',                            // base 28\n  'q1se8f0m04isb',                             // base 29\n  'hajppbc1fc207',                             // base 30\n  'bm03i95hia437',                             // base 31\n  '7vvvvvvvvvvvv',                             // base 32\n  '5hg4ck9jd4u37',                             // base 33\n  '3tdtk1v8j6tpp',                             // base 34\n  '2pijmikexrxp7',                             // base 35\n  '1y2p0ij32e8e7'                              // base 36\n];\n\n\n/**\n * The array of minimum values of a Long in string representation for a given\n * radix between 2 and 36, inclusive.\n * @private @const {!Array<string>}\n */\nconst MIN_VALUE_FOR_RADIX_ = [\n  '', '',  // unused\n  '-1000000000000000000000000000000000000000000000000000000000000000',\n  // base 2\n  '-2021110011022210012102010021220101220222',  // base 3\n  '-20000000000000000000000000000000',          // base 4\n  '-1104332401304422434310311213',              // base 5\n  '-1540241003031030222122212',                 // base 6\n  '-22341010611245052052301',                   // base 7\n  '-1000000000000000000000',                    // base 8\n  '-67404283172107811828',                      // base 9\n  '-9223372036854775808',                       // base 10\n  '-1728002635214590698',                       // base 11\n  '-41a792678515120368',                        // base 12\n  '-10b269549075433c38',                        // base 13\n  '-4340724c6c71dc7a8',                         // base 14\n  '-160e2ad3246366808',                         // base 15\n  '-8000000000000000',                          // base 16\n  '-33d3d8307b214009',                          // base 17\n  '-16agh595df825fa8',                          // base 18\n  '-ba643dci0ffeehi',                           // base 19\n  '-5cbfjia3fh26ja8',                           // base 20\n  '-2heiciiie82dh98',                           // base 21\n  '-1adaibb21dckfa8',                           // base 22\n  '-i6k448cf4192c3',                            // base 23\n  '-acd772jnc9l0l8',                            // base 24\n  '-64ie1focnn5g78',                            // base 25\n  '-3igoecjbmca688',                            // base 26\n  '-27c48l5b37oaoq',                            // base 27\n  '-1bk39f3ah3dmq8',                            // base 28\n  '-q1se8f0m04isc',                             // base 29\n  '-hajppbc1fc208',                             // base 30\n  '-bm03i95hia438',                             // base 31\n  '-8000000000000',                             // base 32\n  '-5hg4ck9jd4u38',                             // base 33\n  '-3tdtk1v8j6tpq',                             // base 34\n  '-2pijmikexrxp8',                             // base 35\n  '-1y2p0ij32e8e8'                              // base 36\n];\n\n/**\n * TODO(goktug): Replace with Number.MAX_SAFE_INTEGER when polyfil is guaranteed\n * to be removed.\n * @type {number}\n * @private @const\n */\nconst MAX_SAFE_INTEGER_ = 0x1fffffffffffff;\n\n// NOTE: the compiler should inline these constant values below and then remove\n// these variables, so there should be no runtime penalty for these.\n\n/**\n * Number used repeated below in calculations.  This must appear before the\n * first call to any from* function above.\n * @const {number}\n * @private\n */\nconst TWO_PWR_32_DBL_ = 0x100000000;\n\n\n/**\n * @const {number}\n * @private\n */\nconst TWO_PWR_63_DBL_ = 0x8000000000000000;\n\n\n/**\n * @private @const {!Long}\n */\nconst ZERO_ = Long.fromBits(0, 0);\n\n\n/**\n * @private @const {!Long}\n */\nconst ONE_ = Long.fromBits(1, 0);\n\n/**\n * @private @const {!Long}\n */\nconst NEG_ONE_ = Long.fromBits(-1, -1);\n\n/**\n * @private @const {!Long}\n */\nconst MAX_VALUE_ = Long.fromBits(0xFFFFFFFF, 0x7FFFFFFF);\n\n/**\n * @private @const {!Long}\n */\nconst MIN_VALUE_ = Long.fromBits(0, 0x80000000);\n\n/**\n * @private @const {!Long}\n */\nconst TWO_PWR_24_ = Long.fromBits(1 << 24, 0);\n"],
+"names":["getCachedIntValue_","value","reflect","cache","IntCache_","val","Long","goog","module","declareLegacyNamespace","asserts","require","constructor","low","high","low_","high_","toInt","toNumber","TWO_PWR_32_DBL_","getLowBitsUnsigned","isSafeInteger","top11Bits","toString","opt_radix","radix","Error","asNumber","safeDigits","radixPowSafeDigits","Math","pow","radixToPower","fromBits","remDiv","div","abs","subtract","multiply","digits","length","slice","toUnsignedString","longRadix","fromInt","quotient","shiftRightUnsigned","shiftLeft","remainder","greaterThanOrEqual","add","getOne","getHighBits","getLowBits","getNumBitsAbs","isNegative","equals","getMinValue","negate","bit","isZero","isOdd","hashCode","other","notEquals","lessThan","compare","lessThanOrEqual","greaterThan","negLow","overflowFromLow","negHigh","a48","a32","a16","a00","b48","b32","b16","b00","c48","c32","c16","c00","getNegOne","halfThis","shiftRight","approx","getZero","rem","result","res","max","floor","log2","ceil","log","LN2","delta","approxRes","fromNumber","approxRem","modulo","not","and","or","xor","numBits","intValue","assert","TWO_PWR_63_DBL_","getMaxValue","lowBits","highBits","fromString","str","charAt","substring","numberValue","parseInt","MAX_SAFE_INTEGER_","indexOf","i","size","min","power","isStringInRange","extremeValue","MIN_VALUE_FOR_RADIX_","MAX_VALUE_FOR_RADIX_","ZERO_","ONE_","NEG_ONE_","MAX_VALUE_","MIN_VALUE_","getTwoPwr24","TWO_PWR_24_","exports"]
+}