procedure zero(var num : number);
var
   b : integer;
begin { procedure zero }
   for b := 1 to MAXB do
      num.n[b] := 0;
   num.s := 1;
end; { procedure zero }

function numcmp(num1, num2 : number) : integer;
{
   does not compare the sign.
}
var
   b : integer;
begin { procedure numcmp }
   b := MAXB;
   while (b > 1) and (num1.n[b] = num2.n[b]) do
      b := b - 1;
   numcmp := num1.n[b] - num2.n[b];
end; { procedure numcmp }


procedure add_ni(num : number; i : integer; var result : number);
var
   b,
   tmp,
   carry  : integer;
begin { procedure add_ni }
   carry := i;
   for b := 1 to MAXB do
      begin
      tmp := num.n[b] + carry;
      carry       := tmp div 256;
      result.n[b] := tmp mod 256;
      end;
   if (carry > 0) then
      writeln('numeric overflow');
end; { procedure add_ni }

procedure mult_ni(num : number; i : integer; var result : number);
var
   b,
   carry  : integer;
   tmp    : real;
begin { procedure mult_ni }
   carry := 0;
   for b := 1 to MAXB do
      begin
      tmp := (1.0 * num.n[b])  * (1.0 * i) + carry;
      carry       := trunc(tmp / 256);
      result.n[b] := trunc(tmp - carry * 256.0);
      end;
   if (carry > 0) then
      writeln('numeric overflow');
end; { procedure mult_ni }

procedure div_ni(num           : number;
                 i             : integer;
                 var result    : number;
                 var remainder : integer);
var
   b   : integer;
   tmp : real;
begin { procedure div_ni }
   b := MAXB;
   remainder := 0;
   repeat
      tmp         := num.n[b] + 256.0 * remainder;
      result.n[b] := trunc(tmp / i);
      remainder   := trunc(tmp - result.n[b] * (1.0 * i));
      b := b - 1;
   until (b < 1);
end; { procedure div_ni }


function todec(num : str; frombase : integer; var dec : number)
                  : boolean;
var
   c     : char;
   val_c : integer;
   valid : boolean;

function upcase(c : char) : char;
begin { function upcase }
   if c in ['a'..'z'] then
      upcase := chr(ord(c) - ord('a') + ord('A'))
   else
      upcase := c;
end; { function upcase }

begin { function todec }
   valid  := true;
   zero(dec);
   if num[1] = '-' then
      begin
      dec.s := -1;
      num := copy(num, 2, length(num) - 1);
      end
   else
      dec.s := 1;
   while (num <> '') and valid do
      begin
      c     := upcase(num[1]);
      val_c := pos(c, NUMS) - 1;
      if (val_c >= frombase) or (val_c < 0) then
         begin
         valid := false;
         writeln('Invalid character ''', c, ''' in number base ',
                  frombase:1, '.');
         end
      else
         begin
         mult_ni(dec, frombase, dec);
         add_ni(dec, val_c, dec);
         num := copy(num, 2, length(num) - 1);
         end;
      end;
   todec := valid;
end; { function todec }

procedure toother(dec : number; tobase : integer; var ans : str;
                  two_comp : boolean);
var
   pos : integer;
begin { procedure toother }
   ans := '';
   if two_comp then
      if dec.s = -1 then
         begin
         dec.b := (neg_one - dec.b);
         add_ni(dec, 1, dec);
         end;
   repeat
      div_ni(dec, tobase, dec, pos);
      pos    := pos + 1;
      ans    := NUMS[pos] + ans;
   until (numcmp(dec, zero_n) = 0);
   if not two_comp then
      if dec.s = -1 then
         ans := '-' + ans;
end; { procedure toother }

function convbase(num : str; frombase, tobase : integer; var ans : str)
                  : boolean;
var
   dec : number;
begin { function convbase }
   convbase := true;
   if todec(num, frombase, dec) then
      toother(dec, tobase, ans, false)
   else
      convbase := false;
end; { function convbase }