type a2=array[0..1] of real;   // тип пара координат
const n=10;                    // кількість точок
const a: array[0..n-1] of a2 = // координати точок
((110, 66), (88,108), (88, 30), (85, 83), (60, 72),
  (53, 45), (32, 72), (39,108), (11, 58), (25,  8));
// ((0, 0),  (4, 4),   (8, 8),   (2, 2));

var start, ns, i, j, k: word;     y,l,r: word;  dk: real;
    p, s: array[0..n-1] of word;    // стек
    line: boolean;

function rotate (a,b,c: a2): real;
begin rotate:=(b[0]-a[0])*(c[1]-b[1])
             -(b[1]-a[1])*(c[0]-b[0]);
end;

// lt справджується, якщо P[j] має бути до P[k]
function lt(k,j: word): boolean;
  var x: real;
BEGIN
  x := rotate (a[start],a[P[k]],a[P[j]]);
  if (x<0)   then lt:=true  else
  if (x>0)   then lt:=false else
  if abs(a[start][0]-a[P[j]][0]) + abs(a[start][1]-a[P[j]][1])
   > abs(a[start][0]-a[P[k]][0]) + abs(a[start][1]-a[P[k]][1])
  then lt:=true
  else lt:=false;
END;

function gt(k,j: word): boolean;
  var x: real;
BEGIN
  x := rotate (a[start],a[P[k]],a[P[j]]);
  if (x<0)   then gt:=false else
  if (x>0)   then gt:=true  else
  if abs(a[start][0]-a[P[j]][0]) + abs(a[start][1]-a[P[j]][1])
   < abs(a[start][0]-a[P[k]][0]) + abs(a[start][1]-a[P[k]][1])
  then gt:=true
  else gt:=false;
END;

procedure qSort(l,r: word);
var i,j,k,y: word;
BEGIN
                          // 2. Упорядкування
                          // якщо масив порожній або одноелементний,
                          // тобто немає що упорядковувати, …
  k:=l+random(r-l+1);     // випадковим чином вибрати номер елемента
                          // масиву, щоб уникнути переповнення стеку
                          // при упорядкованих даних
  i := l;
  j := r;
  while i<=j do
  begin while lt(k,i) do inc(i);
        while gt(k,j) do dec(j);
        if i<=j then
        begin y:=P[i];
                 P[i]:=P[j];
                       P[j]:=y;
              inc(i);
              dec(j);
        end
  end;
  if l<j then qsort(l,j);
  if i<r then qsort(i,r);
END;

function decs (i: word): boolean;
BEGIN
  if (ns=0) then decs:=false
            else decs:=(rotate(a[s[ns-1]],a[s[ns]],a[P[i]])<0);
END;

BEGIN
  for j:=0 to n-1 do p[j]:=j;
  j:=0;
  for i:=1 to n-1 do         // 1. Пошук стартової точки
    if ((a[P[i]][0] <  a[P[j]][0]) or
       ((a[P[i]][0] = a[P[j]][0]) and (a[P[i]][1] < a[P[j]][1])))
    then j:=i;
  start:=P[j];
         P[j]:=P[0];
               P[0]:=start;
  randomize;
  qsort(1,n-1);       // 2. Упорядкування даних точок
  s[0]:=start;        //    Cтворення стеку s
  s[1]:=p[1];
  ns:=1;
  line:=true;        // 3. Перевірка розташування точок на одній прямій
  for i:=2 to n-1 do
  begin
    line:=line and (rotate(a[0],a[1],a[i])=0);
    if (not line) then break;
  end;
  write(s[0]);
  if (line) then writeln(' ',s[1]) else
  begin
    for i:=2 to n-1 do  // 4. Видалення з переліку вершин тих,
                        //    в яких внутрішній кут отриманого
                        //    много­кутника більший від розгорнутого
    begin
      while decs(i) do dec(ns);
      inc(ns);
      s[ns]:=p[i]
    end;
    for i:=1 to ns do write(' ',s[i]);
    writeln;
  end
END.