Const
  n = 8;

Type
  TType = Integer;
  arrType = Array[1 .. n] Of TType;

Const
  a: arrType =
       (44, 55, 12, 42, 94, 18, 6, 67);


Procedure HeapSort(Var source, sorted: arrType);

  Procedure SwapIndex(i, j: Integer);
    Var
      T: TType;
    Begin
      move(sorted[i], T, SizeOf(TType));
      move(sorted[j], sorted[i], SizeOf(TType));
      move(T, sorted[j], SizeOf(TType));
    End;

  Var
    i, Left, Right: integer;
    x: TType;

  Procedure sift;
    Var
      i, j: Integer;
    Begin
      i := Left; j := 2*i; x := sorted[i];
      While j <= Right Do
        Begin
          If j < Right Then
            If sorted[j] < sorted[Succ(j)] Then Inc(j);

          If x >= sorted[j] Then Break;
          sorted[i] := sorted[j];
          i := j; j := 2 * i
        End;

      sorted[i] := x
    end;

  Begin
    move(source, sorted, SizeOf(arrType));

    Left := Succ(n div 2); Right := n;
    While Left > 1 Do
      Begin
        Dec(Left); sift
      End;

    While Right > 1 Do
      Begin
        {
        x := sorted[l]; sorted[l] := sorted[r]; sorted[r] := x;
        }
        SwapIndex(Left, Right);
        Dec(Right); sift
      End
  End;


Var
  b: arrType;

Begin
  HeapSort(a, b);
End.