Program TOI;
uses crt;

Var Input, Output: text;

 { * MATRICY * }
    MS: Array [1..20,1..20] of integer; { // matrica smezhnosti }
    MI: Array [1..20,1..400] of LongInt; { // matrica incidentnosti }
    MSb: Array [1..20,1..20] of integer; { // poluchennaya MS }
    MD: Array [1..20,1..20] of integer; { // matrica dostizhimosti}

 { * GLOBALNYE PEREMENNYE *}
    i, j: integer;
    N: integer; { // chislo vershin }
    E: integer; { // chislo dug ili reber }
    WhatKind: integer; { // kakoj graf: orient. ili neorient.}

{ ===================== BEGIN: PROCEDURY ===================== }

{
  =====================
    Chtenie matricy smezhnosti
  =====================
}
Procedure ReadMS;
Var i,j: integer;
BEGIN
E:=0;
for i:=1 to N do
    for j:=1 to N do
        begin
          Read(Input,MS[i,j]);
          if (MS[i,j]=1) then E:=E+1;
        end;
END;

{
  =====================
    Vyvod matricy na ekran
  =====================
}
Procedure PrintMS;
Var i,j: integer;
BEGIN
for i:=1 to N do
    begin
    for j:=1 to N do
        begin
           Write('   ',MS[i,j]);
        end;
    WriteLn;
    end;
END;

{
  =====================
    Proverka grafa na neorientirovannost
  =====================
}
Function IsGrafNeor:boolean;
Var i,j: integer;
    count: integer;
BEGIN
IsGrafNeor:=FALSE;
count:=0;
for i:=1 to N do
    for j:=1 to N do
           if (MS[i,j]=1) then
               if (MS[j,i]=1) then inc(count);
if (count=E) then IsGrafNeor:=TRUE;
END;


{
  =====================
    Poluchenie matricy incidentnosti
  =====================
}
Procedure BuildMI;
Var i,j: integer;
BEGIN
case WhatKind of
     0:
     begin { // !!! OF CASE = 0 }
          E:=0; { // obnulyaem chislo dug }
          for i:=1 to N do
              for j:=1 to N do
                  if (MS[i,j] = 1) then
                     begin
                          E:=E+1; { // nashli dugu }
                          MI[i,E]:=1;
                          MI[j,E]:=-1;
                     end;

          for i:=1 to N do
              begin
                   for j:=1 to E do
                       begin
                            if(MI[i,j]<0) then Write('  ',MI[i,j])
                            else Write('   ',MI[i,j]);
                       end;
                   WriteLn;
              end;
     end; { // !!! OF CASE = 0 }

     1:
     begin { // !!! OF CASE = 1 }
          WriteLn('[x] Under Construction');
     end; { // !!! OF CASE = 1 }
END;


{
  =====================
    Poluchenie matricy smezhnosti
  =====================
}
Procedure BuildMS;
Var i,j: integer;
    StartOfEdge, EndOfEdge: integer; { // nachalo i konec dugi}
BEGIN
case WhatKind of
     0:
     begin { // !!! OF CASE = 0 }
           for j:=1 to E do
               begin
                    for i:=1 to N do
                        begin
                             if (MI[i,j] = 1) then StartOfEdge:=i;
                             if (MI[i,j]= -1) then EndOfEdge:=i;
                        end;
                    MSb[StartOfEdge,EndOfEdge]:=1;
               end;

           for i:=1 to N do
               begin
                    for j:=1 to N do
                        begin
                             Write('   ',MSb[i,j]);
                        end;
                    WriteLn;
                    end;
     end; { // !!! OF CASE = 0 }

     1:
     begin { // !!! OF CASE = 1 }
           WriteLn('[x] Under Construction');
     end; { // !!! OF CASE = 1 }
END;


{ ===================== END: PROCEDURY ===================== }



Begin
ClrScr;
Assign(Input,'Pract.txt'); Reset(Input); {otkryvaem fail s matricoj smezhnosti}

ReadLn(Input,N);

{ * BEGIN: CHTENIE MATRICY SMEZHNOSTI * }
WriteLn('---------------------------------------------------------------');
WriteLn('    I. MATRICA SMEZHNOSTI.');
WriteLn('---------------------------------------------------------------');
ReadMS; { // chitaem matricu smezhnosti }
PrintMS; { // vyvod matricy smezhnosti na ekran }
WriteLn;
   if (IsGrafNeor) then
      begin
           WhatKind:=1; { // neorientirovannyj graf }
           WriteLn('       <-->');
      end
   else
       begin
           WhatKind:=0; { // graf orientirovannyj }
           WriteLn('       --->');
       end;
WriteLn;
{ * END: CHTENIE MATRICY SMEZHNOSTI * }

{ * BEGIN: POLUCHENIE MATRICY INCIDENTNOSTI * }
WriteLn('---------------------------------------------------------------');
WriteLn('   II. MATRICA INCIDENTNOSTI.');
WriteLn('---------------------------------------------------------------');
BuildMI; { // vyzov procedury polucheniya matricy incidentnosti }
WriteLn;
{ * END: POLUCHENIE MATRICY INCIDENTNOSTI * }

{ * BEGIN: POLUCHENIE MATRICY SMEZHNOSTI * }
WriteLn('---------------------------------------------------------------');
WriteLn('  III. MATRICA SMEZHNOSTI.');
WriteLn('---------------------------------------------------------------');
BuildMS; { // vyzov procedury polucheniya matricy smezhnosti }
WriteLn;
{ * END: POLUCHENIE MATRICY SMEZHNOSTI * }

Close(Input);
ReadLn;
End.