PROCEDURE QUIKSORT(VAR SORTBUF : KEYARRAY;
                       RECS    : INTEGER);


PROCEDURE INT_SWAP(VAR RR,SS : KEYREC);

VAR T : KEYREC;

BEGIN
  T := RR;
  RR := SS;
  SS := T
END;


PROCEDURE DOSORT(LO, HI : INTEGER);

VAR I,J   : INTEGER;
    PIVOT : KEYREC;

BEGIN
  { Can't sort if LO is greater than or equal to HI... }
  IF LO < HI THEN
    BEGIN
      I := LO;
      J := HI;
      PIVOT := SORTBUF[J];
      REPEAT
        WHILE (I < J) AND (SORTBUF[I].KEY <= PIVOT.KEY) DO I := I + 1;
        WHILE (J > I) AND (SORTBUF[J].KEY >= PIVOT.KEY) DO J := J - 1;
        IF I < J THEN INT_SWAP(SORTBUF[I],SORTBUF[J]);
      UNTIL I >= J;
      INT_SWAP(SORTBUF[I],SORTBUF[HI]);
      IF (I - LO < HI - I) THEN
        BEGIN
          DOSORT(LO,I-1);    { Recursive calls to DOSORT! }
          DOSORT(I+1,HI)
        END
      ELSE
        BEGIN
          DOSORT(I+1,HI);    { Recursive calls to DOSORT! }
          DOSORT(LO,I-1)
        END
    END
END;


BEGIN
  DOSORT(1,RECS);
END;  { QUIKSORT }