anchor.diff:      return c;
     }
   
  +  // Accumulate multiply with carry.
  +  // this[i..i+n-1]: bigint multiplicand.
  +  // x: digit multiplier, 0 <= x < 2*DIGIT_BASE  (i.e. 33-bit multiplier).
  +  // w[j..j+n-1]: bigint accumulator.
  +  // c: int carry in.
  +  // Returns carry out.
  +  // w[j..j+n-1] += this[i..i+n-1] * x + c.
  +  // Returns carry out.
  +  int _amc(int i, int x, _Bigint w, int j, int c, int n) {
  +    if (x == 0 && c == 0) {
  +      // No-op if both x and c are 0.
  +      return 0;
  +    }
  +    int xl = x & DIGIT2_MASK;
  +    int xh = x >> DIGIT2_BITS;
  +    while (--n >= 0) {
  +      int l = _digits[i] & DIGIT2_MASK;
  +      int h = _digits[i++] >> DIGIT2_BITS;
  +      int m = xh*l + h*xl;
  +      l = xl*l + ((m & DIGIT2_MASK) << DIGIT2_BITS) + w._digits[j] + c;
  +      c = (l >> DIGIT_BITS) + (m >> DIGIT2_BITS) + xh*h;
  +      w._digits[j++] = l & DIGIT_MASK;
  +    }
  +    return c;
  +  }
  +
     // r = this * a.
     void _mulTo(_Bigint a, _Bigint r) {
       // TODO(regis): Use karatsuba multiplication when appropriate.
  
positive.code:     return other._toBigint()._compareTo(this) == 0;
    }
  
    // New method to support crypto.
  
    // Return this.pow(e) mod m, with 256 <= e < 1<<32.
    int modPow(int e, int m) {
      assert(e >= 256 && !m.isEven());
      if (e >= (1 << 32)) {
        throw "Bigint.modPow with exponent larger than 32-bit not implemented";
      }
      _Reduction z = new _Montgomery(m);
      var r = new _Bigint();
      var r2 = new _Bigint();
      var g = z.convert(this);
      int i = _nbits(e) - 1;
      g._copyTo(r);
      while (--i >= 0) {
        z.sqrTo(r, r2);
        if ((e & (1 << i)) > 0) {
          z.mulTo(r2, g, r);
        } else {
          var t = r;
          r = r2;
          r2 = t;
        }
      }
      return z.revert(r)._toValidInt();
    }
  }
  
  
negative.code:       // Use _am to combine the multiply-shift-add into one call.
        j = i + _m._used;
        var digit = x._digits[j];
        digit += _m ._am(0, u0, x, i, _m._used);
        // Propagate carry.
        while (digit >= _Bigint.DIGIT_BASE) {
          digit -= _Bigint.DIGIT_BASE;
          x._digits[j++] = digit;
  