#include <fstream>
using namespace std;

struct Punct {
    long long x, y;
};

long long cross(Punct A, Punct B, Punct C) {
    // (B - A) x (C - A)
    // > 0 : C este la stanga lui AB
    // < 0 : C este la dreapta lui AB
    return (B.x - A.x) * (C.y - A.y) - (B.y - A.y) * (C.x - A.x);
}

long long dist2(Punct A, Punct B) {
    long long dx = B.x - A.x;
    long long dy = B.y - A.y;
    return dx * dx + dy * dy;
}

int main() {
    const int MAXN = 2000;
    Punct p[MAXN];
    int hull[MAXN];
    int n;

    ifstream fin("infasuratoare.in");
    ofstream fout("infasuratoare.out");

    fin >> n;
    for (int i = 0; i < n; i++)
        fin >> p[i].x >> p[i].y;

    if (n == 0) return 0;
    if (n == 1) {
        fout << 1 << "\n" << p[0].x << " " << p[0].y << "\n";
        return 0;
    }

    // 1) P0 = punctul cel mai de JOS (la egalitate, cel mai din STANGA)
    int start = 0;
    for (int i = 1; i < n; i++) {
        if (p[i].y < p[start].y || (p[i].y == p[start].y && p[i].x < p[start].x))
            start = i;
    }

    // 2) Jarvis March (Gift Wrapping) - construim in sens TRIGONOMETRIC
    int k = 0;
    int cur = start;
    do {
        hull[k++] = cur;

        int next = (cur == 0 ? 1 : 0);
        for (int i = 0; i < n; i++) {
            if (i == cur) continue;

            long long c = cross(p[cur], p[next], p[i]);

            // daca p[i] e mai "la STANGA" decat p[next], schimbam next (sens trigonometric)
            if (c > 0) next = i;
            // daca sunt coliniare, il luam pe cel mai departat
            else if (c == 0 && dist2(p[cur], p[i]) > dist2(p[cur], p[next]))
                next = i;
        }

        cur = next;
    } while (cur != start);

    fout << k << "\n";
    for (int i = 0; i < k; i++)
        fout << p[hull[i]].x << " " << p[hull[i]].y << "\n";

    return 0;
}