uses crt;

type rec_pointer = ^rec;

     rec = record
      edit:Integer;
      next: rec_pointer;
     end;


procedure clear(f_in,f_out:rec_pointer;ex1,ex2:integer);
var time:integer;
    curr_rec,next_rec:rec_pointer;
begin
   next_rec:=f_in;
   for time:= 1 to ex2 do
   begin
      curr_rec:=next_rec;
      if next_rec^.next <> nil then
         next_rec:=next_rec^.next;
      dispose (curr_rec);
   end;

   next_rec:=f_out;
   for time:= 1 to ex1 do
   begin
      curr_rec:=next_rec;
      if next_rec^.next <> nil then
         next_rec:=next_rec^.next;
      dispose (curr_rec);
   end;
end;


var inp,outp,ext1,ext2:text;
    n,k,miss,i,num,time,ex1,ex2,max,main_out:integer;
    curr_rec_in,curr_rec_out,new_rec,first_rec_in,first_rec_out:rec_pointer;

begin
 clrscr;
 assign (inp,'inp.txt');
 assign (outp,'outp.txt');
{ assign (ext1,'ext1.txt');
 assign (ext2,'ext2.txt'); }
 rewrite (outp);
{ rewrite (ext1);
  rewrite (ext2);}
 reset(inp);



 read(inp,n);
 k:=n;
 reset(inp);
 miss:=-2;

 for i:= 1 to n-1 do
 begin
    for time:= 1 to i+1 do
    begin
       read (inp,num);
       inc(miss);
    end;
    max:=num;
    for time:= i to n-1 do
    begin
       read (inp,num);
       if num<=max then
        inc(miss);
    end;
    if miss<k then
    begin
       reset(inp);
       main_out:=miss;
     { rewrite(ext1);
       rewrite(ext2); }
       ex1:=0; ex2:=0;

       read (inp,num);
       k:=miss;
       for time:=1 to i-1 do
       begin
          read (inp,num);

          if ex1= 0 then
          begin
             new (new_rec);
             first_rec_out:=new_rec;
             curr_rec_out:=new_rec;
             curr_rec_out^.edit:=num;
             curr_rec_out^.next:=nil;
          end else
          begin
             new (new_rec);
             curr_rec_out^.next:=new_rec;
             curr_rec_out:=new_rec;
             curr_rec_out^.edit:=num;
             curr_rec_out^.next:=nil;
          end;

       {  writeln(ext1,num); }

          inc(ex1)
       end;
       read (inp,num);
       max:=num;
       new (new_rec);
       first_rec_in:=new_rec;
       curr_rec_in:=new_rec;
       curr_rec_in^.edit:=num;
       curr_rec_in^.next:=nil;

      { writeln (ext2,num);  }

       inc(ex2);
       for time:= i to n-1 do
       begin
          read (inp,num);
          if num>max then
          begin
             new(new_rec);
             curr_rec_in^.next:=new_rec;
             curr_rec_in:=new_rec;
             curr_rec_in^.edit:=num;
             curr_rec_in^.next:=nil;

        {    writeln (ext2,next); }

             inc (ex2);
          end else
          begin
             if ex1= 0 then
             begin
                new (new_rec);
                first_rec_out:=new_rec;
                curr_rec_out:=new_rec;
                curr_rec_out^.edit:=num;
                curr_rec_out^.next:=nil;
             end else
             begin
                new (new_rec);
                curr_rec_out^.next:=new_rec;
                curr_rec_out:=new_rec;
                curr_rec_out^.edit:=num;
                curr_rec_out^.next:=nil;
             end;
          {   writeln (ext1,next); }
             inc (ex1);
          end;
       end;
    end;


    miss:=-2;
    reset (inp);
 end;

{reset (ext1);
 reset (ext2); }

 curr_rec_in:=first_rec_in;
 curr_rec_out:=first_rec_out;
 for time:= 1 to ex2 do
 begin
    num:=curr_rec_in^.edit;

   { read (ext2,num); }

    write (outp,num,' ');
    curr_rec_in:=curr_rec_in^.next;
 end;
 writeln(outp);
 writeln(outp,main_out);
 for time:= 1 to ex1 do
 begin
    num:=curr_rec_out^.edit;

   { read (ext1,num); }

    write (outp,num,' ');
    curr_rec_out:=curr_rec_out^.next;
 end;

 clear (first_rec_in,first_rec_out,ex1,ex2);

 close(inp);
{close(ext1);
 close(ext2); }
 close(outp);
end.