anchor.diff:      var resultUsed = _max(used, otherUsed);
       var digits = _digits;
       var otherDigits = other._digits;
  -    var resultDigits = new Uint32List(resultUsed);
  +    var resultDigits = _newDigits(resultUsed);
       var l, m;
       if (used < otherUsed) {
         l = other;
  
positive.code: 
  // Interface for modular reduction.
  abstract class _BigIntReduction {
    // Return the number of digits used by r_digits.
    int convert(_BigIntImpl x, Uint32List r_digits);
    int mul(Uint32List xDigits, int xUsed, Uint32List yDigits, int yUsed,
        Uint32List resultDigits);
    int sqr(Uint32List xDigits, int xUsed, Uint32List resultDigits);
  
    // Return x reverted to _BigIntImpl.
    _BigIntImpl revert(Uint32List xDigits, int xUsed);
  }
  
  // Modular reduction using "classic" algorithm.
  class _BigIntClassic implements _BigIntReduction {
    final _BigIntImpl _modulus; // Modulus.
    final _BigIntImpl _normalizedModulus; // Normalized _modulus.
  
    _BigIntClassic(this._modulus)
        : _normalizedModulus = _modulus <<
              (_BigIntImpl._digitBits -
                  _modulus._digits[_modulus._used - 1].bitLength);
  
    int convert(_BigIntImpl x, Uint32List resultDigits) {
      var digits;
      var used;
      if (x._isNegative || x.compareTo(_modulus) >= 0) {
  
negative.code:     resultDigits[used] = carry;
    }
  
    /// resultDigits[0..used-1] = digits[0..used-1] - otherDigits[0..otherUsed-1].
    /// used >= otherUsed > 0.
    ///
    /// Note: This function may be intrinsified.
    static void _absSub(Uint32List digits, int used, Uint32List otherDigits,
        int otherUsed, Uint32List resultDigits) {
      assert(used >= otherUsed && otherUsed > 0);
      var carry = 0;
      for (var i = 0; i < otherUsed; i++) {
        carry += digits[i] - otherDigits[i];
  