#include <bits/stdc++.h>

using namespace std;

const long double eps = 1e-8;
const long double pi = acos(-1);

template <typename T>
struct point {
    T x, y;
    point() : x(0), y(0) {}
    point(T _x, T _y) : x(_x), y(_y) {
        x = (x == 0 ? 0 : x);
        y = (y == 0 ? 0 : y);
    }
    long double len() {
        return hypot(x, y);
    }
    point operator+(const point b) const { return {x + b.x, y + b.y}; }
    point operator-(const point b) const { return {x - b.x, y - b.y}; }
    point operator*(T k) const { return {x * k, y * k}; }
    void normalize() {
        long double l = len();
        x /= l;
        y /= l;
    }
    friend istream& operator>>(istream& in, point& p) {
        in >> p.x >> p.y;
        return in;
    }
    friend ostream& operator<<(ostream& out, point& p) {
        out << p.x << ' ' << p.y;
        return out;
    }
    long double angle() {
        return atan2(y, x);
    }
    friend T operator*(point a, point b) { return a.x * b.x + a.y * b.y; }
    friend T operator%(point a, point b) { return a.x * b.y - a.y * b.x; }
};

using pt = point<long double>;

set<vector<int>> delaunay_triangulation(vector<pt> a) {
    int n = a.size();
    map<pair<int, int>, vector<int>> mp;
    auto dist = [&](pt x, pt y) {
        return pow(x.x - y.x, 2) + pow(x.y - y.y, 2);
    };
    auto key = [&](int x, int y) {
        if (x > y) {
            swap(x, y);
        }
        return make_pair(x, y);
    };
    auto remove_triangle = [&](int x1, int x2, int x3) {
        mp[key(x1, x2)].erase(find(mp[key(x1, x2)].begin(), mp[key(x1, x2)].end(), x3));
    };
    auto add_triangle = [&](int x1, int x2, int x3) {
        mp[key(x1, x2)].emplace_back(x3);
    };
    auto check = [&](int A, int B, int C, int D, vector<pt>& a) {
        long double z1 = (a[B] - a[A]) % (a[C] - a[B]);
        long double z2 = (a[C] - a[B]) % (a[D] - a[C]);
        long double z3 = (a[D] - a[C]) % (a[A] - a[D]);
        long double z4 = (a[A] - a[D]) % (a[B] - a[A]);
        return (z1 >= 0 && z2 >= 0 && z3 >= 0 && z4 >= 0) ||
               (z1 <= 0 && z2 <= 0 && z3 <= 0 && z4 <= 0);
    };

    int ind = min_element(a.begin(), a.end(), [&](auto l, auto r) { return l.y < r.y || (l.y == r.y && l.x < r.x); }) - a.begin();
    pt O = a[ind];
    for (int i = 0; i < n; ++i) {
        a[i] = a[i] - O;
    }

    vector<int> pos(n);
    iota(pos.begin(), pos.end(), 0);
    sort(pos.begin(), pos.end(), [&](auto l, auto r) {
        long double x = a[l].angle();
        long double y = a[r].angle();
        if (x == y) {
            return a[l].len() < a[r].len();
        }
        return x < y;
    });
    sort(a.begin(), a.end(), [&](auto l, auto r) {
        long double x = l.angle();
        long double y = r.angle();
        if (x == y) {
            return l.len() < r.len();
        }
        return x < y;
    });

    for (int i = 0; i < n; ++i) {
        a[i] = a[i] + O;
    }

    for (int i = 1; i < n - 1; ++i) {
        int x = 0, y = i, z = i + 1;
        mp[key(x, y)].emplace_back(z);
        mp[key(x, z)].emplace_back(y);
        mp[key(y, z)].emplace_back(x);
    }

    set<pair<int, int>> act;
    for (int i = 2; i < n - 1; ++i) {
        act.emplace(0, i);
    }

    vector<int> aa(n);
    iota(aa.begin(), aa.end(), 0);
    bool notconvex = true;
    while (notconvex) {
        vector<int> st;
        notconvex = false;
        st.emplace_back(aa[0]);
        st.emplace_back(aa[1]);
        for (int i = 2; i < aa.size(); ++i) {
            while (st.size() > 2 && (a[st[st.size() - 1]] - a[st[st.size() - 2]]) % (a[aa[i]] - a[st[st.size() - 2]]) < 0) {
                int x = st[st.size() - 1];
                int y = st[st.size() - 2];
                int z = aa[i];
                mp[key(x, y)].emplace_back(z);
                mp[key(x, z)].emplace_back(y);
                mp[key(y, z)].emplace_back(x);
                act.emplace(x, y);
                act.emplace(x, z);
                st.pop_back();
                notconvex = true;
            }
            st.push_back(aa[i]);
        }
        aa = st;
    }

    for (int i = 0; i < n && act.size(); ++i) {
        set<pair<int, int>> act2;
        for (auto u : act) {
            long double x1 = a[u.first].x;
            long double y1 = a[u.first].y;
            long double x2 = a[u.second].x;
            long double y2 = a[u.second].y;
            long double x3 = a[mp[key(u.first, u.second)][0]].x;
            long double y3 = a[mp[key(u.first, u.second)][0]].y;
            long double x4 = a[mp[key(u.first, u.second)][1]].x;
            long double y4 = a[mp[key(u.first, u.second)][1]].y;
            long double D = 2 * ((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1));
            long double X = ((x2 * x2 + y2 * y2 - x1 * x1 - y1 * y1) * (y3 - y1) -
                             (x3 * x3 + y3 * y3 - x1 * x1 - y1 * y1) * (y2 - y1)) /
                            D;
            long double Y = ((x3 * x3 + y3 * y3 - x1 * x1 - y1 * y1) * (x2 - x1) -
                             (x2 * x2 + y2 * y2 - x1 * x1 - y1 * y1) * (x3 - x1)) /
                            D;
            long double r = dist({X, Y}, {x1, y1});
            long double d = dist({X, Y}, {x4, y4});
            int z1 = u.first;
            int z2 = u.second;
            int z3 = mp[key(u.first, u.second)][0];
            int z4 = mp[key(u.first, u.second)][1];
            if (check(z1, z3, z2, z4, a) && (d < r - eps || D == 0)) {
                remove_triangle(z1, z4, z2);
                remove_triangle(z2, z4, z1);
                remove_triangle(z2, z3, z1);
                remove_triangle(z1, z3, z2);
                remove_triangle(z1, z2, z3);
                remove_triangle(z1, z2, z4);

                add_triangle(z1, z4, z3);
                add_triangle(z2, z4, z3);
                add_triangle(z2, z3, z4);
                add_triangle(z1, z3, z4);
                add_triangle(z3, z4, z1);
                add_triangle(z3, z4, z2);
                act2.emplace(z3, z4);
            } else {
                act2.emplace(z1, z2);
            }
        }
        act = act2;
    }
    set<vector<int>> ans;
    for (auto u : mp) {
        for (auto v : u.second) {
            vector<int> triangle = {pos[u.first.first], pos[u.first.second], pos[v]};
            sort(triangle.begin(), triangle.end());
            ans.insert(triangle);
        }
    }
    return ans;
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
#ifdef LOCAL
    freopen("in.txt", "r", stdin);
    freopen("out.txt", "w", stdout);
#endif
    int n;
    cin >> n;
    vector<pt> a(n);
    for (int i = 0; i < n; ++i) {
        cin >> a[i];
    }
    vector<pt> ap = a;
    set<vector<int>> d = delaunay_triangulation(a);
    for (auto i : d) {
        cout << "Polygon\n";
        for (auto j : i) {
            cout << a[j] << '\n';
        }
        cout << "...\n";
    }
    return 0;
}