{uses HeapTrc;}
type
   TTree = ^node;
   node	 = record
	      left, right : TTree;
	      data	  : integer;
	   end;

procedure init(var root	:TTree );
begin
   root:=nil;
end; { init }

function createnode(const int :integer ):TTree;
var p : TTree;
begin
   new(p);
   with p^ do begin
      init(left);
      init(right);
      data:=int;
   end;
   createnode:=p;
end; { createnode }

procedure insert(var root : TTree; const int:integer);
begin
   if root = nil then root:=createnode(int)
   else
      with root^ do
	 if int > data then insert(left, int)
	 else
	    if int < data then insert(right, int);	       
end; { insert }


procedure input(var tree : TTree);
var
   k : integer;
begin
   readln(k);
   while k>=0 do begin
      insert(tree, k);
      readln(k);
   end;
end; { input }

procedure free(var tree	:TTree );
begin
   if tree <> nil then begin
      free(tree^.left);
      free(tree^.right);
      dispose(tree);
   end;
end; { free }
procedure print(var tree : TTree );
{ in-degree }
begin
   if tree <> nil then begin
      print(tree^.left);
      write(tree^.data :4);      
      print(tree^.right);
   end;
end; { print }

function equal(const tree0, tree1 :TTree ):boolean;
{ pre-order }
begin
   if tree0 = tree1 then equal:=true else
      if (tree0 = nil) and (tree1 <> nil) then equal:=false else
	 if (tree1 = nil) and (tree0 <> nil) then equal:=false else
	    equal:=(( tree0^.data =  tree1^.data) and
		    equal(tree0^.left, tree1^.left) and
		    equal(tree0^.right, tree1^.right));
   
end; { equal }

var
   tree0, tree1	: TTree;
begin
   init(tree0);
   init(tree1);
   input(tree0);
   writeln('===');
   input(tree1);

   print(tree0);
   writeln();
   print(tree1);
   writeln();
   
   if equal(tree0, tree1) then writeln('=')
   else writeln('!=');

   free(tree0);
   free(tree1);
end.