anchor.diff:  
     // Accumulate multiply.
     // this[i..i+n-1]: bigint multiplicand.
  -  // x: digit multiplier.
  +  // x: digit multiplier, 0 <= x < DIGIT_BASE (i.e. 32-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.
  +  // w[j..j+n-1] += this[i..i+n-1] * x.
     // Returns carry out.
  -  // TODO(regis): _sqrTo is the only caller passing an x possibly larger than
  -  // a digit (2*digit) and passing a non-zero carry in. Refactor?
  -  int _am(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.
  +  int _am(int i, int x, _Bigint w, int j, int n) {
  +    if (x == 0) {
  +      // No-op if x is 0.
         return 0;
       }
  +    int c = 0;
       int xl = x & DIGIT2_MASK;
       int xh = x >> DIGIT2_BITS;
       while (--n >= 0) {
  
positive.code:       var qd = (r._digits[--i] == y0)
            ? DIGIT_MASK
            : (r._digits[i]*d1 + (r._digits[i - 1] + e)*d2).floor();
        if ((r._digits[i] += y._am(0, qd, r, j, 0, y_used)) < qd) {  // Try it out
          y._dlShiftTo(j, t);
          r._subTo(t, r);
          while (r._digits[i] < --qd) {
  
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;
  