anchor.diff:    ///
     /// As [parse] except that this method returns `null` if the input is not
     /// valid
  +  ///
  +  /// Examples:
  +  /// ```dart
  +  /// print(BigInt.tryParse('-12345678901234567890')); // -12345678901234567890
  +  /// print(BigInt.tryParse('0xFF')); // 255
  +  /// print(BigInt.tryParse('0xffffffffffffffff')); // 18446744073709551615
  +  ///
  +  /// // From binary (base 2) value.
  +  /// print(BigInt.tryParse('1100', radix: 2)); // 12
  +  /// print(BigInt.tryParse('00011111', radix: 2)); // 31
  +  /// print(BigInt.tryParse('011111100101', radix: 2)); // 2021
  +  /// // From octal (base 8) value.
  +  /// print(BigInt.tryParse('14', radix: 8)); // 12
  +  /// print(BigInt.tryParse('37', radix: 8)); // 31
  +  /// print(BigInt.tryParse('3745', radix: 8)); // 2021
  +  /// // From hexadecimal (base 16) value.
  +  /// print(BigInt.tryParse('c', radix: 16)); // 12
  +  /// print(BigInt.tryParse('1f', radix: 16)); // 31
  +  /// print(BigInt.tryParse('7e5', radix: 16)); // 2021
  +  /// // From base 35 value.
  +  /// print(BigInt.tryParse('y1', radix: 35)); // 1191 == 34 * 35 + 1
  +  /// print(BigInt.tryParse('z1', radix: 35)); // null
  +  /// // From base 36 value.
  +  /// print(BigInt.tryParse('y1', radix: 36)); // 1225 == 34 * 36 + 1
  +  /// print(BigInt.tryParse('z1', radix: 36)); // 1261 == 35 * 36 + 1
  +  /// ```
     external static BigInt? tryParse(String source, {int? radix});
   
  -  /// Allocates a big integer from the provided [value] number.
  +  /// Creates a big integer from the provided [value] number.
  +  ///
  +  /// Examples:
  +  /// ```dart
  +  /// var bigInteger = BigInt.from(1); // 1
  +  /// bigInteger = BigInt.from(0.9999); // 0
  +  /// bigInteger = BigInt.from(-10.99); // -10
  +  /// ```
     external factory BigInt.from(num value);
   
     /// Returns the absolute value of this integer.
  
positive.code: ///
  /// Big integers are signed and can have an arbitrary number of
  /// significant digits, only limited by memory.
  abstract class BigInt implements Comparable<BigInt> {
    /// A big integer with the numerical value 0.
    external static BigInt get zero;
  
negative.code:   BigInt toUnsigned(int width);
  
    /// Returns the least significant [width] bits of this integer, extending the
    /// highest retained bit to the sign. This is the same as truncating the value
    /// to fit in [width] bits using an signed 2-s complement representation. The
    /// returned value has the same bit value in all positions higher than [width].
    ///
    /// ```dart
  