uses {HeapTrc,} stack;
(*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_rec(const tree : TTree );
{ in-degree }
begin
   if tree <> nil then begin
      print_rec(tree^.left);
      write(tree^.data :4);      
      print_rec(tree^.right);
   end;
end; { print_rec }

procedure print(const tree : TTree );
var
   S : LIFO;
   p : TTree;
begin
   p := tree;
   stack.init(S);
   push(S, p);
   while not(isEmpty(S)) do begin
      p:=pop(S);
      if p<> nil then begin
	 write(p^.data:4);
	 push(S, p^.left);
	 push(S, p^.right);
      end;
   end;
end; { print }

function q(const tree0, tree1 : TTree ):boolean;
var
   S0, S1 : LIFO;
   p0, p1 : TTree;
   b	  : boolean;
begin
   b:=true;
   
   stack.init(S0);
   stack.init(S1);
   
   p0:=tree0;
   p1:=tree1;
   
   push(S0, p0);
   push(S1, p1);
   
   while b and not(isEmpty(S1) and isEmpty(S0) ) do begin
      p0:=pop(S0);
      p1:=pop(S1);
      if p0^.data = p1^.data then begin   
	 if ((p0^.left = nil) xor  (p1^.left = nil)) then b:=false else
	    if (p0^.left <> nil) and  (p1^.left <> nil) then begin
		  push(S1, p1^.left);  push(S0, p0^.left);
	       end;
	 
	 if b then if   ((p0^.right = nil) xor  (p1^.right = nil)) then b:=false else
	    if (p0^.right <> nil) and  (p1^.right <> nil)then  begin
		  push(S1, p1^.right);  push(S0, p0^.right);
	       end;	    
      end else b:=false;
   end;
   q:=b and isEmpty(S1) and isEmpty(S0);
   stack.free(S0);
   stack.free(S1);
end;   { q }
var
   tree0, tree1	: TTree;
begin
   init(tree0);
   init(tree1);
   input(tree0);
   writeln('===');
   input(tree1);

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

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