anchor.diff:      var c = 0;
       var i = x_used;
       while (--i >= 0) {
  -      r_digits[i + ds + 1] = (x_digits[i] >> cbs) | c;
  -      c = (x_digits[i] & bm) << bs;
  +      final d = x_digits[i];
  +      r_digits[i + ds + 1] = (d >> cbs) | c;
  +      c = (d & bm) << bs;
       }
       r_digits[ds] = c;
       i = ds;
       while (--i >= 0) {
         r_digits[i] = 0;
       }
  -    if (r_used.isOdd) {
  +    if (r_digits[r_used - 1] == 0) {
  +      r_used--;  // Clamp result.
  +    } else if (r_used.isOdd) {
         r_digits[r_used] = 0;
       }
       return r_used;
  
positive.code:     if (a._used.isOdd) {
        nsh += _DIGIT_BITS;
      }
      var y;  // Normalized positive divisor.
      var r;  // Concatenated positive quotient and normalized positive remainder.
      if (nsh > 0) {
        y = a._lShift(nsh)._abs();
        r = _lShift(nsh)._abs();
      }
      else {
        y = a._abs();
        r = _abs();
      }
      var y_used = y._used;
      var y_digits = y._digits;
      Uint32List args = new Uint32List(4);
      args[_YT_LO] = y_digits[y_used - 2];
      args[_YT] = y_digits[y_used - 1];
      var r_used = r._used;
      // For 64-bit processing, make sure y_used, i, and j are even.
      assert(y_used.isEven);
      var i = r_used + (r_used & 1);
      var j = i - y_used;
      var t = y._dlShift(j);
      if (r._compare(t) >= 0) {
        assert(i == r_used);
        r = r._or(_ONE._dlShift(r_used++))._sub(t);
        assert(r._used == r_used && (i + 1) == r_used);
      }
      // Negate y so we can later use _mulAdd instead of non-existent _mulSub.
      y = _ONE._dlShift(y_used)._sub(y);
      if (y._used < y_used) {
        y_digits = _cloneDigits(y._digits, 0, y._used, y_used);
      } else {
        y_digits = y._digits;
      }
      // y_digits is read-only and has y_used digits (possibly including several
      // leading zeros) plus a leading zero for 64-bit processing.
      var r_digits = _cloneDigits(r._digits, 0, r._used, i + 1);
      // r_digits is modified during iteration.
      // r_digits[0..y_used-1] is the current remainder.
      // r_digits[y_used..r_used-1] is the current quotient.
      --i;
      while (j > 0) {
        var d0 = _estQuotientDigit(args, r_digits, i);
        j -= d0;
        var d1 = _mulAdd(args, _QD, y_digits, 0, r_digits, j, y_used);
        // _estQuotientDigit and _mulAdd must agree on the number of digits to
        // process.
        assert(d0 == d1);
        if (d0 == 1) {
          if (r_digits[i] < args[_QD]) {
            var t = y._dlShift(j);
            var t_digits = t._digits;
            var t_used = t._used;
            _absSub(r_digits, r_used, t_digits, t_used, r_digits);
            while (r_digits[i] < --args[_QD]) {
              _absSub(r_digits, r_used, t_digits, t_used, r_digits);
            }
          }
        } else {
          assert(d0 == 2);
          assert(r_digits[i] <= args[_QD_HI]);
          if ((r_digits[i] < args[_QD_HI]) || (r_digits[i-1] < args[_QD])) {
            var t = y._dlShift(j);
            var t_digits = t._digits;
            var t_used = t._used;
            _absSub(r_digits, r_used, t_digits, t_used, r_digits);
            if (args[_QD] == 0) {
              --args[_QD_HI];
            }
            --args[_QD];
            assert(r_digits[i] <= args[_QD_HI]);
            while ((r_digits[i] < args[_QD_HI]) || (r_digits[i-1] < args[_QD])) {
              _absSub(r_digits, r_used, t_digits, t_used, r_digits);
              if (args[_QD] == 0) {
                --args[_QD_HI];
              }
              --args[_QD];
              assert(r_digits[i] <= args[_QD_HI]);
            }
          }
        }
  
negative.code:     var c = 0;
      var i = _used;
      while (--i >= 0) {
        final d = digits[i];
        r_digits[i + ds + 1] = (d >> cbs) | c;
        c = (d & bm) << bs;
      }
      r_digits[ds] = c;
      return new _Bigint(_neg, r_used, r_digits);
  