anchor.diff:      }
       if (resultDigits[resultUsed - 1] == 0) {
         resultUsed--; // Clamp result.
  +    } else if (resultUsed.isOdd) {
  +      resultDigits[resultUsed] = 0;
       }
       return resultUsed;
     }
   
  -  // resultDigits[0..resultUsed-1] = xDigits[0..xUsed-1] >> n.
  +  /// resultDigits[0..resultUsed-1] = xDigits[0..xUsed-1] >> n.
  +  ///
  +  /// Note: This function may be intrinsified.
     static void _rsh(
         Uint32List xDigits, int xUsed, int n, Uint32List resultDigits) {
       final digitsShift = n ~/ _digitBits;
  
positive.code:   /// digits.
    static Uint32List _cloneDigits(
        Uint32List digits, int from, int to, int length) {
      var resultDigits = new Uint32List(length);
      var n = to - from;
      for (var i = 0; i < n; i++) {
        resultDigits[i] = digits[from + i];
  
negative.code:   /// The least significant digit is in slot 0.
    /// The list may have more digits than needed. That is, `_digits.length` may
    /// be strictly greater than `_used`.
    /// Also, `_digits.length` must always be even, because intrinsics on 64-bit
    /// platforms may process a digit pair as a 64-bit value.
    final Uint32List _digits;
  
    /// The number of used entries in [_digits].
    ///
    /// To avoid reallocating [Uint32List]s, lists that are too big are not
    /// replaced, but `_used` reflects the smaller number of digits actually used.
    ///
    /// Note that functions shortening an existing list of digits to a smaller
    /// `_used` number of digits must ensure that the highermost pair of digits
    /// is correct when read as a 64-bit value by intrinsics. Therefore, if the
    /// smaller '_used' number is odd, the high digit of that pair must be
    /// explicitly cleared, i.e. _digits[_used] = 0, which cannot result in an
    /// out of bounds access, since the length of the list is guaranteed to be
    /// even.
    final int _used;
  
    /**
  