More efficient Int64 parsing and printing.

pkg/fixnum/lib/src/int64.dart

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 part of fixnum;
 
 /**
  * An immutable 64-bit signed integer, in the range [-2^63, 2^63 - 1].
  * Arithmetic operations may overflow in order to maintain this range.
  */
 class Int64 implements IntX {
 
   // A 64-bit integer is represented internally as three non-negative
   // integers, storing the 22 low, 22 middle, and 20 high bits of the
   // 64-bit value.  _l (low) and _m (middle) are in the range
   // [0, 2^22 - 1] and _h (high) is in the range [0, 2^20 - 1].
   int _l, _m, _h;
 
   // Note: instances of [Int64] are immutable outside of this library,
   // therefore we may return a reference to an existing instance.
   // We take care to perform mutation only on internally-generated
   // instances before they are exposed to external code.
 
   // Note: several functions require _BITS == 22 -- do not change this value.
   static const int _BITS = 22;
   static const int _BITS01 = 44; // 2 * _BITS
   static const int _BITS2 = 20; // 64 - _BITS01
   static const int _MASK = 4194303; // (1 << _BITS) - 1
-  static const int _MASK_2 = 1048575; // (1 << _BITS2) - 1
+  static const int _MASK2 = 1048575; // (1 << _BITS2) - 1
   static const int _SIGN_BIT = 19; // _BITS2 - 1
-  static const int _SIGN_BIT_VALUE = 524288; // 1 << _SIGN_BIT
+  static const int _SIGN_BIT_MASK = 524288; // 1 << _SIGN_BIT
 
   // Cached constants
   static Int64 _MAX_VALUE;
   static Int64 _MIN_VALUE;
   static Int64 _ZERO;
   static Int64 _ONE;
   static Int64 _TWO;
 
-  // Precompute the radix strings for MIN_VALUE to avoid the problem
-  // of overflow of -MIN_VALUE.
-  static List<String> _minValues = const <String>[
-      null, null,
-      "-1000000000000000000000000000000000000000000000000000000000000000", // 2
-      "-2021110011022210012102010021220101220222", // base 3
-      "-20000000000000000000000000000000", // base 4
-      "-1104332401304422434310311213", // base 5
-      "-1540241003031030222122212", // base 6
-      "-22341010611245052052301", // base 7
-      "-1000000000000000000000", // base 8
-      "-67404283172107811828", // base 9
-      "-9223372036854775808", // base 10
-      "-1728002635214590698", // base 11
-      "-41A792678515120368", // base 12
-      "-10B269549075433C38", // base 13
-      "-4340724C6C71DC7A8", // base 14
-      "-160E2AD3246366808", // base 15
-      "-8000000000000000" // base 16
-  ];
-
   // The remainder of the last divide operation.
   static Int64 _remainder;
 
   /**
    * The maximum positive value attainable by an [Int64], namely
    * 9,223,372,036,854,775,807.
    */
   static Int64 get MAX_VALUE {
     if (_MAX_VALUE == null) {
-      _MAX_VALUE = new Int64._bits(_MASK, _MASK, _MASK_2 >> 1);
+      _MAX_VALUE = new Int64._bits(_MASK, _MASK, _MASK2 >> 1);
     }
     return _MAX_VALUE;
   }
 
   /**
    * The minimum positive value attainable by an [Int64], namely
    * -9,223,372,036,854,775,808.
    */
   static Int64 get MIN_VALUE {
     if (_MIN_VALUE == null) {
-      _MIN_VALUE = new Int64._bits(0, 0, _SIGN_BIT_VALUE);
+      _MIN_VALUE = new Int64._bits(0, 0, _SIGN_BIT_MASK);
     }
     return _MIN_VALUE;
   }
 
   /**
    * An [Int64] constant equal to 0.
    */
   static Int64 get ZERO {
     if (_ZERO == null) {
       _ZERO = new Int64();
@@ skipping 15 matching lines @@
    * An [Int64] constant equal to 2.
    */
   static Int64 get TWO {
     if (_TWO == null) {
       _TWO = new Int64._bits(2, 0, 0);
     }
     return _TWO;
   }
 
   /**
-   * Parses a [String] in a given [radix] between 2 and 16 and returns an
+   * Parses a [String] in a given [radix] between 2 and 36 and returns an
    * [Int64].
    */
-  // TODO(rice) - make this faster by converting several digits at once.
   static Int64 parseRadix(String s, int radix) {
-    if ((radix <= 1) || (radix > 16)) {
+    if ((radix <= 1) || (radix > 36)) {
       throw new ArgumentError("Bad radix: $radix");
     }
-    Int64 x = ZERO;
+    return _parseRadix(s, radix);
+  }
+
+  static Int64 _parseRadix(String s, int radix) {
     int i = 0;
     bool negative = false;
     if (s[0] == '-') {
       negative = true;
       i++;
     }
+    int d0 = 0, d1 = 0, d2 = 0;  //  low, middle, high components.
     for (; i < s.length; i++) {
       int c = s.codeUnitAt(i);
-      int digit = Int32._decodeHex(c);
+      int digit = Int32._decodeDigit(c);
       if (digit < 0 || digit >= radix) {
         throw new Exception("Non-radix char code: $c");
       }
-      x = (x * radix) + digit;
+
+      // [radix] and [digit] are at most 6 bits, component is 22, so we can
+      // multiply and add within 30 bit temporary values.
+      d0 = d0 * radix + digit;
+      int carry = d0 >> _BITS;
+      d0 &= _MASK;
+
+      d1 = d1 * radix + carry;
+      carry = d1 >> _BITS;
+      d1 &= _MASK;
+
+      d2 = d2 * radix + carry;
+      d2 &= _MASK2;
     }
-    return negative ? -x : x;
+
+    if (negative) {
+      d0 = 0 - d0;
+      int borrow = (d0 >> _BITS) & 1;
+      d0 &= _MASK;
+      d1 = 0 - d1 - borrow;
+      borrow = (d1 >> _BITS) & 1;
+      d1 &= _MASK;
+      d2 = 0 - d2 - borrow;
+      d2 &= _MASK2;
+    }
+    return new Int64._bits(d0, d1, d2);
   }
 
   /**
    * Parses a decimal [String] and returns an [Int64].
    */
-  static Int64 parseInt(String s) => parseRadix(s, 10);
+  static Int64 parseInt(String s) => _parseRadix(s, 10);
 
   /**
    * Parses a hexadecimal [String] and returns an [Int64].
    */
-  static Int64 parseHex(String s) => parseRadix(s, 16);
+  static Int64 parseHex(String s) => _parseRadix(s, 16);
 
   //
   // Public constructors
   //
 
   /**
    * Constructs an [Int64] equal to 0.
    */
   Int64() : _l = 0, _m = 0, _h = 0;
 
   /**
    * Constructs an [Int64] with a given [int] value.
    */
   Int64.fromInt(int value) {
     bool negative = false;
     if (value < 0) {
       negative = true;
       value = -value - 1;
     }
     if (_haveBigInts) {
       _l = value & _MASK;
       _m = (value >> _BITS) & _MASK;
-      _h = (value >> _BITS01) & _MASK_2;
+      _h = (value >> _BITS01) & _MASK2;
     } else {
       // Avoid using bitwise operations that coerce their input to 32 bits.
       _h = value ~/ 17592186044416; // 2^44
       value -= _h * 17592186044416;
       _m = value ~/ 4194304; // 2^22
       value -= _m * 4194304;
       _l = value;
     }
 
     if (negative) {
       _l = ~_l & _MASK;
       _m = ~_m & _MASK;
-      _h = ~_h & _MASK_2;
+      _h = ~_h & _MASK2;
     }
   }
 
   factory Int64.fromBytes(List<int> bytes) {
     int top = bytes[7] & 0xff;
     top <<= 8;
     top |= bytes[6] & 0xff;
     top <<= 8;
     top |= bytes[5] & 0xff;
     top <<= 8;
@@ skipping 27 matching lines @@
     bottom <<= 8;
     bottom |= bytes[7] & 0xff;
 
     return new Int64.fromInts(top, bottom);
  }
 
   /**
    * Constructs an [Int64] from a pair of 32-bit integers having the value
    * [:((top & 0xffffffff) << 32) | (bottom & 0xffffffff):].
    */
-  Int64.fromInts(int top, int bottom) {
+  factory Int64.fromInts(int top, int bottom) {
     top &= 0xffffffff;
     bottom &= 0xffffffff;
-    _l = bottom & _MASK;
-    _m = ((top & 0xfff) << 10) | ((bottom >> _BITS) & 0x3ff);
-    _h = (top >> 12) & _MASK_2;
+    int d0 = bottom & _MASK;
+    int d1 = ((top & 0xfff) << 10) | ((bottom >> _BITS) & 0x3ff);
+    int d2 = (top >> 12) & _MASK2;
+    return new Int64._bits(d0, d1, d2);
   }
 
   // Returns the [Int64] representation of the specified value. Throws
   // [ArgumentError] for non-integer arguments.
   Int64 _promote(val) {
     if (val is Int64) {
       return val;
     } else if (val is int) {
       return new Int64.fromInt(val);
     } else if (val is Int32) {
       return val.toInt64();
     }
     throw new ArgumentError(val);
   }
 
   Int64 operator +(other) {
     Int64 o = _promote(other);
     int sum0 = _l + o._l;
     int sum1 = _m + o._m + _shiftRight(sum0, _BITS);
     int sum2 = _h + o._h + _shiftRight(sum1, _BITS);
 
-    Int64 result = new Int64._bits(sum0 & _MASK, sum1 & _MASK, sum2 & _MASK_2);
+    Int64 result = new Int64._bits(sum0 & _MASK, sum1 & _MASK, sum2 & _MASK2);
     return result;
   }
 
   Int64 operator -(other) {
     Int64 o = _promote(other);
     int sum0 = _l - o._l;
     int sum1 = _m - o._m + _shiftRight(sum0, _BITS);
     int sum2 = _h - o._h + _shiftRight(sum1, _BITS);
 
-    Int64 result = new Int64._bits(sum0 & _MASK, sum1 & _MASK, sum2 & _MASK_2);
+    Int64 result = new Int64._bits(sum0 & _MASK, sum1 & _MASK, sum2 & _MASK2);
     return result;
   }
 
   Int64 operator -() {
     // Like 0 - this.
     int sum0 = -_l;
     int sum1 = -_m + _shiftRight(sum0, _BITS);
     int sum2 = -_h + _shiftRight(sum1, _BITS);
 
-    return new Int64._bits(sum0 & _MASK, sum1 & _MASK, sum2 & _MASK_2);
+    return new Int64._bits(sum0 & _MASK, sum1 & _MASK, sum2 & _MASK2);
   }
 
   Int64 operator *(other) {
     Int64 o = _promote(other);
 
     // Grab 13-bit chunks.
     int a0 = _l & 0x1fff;
     int a1 = (_l >> 13) | ((_m & 0xf) << 9);
     int a2 = (_m >> 4) & 0x1fff;
     int a3 = (_m >> 17) | ((_h & 0xff) << 5);
@@ skipping 61 matching lines @@
     int c22 = p2 >> 18;
     int c23 = p3 >> 5;
     int c24 = (p4 & 0xfff) << 8;
     int c2 = c22 + c23 + c24;
 
     // Propagate high bits from c0 -> c1, c1 -> c2.
     c1 += c0 >> _BITS;
     c0 &= _MASK;
     c2 += c1 >> _BITS;
     c1 &= _MASK;
-    c2 &= _MASK_2;
+    c2 &= _MASK2;
 
     return new Int64._bits(c0, c1, c2);
   }
 
   Int64 operator %(other) {
     if (other.isZero) {
       throw new IntegerDivisionByZeroException();
     }
     if (this.isZero) {
       return ZERO;
@@ skipping 33 matching lines @@
 
   Int64 operator ^(other) {
     Int64 o = _promote(other);
     int a0 = _l ^ o._l;
     int a1 = _m ^ o._m;
     int a2 = _h ^ o._h;
     return new Int64._bits(a0, a1, a2);
   }
 
   Int64 operator ~() {
-    var result = new Int64._bits((~_l) & _MASK, (~_m) & _MASK, (~_h) & _MASK_2);
+    var result = new Int64._bits((~_l) & _MASK, (~_m) & _MASK, (~_h) & _MASK2);
     return result;
   }
 
   Int64 operator <<(int n) {
     if (n < 0) {
       throw new ArgumentError(n);
     }
     n &= 63;
 
     int res0, res1, res2;
     if (n < _BITS) {
       res0 = _l << n;
       res1 = (_m << n) | (_l >> (_BITS - n));
       res2 = (_h << n) | (_m >> (_BITS - n));
     } else if (n < _BITS01) {
       res0 = 0;
       res1 = _l << (n - _BITS);
       res2 = (_m << (n - _BITS)) | (_l >> (_BITS01 - n));
     } else {
       res0 = 0;
       res1 = 0;
       res2 = _l << (n - _BITS01);
     }
 
-    return new Int64._bits(res0 & _MASK, res1 & _MASK, res2 & _MASK_2);
+    return new Int64._bits(res0 & _MASK, res1 & _MASK, res2 & _MASK2);
   }
 
   Int64 operator >>(int n) {
     if (n < 0) {
       throw new ArgumentError(n);
     }
     n &= 63;
 
     int res0, res1, res2;
 
     // Sign extend h(a).
     int a2 = _h;
-    bool negative = (a2 & _SIGN_BIT_VALUE) != 0;
+    bool negative = (a2 & _SIGN_BIT_MASK) != 0;
     if (negative) {
       a2 += 0x3 << _BITS2; // add extra one bits on the left
     }
 
     if (n < _BITS) {
       res2 = _shiftRight(a2, n);
       if (negative) {
-        res2 |= _MASK_2 & ~(_MASK_2 >> n);
+        res2 |= _MASK2 & ~(_MASK2 >> n);
       }
       res1 = _shiftRight(_m, n) | (a2 << (_BITS - n));
       res0 = _shiftRight(_l, n) | (_m << (_BITS - n));
     } else if (n < _BITS01) {
-      res2 = negative ? _MASK_2 : 0;
+      res2 = negative ? _MASK2 : 0;
       res1 = _shiftRight(a2, n - _BITS);
       if (negative) {
         res1 |= _MASK & ~(_MASK >> (n - _BITS));
       }
       res0 = _shiftRight(_m, n - _BITS) | (a2 << (_BITS01 - n));
     } else {
-      res2 = negative ? _MASK_2 : 0;
+      res2 = negative ? _MASK2 : 0;
       res1 = negative ? _MASK : 0;
       res0 = _shiftRight(a2, n - _BITS01);
       if (negative) {
         res0 |= _MASK & ~(_MASK >> (n - _BITS01));
       }
     }
 
-    return new Int64._bits(res0 & _MASK, res1 & _MASK, res2 & _MASK_2);
+    return new Int64._bits(res0 & _MASK, res1 & _MASK, res2 & _MASK2);
   }
 
   Int64 shiftRightUnsigned(int n) {
     if (n < 0) {
       throw new ArgumentError(n);
     }
     n &= 63;
 
     int res0, res1, res2;
-    int a2 = _h & _MASK_2; // Ensure a2 is positive.
+    int a2 = _h & _MASK2; // Ensure a2 is positive.
     if (n < _BITS) {
       res2 = a2 >> n;
       res1 = (_m >> n) | (a2 << (_BITS - n));
       res0 = (_l >> n) | (_m << (_BITS - n));
     } else if (n < _BITS01) {
       res2 = 0;
       res1 = a2 >> (n - _BITS);
       res0 = (_m >> (n - _BITS)) | (_h << (_BITS01 - n));
     } else {
       res2 = 0;
       res1 = 0;
       res0 = a2 >> (n - _BITS01);
     }
 
-    return new Int64._bits(res0 & _MASK, res1 & _MASK, res2 & _MASK_2);
+    return new Int64._bits(res0 & _MASK, res1 & _MASK, res2 & _MASK2);
   }
 
   /**
    * Returns [true] if this [Int64] has the same numeric value as the
    * given object.  The argument may be an [int] or an [IntX].
    */
   bool operator ==(other) {
     Int64 o;
     if (other is Int64) {
       o = other;
@@ skipping 43 matching lines @@
 
   bool operator >(other) {
     return this.compareTo(other) > 0;
   }
 
   bool operator >=(other) {
     return this.compareTo(other) >= 0;
   }
 
   bool get isEven => (_l & 0x1) == 0;
-  bool get isMaxValue => (_h == _MASK_2 >> 1) && _m == _MASK && _l == _MASK;
-  bool get isMinValue => _h == _SIGN_BIT_VALUE && _m == 0 && _l == 0;
+  bool get isMaxValue => (_h == _MASK2 >> 1) && _m == _MASK && _l == _MASK;
+  bool get isMinValue => _h == _SIGN_BIT_MASK && _m == 0 && _l == 0;
   bool get isNegative => (_h >> (_BITS2 - 1)) != 0;
   bool get isOdd => (_l & 0x1) == 1;
   bool get isZero => _h == 0 && _m == 0 && _l == 0;
 
   /**
    * Returns a hash code based on all the bits of this [Int64].
    */
   int get hashCode {
     int bottom = ((_m & 0x3ff) << _BITS) | _l;
     int top = (_h << 12) | ((_m >> 10) & 0xfff);
@@ skipping 56 matching lines @@
     result[6] = (_h >> 4) & 0xff;
     result[7] = (_h >> 12) & 0xff;
     return result;
   }
 
   int toInt() {
     int l = _l;
     int m = _m;
     int h = _h;
     bool negative = false;
-    if ((_h & _SIGN_BIT_VALUE) != 0) {
+    if ((_h & _SIGN_BIT_MASK) != 0) {
       l = ~_l & _MASK;
       m = ~_m & _MASK;
-      h = ~_h & _MASK_2;
+      h = ~_h & _MASK2;
       negative = true;
     }
 
     int result;
     if (_haveBigInts) {
       result = (h << _BITS01) | (m << _BITS) | l;
     } else {
       result = (h * 17592186044416) + (m * 4194304) + l;
     }
     return negative ? -result - 1 : result;
   }
 
   /**
    * Returns an [Int32] containing the low 32 bits of this [Int64].
    */
   Int32 toInt32() {
     return new Int32.fromInt(((_m & 0x3ff) << _BITS) | _l);
   }
 
   /**
    * Returns [this].
    */
   Int64 toInt64() => this;
 
   /**
    * Returns the value of this [Int64] as a decimal [String].
    */
-  // TODO(rice) - Make this faster by converting several digits at once.
-  String toString() {
-    Int64 a = this;
-    if (a.isZero) {
-      return "0";
-    }
-    if (a.isMinValue) {
-      return "-9223372036854775808";
-    }
-
-    String result = "";
-    bool negative = false;
-    if (a.isNegative) {
-      negative = true;
-      a = -a;
-    }
-
-    Int64 ten = new Int64._bits(10, 0, 0);
-    while (!a.isZero) {
-      a = _divMod(a, ten, true);
-      result = "${_remainder._l}$result";
-    }
-    if (negative) {
-      result = "-$result";
-    }
-    return result;
-  }
+  String toString() => _toRadixString(10);
 
   // TODO(rice) - Make this faster by avoiding arithmetic.
   String toHexString() {
     Int64 x = new Int64._copy(this);
     if (isZero) {
       return "0";
     }
     String hexStr = "";
     Int64 digit_f = new Int64.fromInt(0xf);
     while (!x.isZero) {
       int digit = x._l & 0xf;
       hexStr = "${_hexDigit(digit)}$hexStr";
       x = x.shiftRightUnsigned(4);
     }
     return hexStr;
   }
 
   String toRadixString(int radix) {
-    if ((radix <= 1) || (radix > 16)) {
+    if ((radix <= 1) || (radix > 36)) {
       throw new ArgumentError("Bad radix: $radix");
     }
-    Int64 a = this;
-    if (a.isZero) {
-      return "0";
-    }
-    if (a.isMinValue) {
-      return _minValues[radix];
+    return _toRadixString(radix);
+  }
+
+  String _toRadixString(int radix) {
+    int d0 = _l;
+    int d1 = _m;
+    int d2 = _h;
+
+    if (d0 == 0 && d1 == 0 && d2 == 0) return '0';
+
+    String sign = '';
+    if ((d2 & _SIGN_BIT_MASK) != 0) {
+      sign = '-';
+
+      // Negate in-place.
+      d0 = 0 - d0;
+      int borrow = (d0 >> _BITS) & 1;
+      d0 &= _MASK;
+      d1 = 0 - d1 - borrow;
+      borrow = (d1 >> _BITS) & 1;
+      d1 &= _MASK;
+      d2 = 0 - d2 - borrow;
+      d2 &= _MASK2;
+      // d2, d1, d0 now are an unsigned 64 bit integer for MIN_VALUE and an
+      // unsigned 63 bit integer for other values.
     }
 
-    String result = "";
-    bool negative = false;
-    if (a.isNegative) {
-      negative = true;
-      a = -a;
+    // Rearrange components into five components where all but the most
+    // significant are 10 bits wide.
+    //
+    //     d4, d3, d4, d1, d0:  24 + 10 + 10 + 10 + 10 bits
+    //
+    // The choice of 10 bits allows a remainder of 20 bits to be scaled by 10
+    // bits and added during division while keeping all intermediate values
+    // within 30 bits (unsigned small integer range for 32 bit implementations
+    // of Dart VM and V8).
+    //
+    //     6  6         5         4         3         2         1
+    //     3210987654321098765432109876543210987654321098765432109876543210
+    //     [--------d2--------][---------d1---------][---------d0---------]
+    //  -->
+    //     [----------d4----------][---d3---][---d2---][---d1---][---d0---]
+
+
+    int d4 = (d2 << 4) | (d1 >> 18);
+    int d3 = (d1 >> 8) & 0x3ff;
+    d2 = ((d1 << 2) | (d0 >> 20)) & 0x3ff;
+    d1 = (d0 >> 10) & 0x3ff;
+    d0 = d0 & 0x3ff;
+
+    int fatRadix = _fatRadixTable[radix];
+
+    // Generate chunks of digits.  In radix 10, generate 6 digits per chunk.
+    //
+    // This loop generates at most 3 chunks, so we store the chunks in locals
+    // rather than a list.  We are trying to generate digits 20 bits at a time
+    // until we have only 30 bits left.  20 + 20 + 30 > 64 would imply that we
+    // need only two chunks, but radix values 17-19 and 33-36 generate only 15
+    // or 16 bits per iteration, so sometimes the third chunk is needed.
+
+    String chunk1 = "", chunk2 = "", chunk3 = "";
+
+    while (!(d4 == 0 && d3 == 0)) {
+      int q = d4 ~/ fatRadix;
+      int r = d4 - q * fatRadix;
+      d4 = q;
+      d3 += r << 10;
+
+      q = d3 ~/ fatRadix;
+      r = d3 - q * fatRadix;
+      d3 = q;
+      d2 += r << 10;
+
+      q = d2 ~/ fatRadix;
+      r = d2 - q * fatRadix;
+      d2 = q;
+      d1 += r << 10;
+
+      q = d1 ~/ fatRadix;
+      r = d1 - q * fatRadix;
+      d1 = q;
+      d0 += r << 10;
+
+      q = d0 ~/ fatRadix;
+      r = d0 - q * fatRadix;
+      d0 = q;
+
+      assert(chunk2 == "");
+      chunk3 = chunk2;
+      chunk2 = chunk1;
+      // Adding [fatRadix] Forces an extra digit which we discard to get a fixed
+      // width.  E.g.  (1000000 + 123) -> "1000123" -> "000123".  An alternative
+      // would be to pad to the left with zeroes.
+      chunk1 = (fatRadix + r).toRadixString(radix).substring(1);
     }
+    int residue = (d2 << 20) + (d1 << 10) + d0;
+    String leadingDigits = residue == 0 ? '' : residue.toRadixString(radix);
+    return '$sign$leadingDigits$chunk1$chunk2$chunk3';
+  }
 
-    Int64 r = new Int64._bits(radix, 0, 0);
-    while (!a.isZero) {
-      a = _divMod(a, r, true);
-      result = "${_hexDigit(_remainder._l)}$result";
-    }
-    return negative ? "-$result" : result;
-  }
+  // Table of 'fat' radix values.  Each entry for index `i` is the largest power
+  // of `i` whose remainder fits in 20 bits.
+  static const _fatRadixTable = const <int>[
+      0,
+      0,
+      2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2 * 2
+        * 2,
+      3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3 * 3,
+      4 * 4 * 4 * 4 * 4 * 4 * 4 * 4 * 4 * 4,
+      5 * 5 * 5 * 5 * 5 * 5 * 5 * 5,
+      6 * 6 * 6 * 6 * 6 * 6 * 6,
+      7 * 7 * 7 * 7 * 7 * 7 * 7,
+      8 * 8 * 8 * 8 * 8 * 8,
+      9 * 9 * 9 * 9 * 9 * 9,
+      10 * 10 * 10 * 10 * 10 * 10,
+      11 * 11 * 11 * 11 * 11,
+      12 * 12 * 12 * 12 * 12,
+      13 * 13 * 13 * 13 * 13,
+      14 * 14 * 14 * 14 * 14,
+      15 * 15 * 15 * 15 * 15,
+      16 * 16 * 16 * 16 * 16,
+      17 * 17 * 17 * 17,
+      18 * 18 * 18 * 18,
+      19 * 19 * 19 * 19,
+      20 * 20 * 20 * 20,
+      21 * 21 * 21 * 21,
+      22 * 22 * 22 * 22,
+      23 * 23 * 23 * 23,
+      24 * 24 * 24 * 24,
+      25 * 25 * 25 * 25,
+      26 * 26 * 26 * 26,
+      27 * 27 * 27 * 27,
+      28 * 28 * 28 * 28,
+      29 * 29 * 29 * 29,
+      30 * 30 * 30 * 30,
+      31 * 31 * 31 * 31,
+      32 * 32 * 32 * 32,
+      33 * 33 * 33,
+      34 * 34 * 34,
+      35 * 35 * 35,
+      36 * 36 * 36
+  ];
 
   String toDebugString() {
     return "Int64[_l=$_l, _m=$_m, _h=$_h]";
   }
 
   /**
    * Constructs an [Int64] with a given bitwise representation.  No validation
    * is performed.
    */
   Int64._bits(int this._l, int this._m, int this._h);
 
   /**
    * Constructs an [Int64] with the same value as an existing [Int64].
    */
-  Int64._copy(Int64 other) {
-    _l = other._l;
-    _m = other._m;
-    _h = other._h;
-  }
+  Int64._copy(Int64 other)
+      : _l = other._l,
+        _m = other._m,
+        _h = other._h;
 
   // Determine whether the platform supports ints greater than 2^53
   // without loss of precision.
   static bool _haveBigIntsCached = null;
 
   static bool get _haveBigInts {
     if (_haveBigIntsCached == null) {
       var x = 9007199254740992;
       // Defeat compile-time constant folding.
       if (2 + 2 != 4) {
         x = 0;
       }
       var y = x + 1;
       var same = y == x;
       _haveBigIntsCached = !same;
     }
     return _haveBigIntsCached;
   }
 
   String _hexDigit(int digit) => "0123456789ABCDEF"[digit];
 
   // Implementation of '~/' and '%'.
 
   // Note: mutates [this].
   void _negate() {
     int neg0 = (~_l + 1) & _MASK;
     int neg1 = (~_m + (neg0 == 0 ? 1 : 0)) & _MASK;
-    int neg2 = (~_h + ((neg0 == 0 && neg1 == 0) ? 1 : 0)) & _MASK_2;
+    int neg2 = (~_h + ((neg0 == 0 && neg1 == 0) ? 1 : 0)) & _MASK2;
 
     _l = neg0;
     _m = neg1;
     _h = neg2;
   }
 
   // Note: mutates [this].
   void _setBit(int bit) {
     if (bit < _BITS) {
       _l |= 0x1 << bit;
@@ skipping 49 matching lines @@
     int sum0 = a._l - b._l;
     int sum1 = a._m - b._m + _shiftRight(sum0, _BITS);
     sum2 += _shiftRight(sum1, _BITS);
 
     if (sum2 < 0) {
       return false;
     }
 
     a._l = sum0 & _MASK;
     a._m = sum1 & _MASK;
-    a._h = sum2 & _MASK_2;
+    a._h = sum2 & _MASK2;
 
     return true;
   }
 
   // Note: mutates [a] via _trialSubtract.
   static Int64 _divModHelper(Int64 a, Int64 b,
       bool negative, bool aIsNegative, bool aIsMinValue,
       bool computeRemainder) {
     // Align the leading one bits of a and b by shifting b left.
     int shift = b.numberOfLeadingZeros() - a.numberOfLeadingZeros();
@@ skipping 215 matching lines @@
         }
       }
       return ZERO;
     }
 
     // Generate the quotient using bit-at-a-time long division.
     return _divModHelper(aIsCopy ? a : new Int64._copy(a), b, negative,
         aIsNegative, aIsMinValue, computeRemainder);
   }
 }