anchor.diff:        end;
       0:
         begin
  -        if SignBitOf(Dividend.FSize) = SignBitOf(Divisor.FSize) then
  +        if (Dividend.FSize xor Divisor.FSize) and SignMask = 0 then
             ShallowCopy(One, Quotient)
           else
             ShallowCopy(MinusOne, Quotient);
  
positive.code: // TODO: modular arithmetic. Modular inverse, modular division and multiplication. Barrett, Montgomery, etc.
  // TODO: Better parsing. Recursive parsing (more or less the reverse of recursive routine for ToString) for normal
  //       bases, shifting for bases 2, 4 and 16. This means that normal bases are parsed BaseInfo.MaxDigits at a time.
  interface
  
  uses
  
negative.code:   SignBit: Integer;
    Comparison: TValueSign;
  begin
    if Pointer(Left.FData) = nil then
    begin
      ShallowCopy(Right, Result);
      Exit;
    end
    else if Pointer(Right.FData) = nil then
    begin
      ShallowCopy(Left, Result);
      Exit;
    end;
  
    LSize := Left.FSize and SizeMask;
    RSize := Right.FSize and SizeMask;
    Res.MakeSize(IntMax(LSize, RSize) + 1);
  
    if ((Left.FSize xor Right.FSize) and SignMask) = 0 then
    begin
      // Same sign: add both magnitudes and transfer sign.
      FInternalAdd(PLimb(Left.FData), PLimb(Right.FData), PLimb(Res.FData), LSize, RSize);
      SignBit := Left.FSize and SignMask;
    end
    else
    begin
      Comparison := InternalCompare(PLimb(Left.FData), PLimb(Right.FData), Left.FSize and SizeMask, Right.FSize and SizeMask);
  
      if Comparison = 0 then
        Exit(Zero);
  
      if Comparison < 0 then
      begin
        FInternalSubtract(PLimb(Right.FData), PLimb(Left.FData), PLimb(Res.FData), RSize, LSize);
        SignBit := Right.FSize and SignMask;
      end
      else
      begin
        FInternalSubtract(PLimb(Left.FData), PLimb(Right.FData), PLimb(Res.FData), LSize, RSize);
        SignBit := Left.FSize and SignMask;
      end;
    end;
    Res.FSize := (Res.FSize and SizeMask) or SignBit;
  