#include <iostream>
#include <fstream>
#include <algorithm>
#include <math.h>
#include <cmath>
#include <stack>
#include <iomanip>
#define dMAX 120000
#define PI 3.14159265359

using namespace std;

int n;

struct Point{
    int idx;
    double x, y;
} arr[dMAX + 2];

double angles[dMAX + 2];

int h;
Point myStack[dMAX + 2];
Point pVerif, newP;

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

double Angle(Point p, Point q) {
    double dx, dy;
    dy = q.y - p.y;
    dx = q.x - p.x;
    double c = atan2(dy, dx);
    if (dx <= 0 && dy < 0) c = 2 * PI + atan2(dy, dx);
    if (dx > 0  && dy < 0) c = 2 * PI + atan2(dy, dx);
    return c;
}

bool CompareY(Point p, Point q) {
    if (p.y == q.y) return p.x < q.y;
    return p.y < q.y;
}

bool CompareA(Point p, Point q) {
    //return angles[p.idx] < angles[q.idx];
    //return Angle(arr[p.idx], arr[1]) < Angle(arr[q.idx], arr[1]);
    return Angle(p, arr[1]) < Angle(q, arr[1]);
}

bool Colinear(Point p, Point q, Point r) {
    return (p.y - q.y) * (r.x - q.x) - (p.x - q.x) * (r.y - q.y) == 0;
}

bool CounterClockwiseTurn(Point p, Point q, Point r) {
    if (Colinear(p, q, r)) return true;
    return (p.x * q.y + q.x * r.y + r.x * p.y
          - p.x * r.y - q.x * p.y - r.x * q.y > 0);
}

int main()
{
    int i, j;
    fin >> n;
    for (i = 1; i <= n; i++) {
        fin >> arr[i].x >> arr[i].y;
        arr[i].idx = i;
    }

    sort(arr + 1, arr + 1 + n, CompareY);

    /*for (i = 1; i <= n; i++) {
        angles[i] = Angle(arr[i], arr[1]);
    }*/

    sort(arr + 1, arr + 1 + n, CompareA);

    myStack[++h] = arr[1];
    myStack[++h] = arr[2];
    for (i = 3; i <= n; i++) {
        pVerif = arr[i];
        if (CounterClockwiseTurn(myStack[h - 1], myStack[h], pVerif)) {
            myStack[++h] = pVerif;
        } else {
            while (!CounterClockwiseTurn(myStack[h - 1], myStack[h], pVerif) && h >= 2) {
                h--;
            }
            myStack[++h] = pVerif;
        }
    }
    fout << h << '\n';
    for (i = 1; i <= h; i++) fout << setprecision(6) << fixed <<  myStack[i].x << ' ' << myStack[i].y << '\n';
    return 0;
}