anchor.diff:      var bm = (1 << cbs) - 1;
       var r_used = _used + ds + 1;
       r._ensureLength(r_used);
  +    var digits = _digits;
  +    var r_digits = r._digits;
       var c = 0;
       for (var i = _used - 1; i >= 0; --i) {
  -      r._digits[i + ds + 1] = (_digits[i] >> cbs) | c;
  -      c = (_digits[i] & bm) << bs;
  +      r_digits[i + ds + 1] = (digits[i] >> cbs) | c;
  +      c = (digits[i] & bm) << bs;
       }
       for (var i = ds - 1; i >= 0; --i) {
  -      r._digits[i] = 0;
  -    }
  -    r._digits[ds] = c;
  +      r_digits[i] = 0;
  +    }
  +    r_digits[ds] = c;
       r._used = r_used;
       r._neg = _neg;
       r._clamp();
  
positive.code:     y._neg = false;
      r._neg = false;
      var y_used = y._used;
      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);
  
      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.
        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);
          }
        }
  
negative.code:     int c = 0;
      int xl = x & DIGIT2_MASK;
      int xh = x >> DIGIT2_BITS;
      var digits = _digits;
      var w_digits = w._digits;
      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;
    }
  