#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>

using namespace std;

int main() {
    int n;
    double all = 0;
    cin >> n;
    if (n != 0) {
        vector<double> x, y;
        for (int i = 0; i < n; ++i) {
            double q, w;
            cin >> q >> w;
            x.push_back(q);
            y.push_back(w);
        }
        vector<int> visited(n, 0), way, distance;
        way.push_back(0);
        visited[0] = 1;
        int o = 0;
        for (int i = 1; i < n; ++i) {
            double dist = 1000000000000000000;
            int nearest;
            for (int j = 0; j < n; ++j) {
                if (visited[j] == 0) {
                    double newDist = sqrt((x[o] - x[j]) * (x[o] - x[j]) +
                                          (y[o] - y[j]) * (y[o] - y[j]));
                    if (newDist < dist) {
                        dist = newDist;
                        nearest = j;
                    }
                }
            }
            way.push_back(nearest);
            distance.push_back(dist);
            all += dist;
            visited[nearest] = 1;
            o = nearest;
        }
        distance.push_back(sqrt((x[o] - x[0]) * (x[o] - x[0]) +
                                (y[o] - y[0]) * (y[o] - y[0])));
        all += sqrt((x[o] - x[0]) * (x[o] - x[0]) + (y[o] - y[0]) * (y[o] - y[0]));
        way.push_back(0);
        for (int flag = 0; flag < 35; ++flag) {
            for (int i = 0; i < n - 1; ++i) {
                for (int j = 0; j < n - 1; ++j) {
                    double dFirst = sqrt((x[way[i]] - x[way[j]]) * (x[way[i]] - x[way[j]]) +
                                         (y[way[i]] - y[way[j]]) * (y[way[i]] - y[way[j]]));
                    double dSecond = sqrt((x[way[i + 1]] - x[way[j + 1]]) *
                                          (x[way[i + 1]] - x[way[j + 1]]) +
                                          (y[way[i + 1]] - y[way[j + 1]]) *
                                          (y[way[i + 1]] - y[way[j + 1]]));
                    if (distance[i] + distance[j] > dFirst + dSecond) {
                        double newAll = all;
                        vector<int> newWay = way;
                        newAll -= distance[i] - distance[j + 1];
                        newAll += sqrt((x[way[i]] - x[way[j + 1]]) * (x[way[i]] - x[way[j + 1]]) +
                                       (y[way[i]] - y[way[j + 1]]) * (y[way[i]] - y[way[j + 1]]));
                        newAll += sqrt((x[way[i + 1]] - x[way[j + 2]]) *
                                       (x[way[i + 1]] - x[way[j + 2]]) +
                                       (y[way[i + 1]] - y[way[j + 2]]) *
                                       (y[way[i + 1]] - y[way[j + 2]]));
                        reverse(&newWay[i + 1], &newWay[j + 1]);
                        if (newAll < all) {
                            all = newAll;
                            way = newWay;
                        }
                    }
                }
            }
        }
        for (int i = 0; i < n + 1; ++i) {
            cout << way[i] + 1 << ' ';
        }
    }
    return 0;
}