anchor.diff:    // Copy existing _digits if reallocation is necessary.
     // TODO(regis): Check that we are not preserving _digits unnecessarily.
     void _ensureLength(int length) {
  -    if (length > 0 && (_digits == null || length > _digits.length)) {
  +    var digits = _digits;
  +    if (length > 0 && (digits == null || length > digits.length)) {
         var new_digits = new Uint32List(length + EXTRA_DIGITS);
  -      if (_digits != null) {
  +      if (digits != null) {
           for (var i = _used; --i >= 0; ) {
  -          new_digits[i] = _digits[i];
  +          new_digits[i] = digits[i];
           }
         }
         _digits = new_digits;
  
positive.code:     int c = 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;
    }
  
negative.code:     y._neg = false;
      r._neg = false;
      var y_used = y._used;
      var y_digits = y._digits;
      var y0 = y_digits[y_used - 1];
      if (y0 == 0) return;
      var yt = y0 >> 1;  // Chop off one bit, see below. y is normalized: yt != 0.
      var i = r._used;
      var j = i - y_used;
      _Bigint t = (q == null) ? new _Bigint() : q;
      y._dlShiftTo(j, t);
      var r_digits = r._digits;
      if (r._compareTo(t) >= 0) {
        r_digits[r._used++] = 1;
        r._subTo(t, r);
      }
      ONE._dlShiftTo(y_used, t);
      t._subTo(y, y);  // Negate y so we can replace sub with _am later.
      while (y._used < y_used) {
        y_digits[y._used++] = 0;
      }
      while (--j >= 0) {
        // Estimate quotient digit.
        // TODO(regis): Move the expensive mint division below to a function that
        // can be intrinsified using an uint64_t by uint32_t division instruction,
        // e.g. qd = _estqd(r_digits, --i, y0).
        var qd;
        if (r_digits[--i] == y0) {
          qd = DIGIT_MASK;
        } else {
          // Chop off one bit, since a Mint cannot hold 2 DIGITs.
          qd = ((r_digits[i] << (DIGIT_BITS - 1)) | (r_digits[i - 1] >> 1)) ~/ yt;
        }
        if ((r_digits[i] += y._am(0, qd, r, j, y_used)) < qd) {  // Try it out.
          y._dlShiftTo(j, t);
          r._subTo(t, r);
          while (r_digits[i] < --qd) {
            r._subTo(t, r);
          }
        }
  