anchor.diff:  
     // Return trunc(this / a), a != 0.
     _Bigint _div(_Bigint a) {
  -    return _divRem(a, true);
  +    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) {
  -    return _divRem(a, false);
  -  }
  -
  -  // Return trunc(this / a), a != 0, if div == true.
  -  // Return this - a * trunc(this / a), a != 0, if div == false.
  -  _Bigint _divRem(_Bigint a, bool div) {
       assert(a._used > 0);
       if (_used < a._used) {
  -      return div ? _ZERO : this;
  +      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.
  
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:       }
        i -= d0;
      }
      // Cache result.
      _lastDividend_digits = _digits;
      _lastDividend_used = _used;
      _lastDivisor_digits = a._digits;
      _lastDivisor_used = a._used;
      _lastQuoRem_digits = r_digits;
      _lastQuoRem_used = r_used;
      _lastRem_used = y_used;
      _lastRem_nsh = nsh;
    }
  
    // Customized version of _rem() minimizing allocations for use in reduction.
  