longfpc

{*
* С клавиатуры вводится основание с/с (от 2 до 36, в случае >10 для ввода цифр используются буквы латинского алфавита)
* и два числа длины не более 1000 цифр. Необходимо написать программу, которая будет выводить результат вычитания этих чисел.
* В программе необходимо предусмотреть вывод чисел, как с цифрами >10 в виде букв, так и чисел
 *}

const ErrorByte = $FF; { 255 }
      BigIntegerMaxDigits = 1000;

type
    BigInteger = record
        n : word;
        base : byte;
        bytes : array[0 .. BigIntegerMaxDigits] of byte;
    end;


function char2byte(c : char) : byte;
begin
    c := lowerCase(c);

    if c in ['0'..'9'] then
        char2byte := byte(ord(c) - ord('0'))
    else if c in ['a'..'z'] then
        char2byte := byte(ord(c) - ord('a') + 10)
    else
        char2byte := ErrorByte;
end;


function byte2char(b : byte) : char;
begin
    if b in [0..9] then
        byte2char := char(ord('0') + b)
    else if b in [10..35]then
        byte2char := char(ord('A') + b - 10)
    else
        byte2char := '#';
end;


function readBase() : byte;
var
    i, n : integer;
    base : string;
    pow10, result : word;
    sym : byte;
begin
    readln(base);
    n := length(base);


    pow10 := 1;
    result := 0;

    for i := 1 to n do
    begin
        sym := char2byte(base[n - i + 1]);

        if sym = ErrorByte then
        begin
            readBase := ErrorByte;
            Exit();
        end;

        result := result + sym * pow10;
        pow10 := pow10 * 10;
    end;

    if (result >= 2) and (result <= 36) then
        readBase := byte(result)
    else
        readBase := ErrorByte;
end;


function read_BigInteger_withBase(var number : BigInteger) : boolean;
var
    temp : byte;
    c : char;
begin
    number.base := readBase();

    if number.base = ErrorByte then
    begin
        read_BigInteger_withBase := false;
        Exit();
    end;

    number.n := 0;
    FillChar(number.bytes, BigIntegerMaxDigits, 0);

    while True do
    begin
        if number.n > BigIntegerMaxDigits then
        begin
            read_BigInteger_withBase := false;
            Exit();
        end;

        read(c);

        if (c = #10) or (c = #13) then
            break;

        inc(number.n);
        temp := char2byte(c);

        if (temp >= number.base) or (temp = ErrorByte) then
        begin
            read_BigInteger_withBase := false;
            Exit();
        end;

        number.bytes[number.n] := temp;
    end;

    read_BigInteger_withBase := true;
end;


procedure write_BigInteger(number : BigInteger);
var
    i : word;
begin
    for i := 1 to number.n do
        write(byte2char(number.bytes[i]));
    writeln;
end;


function toBase_BigInteger(number : BigInteger; base : byte) : BigInteger;
var
    i, temp : word;
    result : BigInteger;
begin
    //
end;


function substract_BigInteger(left, right : BigInteger) : BigInteger;
begin
    //
end;


var
    left, right : BigInteger;
    noError : boolean;

begin
    noError := read_BigInteger_withBase(left);

    if not noError then
    begin
        writeln('Error reading first number');
        Exit();
    end;

    noError := read_BigInteger_withBase(right);

    if not noError then
    begin
        writeln('Error reading second number');
        Exit();
    end;

    write_BigInteger(left);
    write_BigInteger(right);

    {write_BigInteger(substract_BigInteger(left, right));}
end.