i, len8: longint;
  g: char;
begin
  str256 := '';
  while (Length(str2) mod 8) <> 0 do
    str2 := '0' + str2;
  len8 := Length(str2) div 8;
  for i := 1 to len8 do
  begin
    zeronetochar8(g, copy(str2, 1, 8));
    str256 := str256 + g;
    delete(str2, 1, 8);
  end;
end;


procedure ConvertBase2to64(str2: string; var str64: string);
var
  i, len6: longint;
  g: integer;
begin
  str64 := '';
  while (Length(str2) mod 6) <> 0 do
    str2 := '0' + str2;
  len6 := Length(str2) div 6;
  for i := 1 to len6 do
  begin
    zeronetochar6(g, copy(str2, 1, 6));
    str64 := str64 + chr64[g];
    delete(str2, 1, 6);
  end;
end;


// Convert base 256 strings to base 16 (HexaDecimal) strings and visa versa

procedure ConvertBase256StringToHexString(str256: string; var HexStr: string);
var
  i: longint;
  b: byte;
begin
  HexStr := '';
  for i := 1 to Length(str256) do
  begin
    b := ord(str256[i]);
    if (b shr 4) < 10 then
      HexStr := HexStr + chr(48 + (b shr 4))
    else
      HexStr := HexStr + chr(55 + (b shr 4));
    if (b and 15) < 10 then
      HexStr := HexStr + chr(48 + (b and 15))
    else
      HexStr := HexStr + chr(55 + (b and 15));
  end;
end;


procedure ConvertHexStringToBase256String(HexStr: string; var str256: string);
var
  i: longint;
  b, h1, h2: byte;
begin
  str256 := '';
  for i := 1 to (Length(HexStr) div 2) do
  begin
    h2 := ord(HexStr[2 * i]);
    h1 := ord(HexStr[2 * i - 1]);
    if h1 < 58 then
      b := ((h1 - 48) shl 4)
    else
      b := ((h1 - 55) shl 4);
    if h2 < 58 then
      b := (b or (h2 - 48))
    else
      b := (b or (h2 - 55));
    str256 := str256 + chr(b);
  end;
end;


// Convert base 256 strings to base 64 strings and visa versa, PGP style

procedure PGPConvertBase256to64(var str256, str64: string);
var
  temp, x, a: string;
  i, len6: longint;
  g: integer;
  trans: array[0..255] of string;
begin
  initialize8(trans);
  temp := '';
  for i := 1 to Length(str256) do
    temp := temp + trans[ord(str256[i])];
  if (Length(temp) mod 6) = 0 then
    a := ''
  else if (Length(temp) mod 6) = 4 then
  begin
    temp := temp + '00';
    a := '='
  end
  else
  begin
    temp := temp + '0000';
    a := '=='
  end;
  str64 := '';
  len6 := Length(temp) div 6;
  for i := 1 to len6 do
  begin
    x := copy(temp, 1, 6);
    zeronetochar6(g, x);
    str64 := str64 + PGPchr64[g];
    delete(temp, 1, 6);
  end;
  str64 := str64 + a;
end;


procedure PGPConvertBase64to256(str64: string; var str256: string);
var
  temp, x: string;
  i, j, len8: longint;
  g: char;
  trans: array[0..255] of string;
begin
  initialize6PGP(trans);
  temp := '';
  str256 := '';
  if str64[Length(str64) - 1] = '=' then
    j := 2
  else if str64[Length(str64)] = '=' then
    j := 1
  else
    j := 0;
  for i := 1 to (Length(str64) - j) do
    temp := temp + trans[ord(str64[i])];
  if j <> 0 then delete(temp, Length(temp) - 2 * j + 1, 2 * j);
  len8 := Length(temp) div 8;
  for i := 1 to len8 do
  begin
    x := copy(temp, 1, 8);
    zeronetochar8(g, x);
    str256 := str256 + g;
    delete(temp, 1, 8);
  end;
end;

// Convert base 64 strings to base 2 strings, PGP style


procedure PGPConvertBase64to2(str64: string; var str2: string);
var
  i, j: longint;
  trans: array[0..255] of string;
begin
  str2 := '';
  initialize6(trans);
  if str64[Length(str64) - 1] = '=' then
    j := 2
  else if str64[Length(str64)] = '=' then
    j := 1
  else
    j := 0;
  for i := 1 to (Length(str64) - j) do
    str2 := str2 + trans[ord(str64[i])];
  delete(str2, Length(str2) - 2 * j + 1, 2 * j);
end;


// Convert a base 10 string to a FGInt

procedure Base10StringToFGInt(Base10: string; var FGInt: TFGInt);
var
  i, size: longint;
  j: int64;
  s: string;
  Sign: TSign;

  procedure GIntDivByIntBis1(var GInt: TFGInt; by: int64; var modres: int64);
  var
    i, size: longint;
    rest: int64;
  begin
    size := GInt.Number[0];
    modres := 0;
    for i := size downto 1 do
    begin
      modres := modres * 1000000000;
      rest := modres + GInt.Number[i];
      GInt.Number[i] := rest div by;
      modres := rest mod by;
    end;
    while (GInt.Number[size] = 0) and (size > 1) do
      size := size - 1;
    if size <> GInt.Number[0] then
    begin
      SetLength(GInt.Number, size + 1);
      GInt.Number[0] := size;
    end;
  end;

begin
  while (not (Base10[1] in ['-', '0'..'9'])) and (Length(Base10) > 1) do
    delete(Base10, 1, 1);
  if copy(Base10, 1, 1) = '-' then
  begin
    Sign := negative;
    delete(Base10, 1, 1);
  end
  else
    Sign := positive;
  while (Length(Base10) > 1) and (copy(Base10, 1, 1) = '0') do
    delete(Base10, 1, 1);
  size := Length(Base10) div 9;
  if (Length(Base10) mod 9) <> 0 then size := size + 1;
  SetLength(FGInt.Number, size + 1);
  FGInt.Number[0] := size;
  for i := 1 to size - 1 do
  begin
    FGInt.Number[i] := StrToInt(copy(Base10, Length(Base10) - 8, 9));
    delete(Base10, Length(Base10) - 8, 9);
  end;
  FGInt.Number[size] := StrToInt(Base10);

  s := '';
  while (FGInt.Number[0] <> 1) or (FGInt.Number[1] <> 0) do
  begin
    GIntDivByIntBis1(FGInt, 2, j);
    s := inttostr(j) + s;
  end;
  s := '0' + s;
  FGIntDestroy(FGInt);
  Base2StringToFGInt(s, FGInt);
  FGInt.Sign := Sign;
end;


// Convert a FGInt to a base 10 string

procedure FGIntToBase10String(const FGInt: TFGInt; var Base10: string);
var
  s: string;
  j: int64;
  temp: TFGInt;
begin
  FGIntCopy(FGInt, temp);
  Base10 := '';
  while (temp.Number[0] > 1) or (temp.Number[1] > 0) do
  begin
    FGIntDivByIntBis(temp, 1000000000, j);
    s := inttostr(j);
    while Length(s) < 9 do
      s := '0' + s;
    Base10 := s + Base10;
  end;
  Base10 := '0' + Base10;
  while (Length(Base10) > 1) and (Base10[1] = '0') do
    delete(Base10, 1, 1);
  if FGInt.Sign = negative then Base10 := '-' + Base10;
end;



// Destroy a FGInt to free memory

procedure FGIntDestroy(var FGInt: TFGInt);
begin
  FGInt.Number := nil;
end;


// Compare 2 FGInts in absolute value, returns
// Lt if FGInt1 > FGInt2, St if FGInt1 < FGInt2, Eq if FGInt1 = FGInt2,
// Er otherwise

function FGIntCompareAbs(const FGInt1, FGInt2: TFGInt): TCompare;
var
  size1, size2, i: longint;
begin
  FGIntCompareAbs := Er;
  size1 := FGInt1.Number[0];
  size2 := FGInt2.Number[0];
  if size1 > size2 then
    FGIntCompareAbs := Lt
  else if size1 < size2 then
    FGIntCompareAbs := St
  else
  begin
    i := size2;
    while (FGInt1.Number[i] = FGInt2.Number[i]) and (i > 1) do
      i := i - 1;
    if FGInt1.Number[i] = FGInt2.Number[i] then
      FGIntCompareAbs := Eq
    else if FGInt1.Number[i] < FGInt2.Number[i] then
      FGIntCompareAbs := St
    else if FGInt1.Number[i] > FGInt2.Number[i] then
      FGIntCompareAbs := Lt;
  end;
end;


// Add 2 FGInts, FGInt1 + FGInt2 = Sum

procedure FGIntadd(const FGInt1, FGInt2: TFGInt; var Sum: TFGInt);
var
  i, size1, size2, size: longint;
  rest: integer;
  Trest: int64;
begin
  size1 := FGInt1.Number[0];
  size2 := FGInt2.Number[0];
  if size1 < size2 then
    FGIntadd(FGInt2, FGInt1, Sum)
  else
  begin
    if FGInt1.Sign = FGInt2.Sign then
    begin
      Sum.Sign := FGInt1.Sign;
      SetLength(Sum.Number, size1 + 2);
      rest := 0;
      for i := 1 to size2 do
      begin
        Trest := FGInt1.Number[i] + FGInt2.Number[i] + rest;
        Sum.Number[i] := Trest and 2147483647;
        rest := Trest shr 31;
      end;
      for i := (size2 + 1) to size1 do
      begin
        Trest := FGInt1.Number[i] + rest;
        Sum.Number[i] := Trest and 2147483647;
        rest := Trest shr 31;
      end;
      size := size1 + 1;
      Sum.Number[0] := size;
      Sum.Number[size] := rest;
      while (Sum.Number[size] = 0) and (size > 1) do
        size := size - 1;
      if Sum.Number[0] > size then SetLength(Sum.Number, size + 1);
      Sum.Number[0] := size;
    end
    else
    begin
      if FGIntCompareAbs(FGInt2, FGInt1) = Lt then
        FGIntadd(FGInt2, FGInt1, Sum)
      else
      begin
        SetLength(Sum.Number, size1 + 1);
        rest := 0;
        for i := 1 to size2 do
        begin
          Trest := 2147483648 + FGInt1.Number[i] - FGInt2.Number[i] + rest;
          Sum.Number[i] := Trest and 2147483647;
          if (Trest > 2147483647) then
            rest := 0
          else
            rest := -1;
        end;
        for i := (size2 + 1) to size1 do
        begin
          Trest := 2147483648 + FGInt1.Number[i] + rest;
          Sum.Number[i] := Trest and 2147483647;