program Task2(input, output);

type term = record coeff, deg: integer end;
     list = ^node;
     node = record t: term; next: list end;

     errCode = (success,
                invalidZeroPolynom,
                signExpected,
                degAlreadyPresent,
                emptyPolynom,
                invalidCoeff,
                invalidDeg,
                degExpected,
                emptyTerm);
     error = record pos: integer; code: errCode end;

var polynoms: array[1..2] of list;
    errInfo: error;
    i: integer;

{ ================================ ‘ЇЁб®Є =============================== }

procedure CreateList(var l: list);
begin
     new(l);
     l^.t.coeff := 0; l^.t.deg := -1;
     l^.next := nil
end;

procedure Insert(var l: list; t: term);
var temp: list;
begin
     temp := l;
     new(l); l^.t := t; l^.next := temp
end;

function IsEmpty(l: list): boolean;
begin
     IsEmpty := l^.next = nil
end;

procedure FindAndInsert(var l: list; t: term; var errInfo: error);
var i: list;
begin
     if t.deg > l^.t.deg then Insert(l, t)
     else
     begin
          i := l;
          while t.deg < i^.next^.t.deg do i := i^.next;

          if (i^.t.deg = t.deg) or (i^.next^.t.deg = t.deg) then
             errInfo.code := degAlreadyPresent
          else Insert(i^.next, t)
     end
end;

function Compare(l1, l2: list): boolean;
var res: boolean;
begin
     res := true;
     while res and not IsEmpty(l1) and not IsEmpty(l2) do
     begin
          res := (l1^.t.deg = l2^.t.deg) and (l1^.t.coeff = l2^.t.coeff);
          l1 := l1^.next; l2 := l2^.next
     end;

     res := res and (IsEmpty(l1) = IsEmpty(l2));
     Compare := res
end;

{ =========================== —⥭ЁҐ ¬­®Ј®з«Ґ­  ========================= }

{ —⥭ЁҐ 楫®Ј® зЁб«  }
procedure ReadInteger(var n: integer; var ch: char);
begin
     n := 0;
     repeat
           n := n * 10 + ord(ch) - ord('0');
           read(ch)
     until ('0' > ch) or (ch > '9')
end;

{ —⥭ЁҐ ®¤­®з«Ґ­  ЎҐ§ ЇаҐ¤иҐбвўго饣® §­ Є  }
procedure ReadTerm(var out: term; var ch: char; var errInfo: error);
var coeffExplicit, degExplicit: boolean;

  { —⥭ЁҐ Є®нддЁжЁҐ­в  ®¤­®з«Ґ­  }
  procedure ReadCoeff(var n: integer);
  begin
       ReadInteger(n, ch);
       if n = 0 then errInfo.code := invalidCoeff
  end;

  { —⥭ЁҐ Ї®Є § ⥫п б⥯Ґ­Ё }
  procedure ReadDeg(var n: integer);
  begin
       read(ch);
       if ch = '^' then
       begin
            read(ch);
            if ('0' <= ch) and (ch <= '9') then
            begin
                 ReadInteger(n, ch);
                 if n < 2 then errInfo.code := invalidDeg
            end
            else errInfo.code := degExpected
       end
       else n := 1
  end;

begin
     coeffExplicit := ('0' <= ch) and (ch <= '9');
     if coeffExplicit then ReadCoeff(out.coeff)
     else out.coeff := 1;

     if errInfo.code = success then
     begin
          degExplicit := ch = 'X';
          if degExplicit then ReadDeg(out.deg)
          else out.deg := 0;

          if not (coeffExplicit or degExplicit) and (errInfo.code = success) then
             errInfo.code := emptyTerm
     end
end;

{ —⥭ЁҐ ­Ґ­г«Ґў®Ј® ¬­®Ј®з«Ґ­  }
procedure ReadNonZeroPolynom(var out: list; var ch: char; var errInfo: error);
var signNeeded, sign: boolean;
    i: integer;

  { —⥭ЁҐ §­ Є  ЇҐаҐ¤ ®¤­®з«Ґ­®¬ }
  procedure ReadSign(var s: boolean);
  begin
       if (ch = '+') or (ch = '-') then
       begin
            s := ch = '-';
            read(ch)
       end
       else if not signNeeded then
       begin
            s := false;
            signNeeded := true
       end
       else errInfo.code := signExpected
  end;

  { —⥭ЁҐ ®¤­®з«Ґ­  Ё ҐЈ® ўбв ўЄ  ў бЇЁб®Є }
  procedure ReadAndInsertTerm;
  var t: term;
  begin
       ReadTerm(t, ch, errInfo);

       if errInfo.code = success then
       begin
            if sign then t.coeff := -t.coeff;
            FindAndInsert(out, t, errInfo)
       end
  end;

begin
     signNeeded := false; i := 0;

     while (ch <> ' ') and (errInfo.code = success) do
     begin
          ReadSign(sign);
          if errInfo.code = success then ReadAndInsertTerm;
          i := i + 1
     end;

     if errInfo.code <> success then errInfo.pos := i
end;

{ —⥭ЁҐ ¬­®Ј®з«Ґ­  }
procedure ReadPolynom(var out: list; var errInfo: error);
var ch: char;
    zero: term;
begin
     errInfo.code := success; errInfo.pos := 0;
     CreateList(out);
     read(ch);

     if ch = '0' then
     begin { Zero polynomial }
          zero.coeff := 0;
          zero.deg := 0;
          Insert(out, zero);

          read(ch);
          if ch <> ' ' then errInfo.code := invalidZeroPolynom
     end
     else
     begin { Non-zero polynomial }
          ReadNonZeroPolynom(out, ch, errInfo);
          if (errInfo.code = success) and IsEmpty(out) then
             errInfo.code := emptyPolynom
     end
end;

{ =========================== €­вҐа䥩б ================================= }

{ ‚лў®¤ б®®ЎйҐ­ЁҐ ®Ў ®иЁЎЄҐ ­  нЄа ­ }
procedure ReportError(errInfo: error);
begin
     write('Error');
     if errInfo.pos <> 0 then write(' in monomial ', errInfo.pos);
     write(': ');

     case errInfo.code of
          invalidZeroPolynom: writeln('Invalid zero polynomial.');
          signExpected: writeln('Sign expected before monomial.');
          degAlreadyPresent: writeln('Monomial of this power is already present in polynomial.');
          emptyPolynom: writeln('Polynomial must contain at least one monomial.');
          invalidCoeff: writeln('Coefficient must be different from zero.');
          invalidDeg: writeln('Power must be greater than 1.');
          degExpected: writeln('Number expected after ^ sign.');
          emptyTerm: writeln('Monomial is empty.');
     end
end;

begin
     i := 1;
     repeat
           writeln('Enter polynomial ', i, ', space-terminated:');
           ReadPolynom(polynoms[i], errInfo); readln;
           i := i + 1;
     until (i > 2) or (errInfo.code <> success);

     if errInfo.code = success then
        writeln('Result: ', Compare(polynoms[1], polynoms[2]))
     else ReportError(errInfo)
end.