#include <iostream>
#include <sstream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <map>


using namespace std;



struct point{
    int x, y;
    point(){}
    point(int _x, int _y) {
        x = _x;
        y = _y;
    }
};


inline bool operator < (const point a, const point b) {
    return a.x < b.x || (a.x == b.x && a.y < b.y);
}


inline bool operator ==(const point a, const point b) {
    return a.x == b.x && a.y == b.y;
}


int n;
point p[102];
int dup[102][102], ddown[102][102];
int dup1[102], ddown1[102];
bool d[102][102][102];
pair<int, pair<int, int> > cc[102][102][102];
map<point, int> m;


int main() {
  //freopen("division.in", "r", stdin);freopen("division.out", "w", stdout);
    cin >> n;
    for (int i = 0; i < n; i++) {
        cin >> p[i].x >> p[i].y;
        m[p[i]] = i + 1;
    }
    sort(p, p + n);
    for (int i = 0; i < n; i++) {
        for (int j = i + 1; j < n; j++) {
            int a = p[i].y - p[j].y;
            int b = p[j].x - p[i].x;
            int c = -(a * p[i].x + b * p[i].y);
            for (int k = 0; k < n; k++) {
                if (p[k].x >= p[i].x && p[k].x < p[j].x) {
                    if (a * p[k].x + b * p[k].y + c > 0) {
                        dup[i][j]++;
                    }
                }
            }
            for (int k = 0; k < n; k++) {
                if (p[k].x >= p[i].x && p[k].x < p[j].x) {
                    if (a * p[k].x + b * p[k].y + c < 0) {
                        ddown[i][j]++;
                    }
                }
            }
            for (int k = 0; k < n; k++) {
                if (p[k].x > p[i].x && p[k].x < p[j].x) {
                    if (a * p[k].x + b * p[k].y + c == 0) {
                        ddown[i][j] = -200;
                        dup[i][j] = -200;
                    }
                }
            }
        }
        int a = 0;
        int b = 1;
        int c = -b * p[i].y;
        for (int k = 0; k < n; k++) {
            if (p[k].x < p[i].x) {
                if (a * p[k].x + b * p[k].y + c > 0) {
                    dup[i][i]++;
                }
            }
        }
        for (int k = 0; k < n; k++) {
            if (p[k].x < p[i].x) {
                if (a * p[k].x + b * p[k].y + c < 0) {
                    ddown[i][i]++;
                }
            }
        }
        for (int k = 0; k < n; k++) {
            if (p[k].x >= p[i].x) {
                if (a * p[k].x + b * p[k].y + c > 0) {
                    dup1[i]++;
                }
            }
        }
        for (int k = 0; k < n; k++) {
            if (p[k].x >= p[i].x) {
                if (a * p[k].x + b * p[k].y + c < 0) {
                    ddown1[i]++;
                }
            }
        }
    }
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= n - 1; j++) {
            for (int k = 0; k <= n - 1 - j; k++) {
                for (int g = i; g >= 0; g--) {
                    if (dup[g][i] >= 0 && j >= dup[g][i] && k >= ddown[g][i] && ((g != i && p[i].x > p[g].x) || (g == i))) {
                        if (d[i][j][k] < d[g][j - dup[g][i]][k - ddown[g][i]]) {
                            d[i][j][k] = d[g][j - dup[g][i]][k - ddown[g][i]];
                            cc[i][j][k] = make_pair(g, make_pair(j - dup[g][i], k - ddown[g][i]));
                        }
                    }
                }
                if (j == dup[i][i] && k == ddown[i][i]) {
                    d[i][j][k] = 1;
                    cc[i][j][k] = make_pair(-1, make_pair(-1, -1));
                }
            }
        }
    }
    int ans = 1000000000;
    int a = 0, b = 0, c = 0;
    vector<pair<point, int> > v;
    for (int i = 0; i < n; i++) {
        for (int j = 0; j <= n - 1; j++) {
            for (int k = 0; k <= n - 1 - j; k++) {
                if (d[i][j][k]) {
                    int j1 = j + dup1[i];
                    int k1 = k + ddown1[i];
                    if (ans > max(j1, max(k1, n - j1 - k1)) - min(j1, min(k1, n - j1 - k1))) {
                        ans = max(j1, max(k1, n - j1 - k1)) - min(j1, min(k1, n - j1 - k1));
                        //cout << ans << endl;
                      //cout << j << endl;
                        a = i;
                        b = j;
                        c = k;
                      //  cout << "aa";
                    }
                }
            }
        }
    }
   // cout << ans << endl;
    while (a > -1) {
        v.push_back(make_pair(p[a], m[p[a]]));
        pair<int, pair<int, int> > p = cc[a][b][c];
        a = p.first;
        b = p.second.first;
        c = p.second.second;
    }
    sort(v.begin(), v.end());
    int k = (int)v.size();
    for (int i = 0; i < n; i++) {
        if (p[i].y == v[0].first.y && p[i].x <= v[0].first.x) {
            v.push_back(make_pair(p[i], m[p[i]]));
        }
        if (p[i].y == v[k - 1].first.y && p[i].x >= v[k - 1].first.x) {
            v.push_back(make_pair(p[i], m[p[i]]));
        }
        if (i > 0) {
            int a = p[i - 1].y - p[i].y;
            int b = p[i].x - p[i - 1].x;
            int c = -(a * p[i].x + b * p[i].y);
            for (int j = 0; j < n; j++) {
                if (a * p[j].x + b * p[j].y + c == 0 && p[j].x > p[i - 1].x && p[j].x < p[i].x) {
                    v.push_back(make_pair(p[j], m[p[j]]));
                }
            }
        }
    }
    sort(v.begin(), v.end());
    v.resize(distance(v.begin(), unique(v.begin(), v.end())));
    cout << (int)v.size() << endl;
    for (int i = 0; i < (int)v.size(); i++) {
        cout << v[i].second << ' ';
    }
    cout << endl;
    return 0;
}