PROCEDURE POLSORT(VAR TAPE :DUMP; VAR X :INTEGER);
  TYPE
    BLOCK=ARRAY [1..6] OF INTEGER;
    DUMP =PACKED ARRAY [0..3] OF TEXT;

  VAR
    ONE_RUN:BOOLEAN;
    N,M,K,L:INTEGER;
    I,J:ARRAY [1..2] OF INTEGER;
    C:BLOCK;
    T:ARRAY [1..4,1..39] OF INTEGER;
    P:ARRAY [1..4] OF INTEGER;
    CCC : INTEGER;


PROCEDURE SORT(VAR C:BLOCK; NUM:INTEGER);
  VAR
    I,J:INTEGER;
    MEMO:INTEGER;
  BEGIN
    FOR I:=2 TO NUM DO
      FOR J:=NUM DOWNTO I DO
        IF C[J-1]>C[J] THEN
          BEGIN
            MEMO:=C[J-1];
            C[J-1]:=C[J];
            C[J]:=MEMO;
          END
  END;

PROCEDURE MGSORT(VAR TAPE1,TAPE2,TAPE3 :TEXT);
  VAR
    A,B :INTEGER;
  BEGIN
    READ(TAPE1,A);
    READ(TAPE2,B);
    WHILE NOT(EOLN(TAPE1) OR EOLN(TAPE2)) DO
      IF A < B THEN
        BEGIN
          WRITE(LST,TAPE3,A:8);
          READ(TAPE1,A)
        END
      ELSE
        BEGIN
          WRITE(LST,TAPE3,B:8);
          READ(TAPE2,B)
        END;
    IF EOLN(TAPE1) THEN
      WHILE NOT EOLN(TAPE2) DO
        BEGIN
          WRITE(LST,TAPE3,B:8);
          READ(TAPE2,B)
        END
    ELSE
      WHILE NOT EOLN(TAPE1) DO
        BEGIN
          WRITE(LST,TAPE3,A:8);
          READ(TAPE1,A)
        END;
    READLN(TAPE1);
    READLN(TAPE2);
    WRITELN(LST,TAPE3,0:8)
  END;

BEGIN
  ASSIGN(TAPE[0],'B:TAPE0.CPO');
  RESET(TAPE[0]);
  REWRITE(TAPE[2]);
  REWRITE(TAPE[3]);
  L:=2;
  REPEAT
    N:=1;
    FOR M:=1 TO 6 DO C[M]:=0;
    REPEAT
      READ(TAPE[0],C[N]);
      N:=N+1
    UNTIL (N>6) OR (EOF(TAPE[0]));
    SORT(C,N-1);
    FOR K:=1 TO N-1 DO WRITE(TAPE[L],C[K]:8);
    WRITELN(LST,TAPE[L],0:8);
    L:=5-L;
  UNTIL EOF(TAPE[0]);

{--------- END OF FIRST PHASE ----------------}

  I[1]:=2;
  I[2]:=3;
  J[1]:=0;
  J[2]:=1;

  REPEAT
    FOR M:=0 TO 3 DO CLOSE(TAPE[M]);
    FOR M:=1 TO 2 DO
      BEGIN
        RESET(TAPE[I[M]]);
        REWRITE(TAPE[J[M]])
      END;
    MGSORT(TAPE[I[1]],TAPE[I[2]],TAPE[J[1]]);
    ONE_RUN:=EOF(TAPE[I[1]]) AND EOF(TAPE[I[2]]);
    IF NOT ONE_RUN THEN
      BEGIN
        MGSORT(TAPE[I[1]],TAPE[I[2]],TAPE[J[2]]);
        WHILE NOT(EOF(TAPE[I[1]]) AND EOF(TAPE[I[2]])) DO
          BEGIN
            MGSORT(TAPE[I[1]],TAPE[I[2]],TAPE[J[1]]);
            MGSORT(TAPE[I[1]],TAPE[I[2]],TAPE[J[2]]);
          END;
        I[1]:=I[1] + 2;
        I[2]:=I[2] + 2;
        J[1]:=J[1] + 2;
        J[2]:=J[2] + 2;
        I[1]:=I[1] MOD 4;
        I[2]:=I[2] MOD 4;
        J[1]:=J[1] MOD 4;
        J[2]:=J[2] MOD 4;
      END;
  UNTIL ONE_RUN;
  FOR M:=0 TO 3 DO CLOSE(TAPE[M]);
  X := J[1]
END;