#include <cstdio>
#include <vector>
#include <algorithm>
#include <cmath>
#include <set>
#include <iostream>
#include <cassert>
#include <cstring>
#include <map>

#define FOR(i,a,b) for (int i = (a); i < (b); ++i)
#define REP(i,n) FOR(i,0,n)

#define TRACE(x) cerr << #x << " = " << x << endl
#define _ << " _ " <<

#define pb push_back
#define x first
#define y second

using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<int, int> Pt;

// const double eps = 1e-9;

//inline bool lt(double a, double b) { return a + eps < b;}
//inline bool gt(double a, double b) { return lt(b, a);}

inline int sgn(ll w) { return w<0 ? -1 : w>0 ;}

const int MAX = 1<<18;
//struct Pt {
//  int x, y;
  // Pt operator+ (const Pt &b) { return {x + b.x, y + b.y};}
  // Pt operator- (const Pt &b) { return {x - b.x, y - b.y};}
  //  Pt operator* (const double &b) { return {x*b, y*b}; }
//} p[MAX];

// inline ll cross(const Pt &a, const Pt &b) {
  
// }

Pt p[MAX];

inline ll ccw(Pt a, Pt b, Pt c) {
  ll tmp = (ll) a.x * (b.y - c.y) + (ll) b.x * (c.y - a.y) + (ll) c.x * (a.y - b.y);
  return sgn(tmp);
  //return sgn(cross(b-a, c-a));
}

vector <Pt> convex_hull(vector <Pt> pts) {
  sort(pts.begin(), pts.end());
  vector <Pt> H;

  REP(step, 2) {
    auto start = H.size();
    for (Pt P : pts) {
      while(H.size() >= start + 2 && ccw(H[H.size()-2], H[H.size()-1], P) < 0)
	H.pop_back();
      H.push_back(P);
    }

    H.pop_back();
    reverse(pts.begin(), pts.end());
  }

  return H;
}

map <pii, int> Ind;
int na_h[MAX];
int ima[MAX];

int main(){
  ios_base::sync_with_stdio(false);

  int n;
  scanf("%d", &n);
  REP(i, n) {
    scanf("%d%d", &p[i].x, &p[i].y);
    Ind[pii(p[i].x, p[i].y)] = i;
  }

  vector <Pt> Hull = convex_hull(vector<Pt>(p, p+n));
  //  REP(i, n) na_h[i] = 1;
  for (auto it : Hull)
    na_h[Ind[it]] = 1;

  if ((int) Hull.size() == n) {
    printf("3 %d %d\n", n-2, n);
    return 0;
  }

  int mn = -1;
  REP(i, n) if (na_h[i]) { mn = i; break; }
  int ind_mn = -1;
  REP(i, (int) Hull.size()) if (Ind[Hull[i]] == mn) ind_mn = i;

  {
    //    TRACE(Hull.size() _ ind_mn);
    
    vector <Pt> Poc, Kraj;
    REP(i, ind_mn) Poc.push_back(Hull[i]);
    FOR(i, ind_mn, (int) Hull.size()) Kraj.push_back(Hull[i]);
    Hull.clear();
    for (auto it : Kraj) Hull.push_back(it);
    for (auto it : Poc) Hull.push_back(it);

    //    TRACE(Hull.size());
    

  }
    
  //  for (auto it : Hull) TRACE(it.x _ it.y);
  
  REP(i, n) {
    if (!na_h[i]) {
      int lo = 1, hi = (int) Hull.size()-1;
      for (; lo<hi; ) {
	int mid = (lo + hi + 1) / 2;
	if (ccw(Hull[0], Hull[mid], p[i]) >= 0)
	  lo = mid;
	else
	  hi = mid - 1;
      }

      ima[lo] = ima[lo+1] = 1;
    }
  }

  int nema = 0;
  FOR(i, 1, (int) Hull.size())
    nema += 1-ima[i];

  printf("4 %d %d\n", n - (int) Hull.size(), n - nema);
    
  return 0;
}