anchor.diff:      // -- Comparison operators --
   
       /// <summary>Returns True if the specified BigIntegers have the same value.</summary>
  -    class operator Equal(const Left, Right: BigInteger): Boolean;
  +    class operator Equal(const Left, Right: BigInteger): Boolean; inline;
   
       /// <summary>Returns True if the specified BigInteger do not have the same value.</summary>
  -    class operator NotEqual(const Left, Right: BigInteger): Boolean;
  +    class operator NotEqual(const Left, Right: BigInteger): Boolean; inline;
   
       /// <summary>Returns true if the value of Left is mathematically greater than the value of Right.</summary>
  -    class operator GreaterThan(const Left, Right: BigInteger): Boolean;
  +    class operator GreaterThan(const Left, Right: BigInteger): Boolean; inline;
   
       /// <summary>Returns true if the value of Left is mathematically greater than or equal to the value of Right.</summary>
  -    class operator GreaterThanOrEqual(const Left, Right: BigInteger): Boolean;
  +    class operator GreaterThanOrEqual(const Left, Right: BigInteger): Boolean; inline;
   
       /// <summary>Returns true if the value of Left is mathematically less than the value of Right.</summary>
  -    class operator LessThan(const Left, Right: BigInteger): Boolean;
  +    class operator LessThan(const Left, Right: BigInteger): Boolean; inline;
   
       /// <summary>Returns true if the value of Left is mathematically less than or equal to the value of Right.</summary>
  -    class operator LessThanOrEqual(const Left, Right: BigInteger): Boolean;
  +    class operator LessThanOrEqual(const Left, Right: BigInteger): Boolean; inline;
   
   
       // -- Implicit conversion operators --
  
positive.code:       TErrorCode = (ecParse, ecDivbyZero, ecConversion, ecInvalidBase, ecOverflow, ecInvalidArg, ecNoInverse);
        TDyadicOperator = procedure(Left, Right, Result: PLimb; LSize, RSize: Integer);
      var
        FData: TMagnitude;                        // The limbs of the magnitude, least significant limb at lowest address.
        FSize: Integer;                           // The top bit is the sign of the big integer. Rest is the number of valid limbs of the big integer.
      class var
        FBase: TNumberBase;
        FAvoidStall: Boolean;
        FRoundingMode: TRoundingMode;
        FInternalAdd: TDyadicOperator;
        FInternalSubtract: TDyadicOperator;
    {$ENDREGION}
  
    {$REGION 'private functions'}
    {$IFNDEF PUREPASCAL}
      class procedure DetectPartialFlagsStall; static;
      class procedure InternalAddModified(Left, Right, Result: PLimb; LSize, RSize: Integer); static;
      class procedure InternalAddPlain(Left, Right, Result: PLimb; LSize, RSize: Integer); static;
      class procedure InternalSubtractModified(Larger, Smaller, Result: PLimb; LSize, SSize: Integer); static;
      class procedure InternalSubtractPlain(Larger, Smaller, Result: PLimb; LSize, SSize: Integer); static;
      class procedure InternalDivideBy3(Value, Result: PLimb; ASize: Integer); static;
      class function InternalDivMod100(var X: NativeUInt): NativeUInt; static;
      class procedure InternalIntToStrDecimal(const Value: NativeUInt; var WritePtr: PChar; MaxDigits: Integer); static;
    {$ELSE}
      class procedure InternalAddPurePascal(Left, Right, Result: PLimb; LSize, RSize: Integer); static;
      class procedure InternalSubtractPurePascal(Larger, Smaller, Result: PLimb; LSize, SSize: Integer); static;
    {$ENDIF}
      class function InternalCompare(Left, Right: PLimb; LSize, RSize: Integer): Integer; static;
      class procedure InternalAnd(Left, Right, Result: PLimb; LSize, RSize: Integer); static;
      class procedure InternalOr(Left, Right, Result: PLimb; LSize, RSize: Integer); static;
      class procedure InternalXor(Left, Right, Result: PLimb; LSize, RSize: Integer); static;
      class procedure InternalAndNot(Left, Right, Result: PLimb; LSize, RSize: Integer); static;
      class procedure InternalNotAnd(Left, Right, Result: PLimb; LSize, RSize: Integer); static; inline;
      class procedure InternalBitwise(const Left, Right: BigInteger; var Result: BigInteger; PlainOp, OppositeOp, InversionOp: TDyadicOperator); static;
      class procedure InternalIncrement(Limbs: PLimb; Size: Integer); static;
      class procedure InternalDecrement(Limbs: PLimb; Size: Integer); static;
      class function InternalParseDecimal(P: PChar; var Value: BigInteger): Boolean; static;
      class function InternalParseHex(P: PChar; var Value: BigInteger): Boolean; static;
      class procedure InternalShiftLeft(Source, Dest: PLimb; Shift, Size: Integer); static;
      class procedure InternalShiftRight(Source, Dest: PLimb; Shift, Size: Integer); static;
      class procedure InternalIntToStrBase(const Value: NativeUInt; Base: Cardinal; var WritePtr: PChar; MaxDigits: Integer); static;
      class procedure InternalShiftedToString(const Value: BigInteger; Base: Integer; var WritePtr: PChar); static;
      class procedure InternalPlainToString(const Value: BigInteger; Base: Integer; const BaseInfo: TNumberBaseInfo; var WritePtr: PChar; SectionCount: Integer); static;
      class procedure InternalRecursiveToString(const Value: BigInteger; Base: Integer; const BaseInfo: TNumberBaseInfo; var WritePtr: PChar; SectionCount: Integer); static;
      class function InternalDivMod(Dividend, Divisor, Quotient, Remainder: PLimb; LSize, RSize: Integer): Boolean; static;
      class function InternalDivMod32(Dividend: PLimb; Divisor: UInt32; Quotient, Remainder: PLimb; LSize: Integer): Boolean; static;
      class function InternalDivMod16(Dividend: PLimb; Divisor: UInt16; Quotient, Remainder: PLimb; LSize: Integer): Boolean; static;
      class procedure InternalMultiply(Left, Right, Result: PLimb; LSize, RSize: Integer); static;
      class function InternalDivideByBase(Mag: PLimb; Base: Integer; var Size: Integer): UInt32; static;
      class procedure InternalMultiplyAndAdd16(const Multiplicand: TMagnitude; Multiplicator, Addend: UInt16; const Res: TMagnitude); static;
      class procedure InternalMultiplyAndAdd32(const Multiplicand: TMagnitude; Multiplicator, Addend: UInt32; const Res: TMagnitude); static;
      class procedure InternalNegate(Source, Dest: PLimb; Size: Integer); static;
  
      // Burnikel-Ziegler and helper functions.
      class procedure InternalDivModBurnikelZiegler(const Left, Right: BigInteger; var Quotient, Remainder: BigInteger); static;
      class function DivideBy3Exactly(const A: BigInteger): BigInteger; static;
      class procedure DivThreeHalvesByTwo(const LeftUpperMid, LeftLower, Right, RightUpper, RightLower: BigInteger; N: Integer; var Quotient, Remainder: BigInteger); static;
      class procedure DivTwoDigitsByOne(const Left, Right: BigInteger; N: Integer; var Quotient, Remainder: BigInteger); static;
  
      // Karatsuba and Toom-Cook helper functions
      procedure AddWithOffset(const Addend: BigInteger; Offset: Integer);
      function Split(BlockSize, BlockCount: Integer): TArray<BigInteger>;
  
      class procedure SetBase(const Value: TNumberBase); static;
      class procedure Error(ErrorCode: TErrorCode; const ErrorInfo: string = ''); static;
  
      procedure Compact;
      procedure EnsureSize(RequiredSize: Integer);
      procedure MakeSize(RequiredSize: Integer);
    {$ENDREGION}
  
    public
    {$REGION 'public properties'}
      property Size: Integer read GetSize;
      property Allocated: Integer read GetAllocated;
      property Negative: Boolean read IsNegative;
      property Sign: Integer read GetSign write SetSign;
      property Magnitude: TMagnitude read FData;
  
      // -- Global numeric base for BigIntegers --
  
      class property Base: TNumberBase read FBase write SetBase;
      class property StallAvoided: Boolean read FAvoidStall;
      class property RoundingMode: TRoundingMode read FRoundingMode write FRoundingMode;
    {$ENDREGION}
  
  
negative.code: 
      /// <summary>Returns the result of the bitwise AND operation on its BigInteger operands. The result
      /// has two's complement semantics, e.g. '-1 and 7' returns '7'.</summary>
      class operator BitwiseAnd(const Left, Right: BigInteger): BigInteger; inline;
  
      /// <summary>Returns the result of the bitwise OR operation on its BigInteger operands. The result
      /// has two's complement semantics, e.g. '-1 or 7' returns '-1'.</summary>
      class operator BitwiseOr(const Left, Right: BigInteger): BigInteger; inline;
  
      /// <summary>Returns the result of the bitwise XOR operation on its BigIntegers operands. The result
      /// has two's complement semantics, e.g. '-1 xor 7' returns '-8'.</summary>
      class operator BitwiseXor(const Left, Right: BigInteger): BigInteger; inline;
  
      /// <summary>Returns the result of the bitwise NOT operation on its BigInteger operand. The result
      /// has two's complement semantics, e.g. 'not 1' returns '-2'.</summary>
      class operator LogicalNot(const Value: BigInteger): BigInteger; inline;
  
  
      // -- Shift operators --
  