anchor.diff:     */
     _BigIntImpl operator <<(int shiftAmount) {
       if (shiftAmount < 0) {
  -      throw new ArgumentError("shift-amount must be posititve $shiftAmount");
  +      throw new ArgumentError("shift-amount must be positive $shiftAmount");
       }
       final digitShift = shiftAmount ~/ _digitBits;
       final bitShift = shiftAmount % _digitBits;
       if (bitShift == 0) {
         return _dlShift(digitShift);
       }
  +    // Need one extra digit to hold bits shifted by bitShift.
       var resultUsed = _used + digitShift + 1;
  -    var resultDigits = new Uint32List(resultUsed);
  +    var resultDigits = _newDigits(resultUsed);
       _lsh(_digits, _used, shiftAmount, resultDigits);
       return new _BigIntImpl._(_isNegative, resultUsed, resultDigits);
     }
   
  -  // resultDigits[0..resultUsed-1] = xDigits[0..xUsed-1] << n.
  -  // Returns resultUsed.
  +  /// resultDigits[0..resultUsed-1] = xDigits[0..xUsed-1] << n.
  +  /// Returns resultUsed.
     static int _lShiftDigits(
         Uint32List xDigits, int xUsed, int n, Uint32List resultDigits) {
       final digitsShift = n ~/ _digitBits;
  
positive.code:   ///
    /// Returns `resultUsed`.
    ///
    /// `resultDigits[0..resultUsed-1] = xDigits[0..xUsed-1] << n*_DIGIT_BITS`.
    static int _dlShiftDigits(
        Uint32List xDigits, int xUsed, int n, Uint32List resultDigits) {
      if (xUsed == 0) {
  
negative.code:     _lastRem_nsh = nsh;
    }
  
    // Customized version of _rem() minimizing allocations for use in reduction.
    // Input:
    //   xDigits[0..xUsed-1]: positive dividend.
    //   yDigits[0..yUsed-1]: normalized positive divisor.
    //   nyDigits[0..yUsed-1]: negated yDigits.
    //   nsh: normalization shift amount.
    //   args: top y digit(s) and place holder for estimated quotient digit(s).
    //   tmpDigits: temp array of 2*yUsed digits.
    //   resultDigits: result digits array large enough to temporarily hold
    //                 concatenated quotient and normalized remainder.
    // Output:
    //   resultDigits[0..resultUsed-1]: positive remainder.
    // Returns resultUsed.
    static int _remDigits(
        Uint32List xDigits,
        int xUsed,
        Uint32List yDigits,
        int yUsed,
        Uint32List nyDigits,
        int nsh,
        Uint32List args,
        Uint32List tmpDigits,
        Uint32List resultDigits) {
      // Initialize resultDigits to normalized positive dividend.
      var resultUsed = _lShiftDigits(xDigits, xUsed, nsh, resultDigits);
      // For 64-bit processing, make sure yUsed, i, and j are even.
      assert(yUsed.isEven);
      var i = resultUsed + (resultUsed & 1);
      var j = i - yUsed;
      var tmpUsed = _dlShiftDigits(yDigits, yUsed, j, tmpDigits);
      // Explicit first division step in case normalized dividend is larger or
      // equal to shifted normalized divisor.
      if (_compareDigits(resultDigits, resultUsed, tmpDigits, tmpUsed) >= 0) {
        assert(i == resultUsed);
        resultDigits[resultUsed++] = 1; // Quotient = 1.
        // Subtract divisor from remainder.
        _absSub(resultDigits, resultUsed, tmpDigits, tmpUsed, resultDigits);
      } else {
        // Account for possible carry in _mulAdd step.
        resultDigits[resultUsed++] = 0;
      }
      if (resultUsed.isOdd) {
        resultDigits[resultUsed] = 0; // Leading zero for 64-bit processing.
      }
      // Negated yDigits passed in nyDigits allow the use of _mulAdd instead of
      // unimplemented _mulSub.
      // nyDigits is read-only and has yUsed digits (possibly including several
      // leading zeros) plus a leading zero for 64-bit processing.
      // resultDigits is modified during iteration.
      // resultDigits[0..yUsed-1] is the current remainder.
      // resultDigits[yUsed..resultUsed-1] is the current quotient.
      --i;
      while (j > 0) {
        var d0 = _estimateQuotientDigit(args, resultDigits, i);
        j -= d0;
        var d1 =
            _mulAdd(args, _quotientDigit, nyDigits, 0, resultDigits, j, yUsed);
        // _estimateQuotientDigit and _mulAdd must agree on the number of digits
        // to process.
        assert(d0 == d1);
        if (d0 == 1) {
          if (resultDigits[i] < args[_quotientDigit]) {
            var tmpUsed = _dlShiftDigits(nyDigits, yUsed, j, tmpDigits);
            _absSub(resultDigits, resultUsed, tmpDigits, tmpUsed, resultDigits);
            while (resultDigits[i] < --args[_quotientDigit]) {
              _absSub(resultDigits, resultUsed, tmpDigits, tmpUsed, resultDigits);
            }
          }
        } else {
          assert(d0 == 2);
          assert(resultDigits[i] <= args[_quotientHighDigit]);
          if ((resultDigits[i] < args[_quotientHighDigit]) ||
              (resultDigits[i - 1] < args[_quotientDigit])) {
            var tmpUsed = _dlShiftDigits(nyDigits, yUsed, j, tmpDigits);
            _absSub(resultDigits, resultUsed, tmpDigits, tmpUsed, resultDigits);
            if (args[_quotientDigit] == 0) {
              --args[_quotientHighDigit];
            }
            --args[_quotientDigit];
            assert(resultDigits[i] <= args[_quotientHighDigit]);
            while ((resultDigits[i] < args[_quotientHighDigit]) ||
                (resultDigits[i - 1] < args[_quotientDigit])) {
              _absSub(resultDigits, resultUsed, tmpDigits, tmpUsed, resultDigits);
              if (args[_quotientDigit] == 0) {
                --args[_quotientHighDigit];
              }
              --args[_quotientDigit];
              assert(resultDigits[i] <= args[_quotientHighDigit]);
            }
          }
        }
        i -= d0;
      }
      // Return remainder, i.e. denormalized resultDigits[0..yUsed-1].
      resultUsed = yUsed;
      if (nsh > 0) {
        // Denormalize remainder.
        resultUsed = _rShiftDigits(resultDigits, resultUsed, nsh, resultDigits);
      }
      return resultUsed;
    }
  
    int get hashCode {
      // This is the [Jenkins hash function][1] but using masking to keep
      // values in SMI range.
  