anchor.diff:    static _Bigint _ZERO = new _Bigint._fromInt(0);
     static _Bigint _ONE = new _Bigint._fromInt(1);
   
  +  // Result cache for last _divRem call.
  +  static Uint32List _lastDividend_digits;
  +  static int _lastDividend_used;
  +  static Uint32List _lastDivisor_digits;
  +  static int _lastDivisor_used;
  +  static Uint32List _lastQuoRem_digits;
  +  static int _lastQuoRem_used;
  +  static int _lastRem_used;
  +  static int _lastRem_nsh;
  +
     // Internal data structure.
     bool get _neg native "Bigint_getNeg";
     int get _used native "Bigint_getUsed";
  
positive.code:     if (x_used == 0) {
        return 0;
      }
      if (n == 0 && r_digits == x_digits) {
        return x_used;
      }
      final r_used = x_used + n;
  
negative.code: 
    // Return trunc(this / a), a != 0.
    _Bigint _div(_Bigint a) {
      assert(a._used > 0);
      if (_used < a._used) {
        return _ZERO;
      }
      _divRem(a);
      // Return quotient, i.e.
      // _lastQuoRem_digits[_lastRem_used.._lastQuoRem_used-1] with proper sign.
      var lastQuo_used = _lastQuoRem_used - _lastRem_used;
      var quo_digits = _cloneDigits(_lastQuoRem_digits,
                                    _lastRem_used,
                                    _lastQuoRem_used,
                                    lastQuo_used);
      var quo = new _Bigint(false, lastQuo_used, quo_digits);
      if ((_neg != a._neg) && (quo._used > 0)) {
        quo = quo._negate();
      }
      return quo;
    }
  
    // Return this - a * trunc(this / a), a != 0.
    _Bigint _rem(_Bigint a) {
      assert(a._used > 0);
      if (_used < a._used) {
        return this;
      }
      _divRem(a);
      // Return remainder, i.e.
      // denormalized _lastQuoRem_digits[0.._lastRem_used-1] with proper sign.
      var rem_digits = _cloneDigits(_lastQuoRem_digits,
                                    0,
                                    _lastRem_used,
                                    _lastRem_used);
      var rem = new _Bigint(false, _lastRem_used, rem_digits);
      if (_lastRem_nsh > 0) {
        rem = rem._rShift(_lastRem_nsh);  // Denormalize remainder.
      }
      if (_neg && (rem._used > 0)) {
        rem = rem._negate();
      }
      return rem;
    }
  
    // Cache concatenated positive quotient and normalized positive remainder.
    void _divRem(_Bigint a) {
      // Check if result is already cached (identical on Bigint is too expensive).
      if ((this._used == _lastDividend_used) &&
          (a._used == _lastDivisor_used) &&
          identical(this._digits, _lastDividend_digits) &&
          identical(a._digits, _lastDivisor_digits)) {
        return;
      }
      var nsh = _DIGIT_BITS - _nbits(a._digits[a._used - 1]);
      // For 64-bit processing, make sure y has an even number of digits.
  