#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <fstream>
#include <iterator>
#include <random>
#include <assert.h>
using namespace std;

const string file = "infasuratoare";

const string infile = file + ".in";
const string outfile = file + ".out";

const int INF = 0x3f3f3f3f; 

//#define ONLINE_JUDGE

struct Point
{
    double x;
    double y;
};

double cross(const Point& a, const Point& b)
{
    return a.x * b.y - a.y * b.x;
}

Point translate(const Point& a, const Point& b)
{
    Point res;
    res.x = a.x - b.x;
    res.y = a.y - b.y;
    return res;
}

double dist(const Point& a, const Point& b)
{
    double x = a.x - b.x;
    double y = a.y - b.y;
    return sqrt(x * x + y * y);
}

struct SortPred
{
    SortPred(Point p)
    {
        this->p = p;
    }
    bool operator()(const Point& a, const Point& b)
    {

        Point x = translate(a, p);
        Point y = translate(b, p);

        double val1 = x.y / x.x;
        double val2 = y.y / y.x;

        if(val1 < val2)
            return true;
        if(val1 > val2)
            return false;
        return dist(a, p) < dist(b, p);
    }

    Point p;
};

int main()
{
#ifdef ONLINE_JUDGE
	ostream &fout = cout;
	istream &fin = cin;
#else
	fstream fin(infile.c_str(), ios::in);
	fstream fout(outfile.c_str(), ios::out);
#endif	

    int N;
    fin >> N;
    vector<Point> points(N);
    int mini = 0;
    for(int i = 0; i < N; i++)
    {
        fin >> points[i].x >> points[i].y;
        if(points[i].x < points[mini].x)
        {
            mini = i;
        }
        else if(points[i].x == points[mini].x)
        {
            if(points[i].y < points[mini].y)
                mini = i;
        }
    }

    swap(points[0], points[mini]);

    sort(points.begin() + 1, points.end(), SortPred(points[0]));

    vector<int> convexHull;
    convexHull.reserve(N);

    for(int i = 0; i < N; i++)
    {
        while(convexHull.size() >= 2)
        {
            int last = convexHull.size() - 1;
            Point O = points[convexHull[last - 1]];
            Point A = translate(points[convexHull[last]], O);
            Point B = translate(points[i], O);

            double val = cross(A, B);
            if(val > 0)
                break;
            convexHull.pop_back();
        }

        convexHull.push_back(i);
    }

    fout << convexHull.size() << "\n";

    for(vector<int>::iterator itr = convexHull.begin();
            itr != convexHull.end();
            itr++)
    {
        Point& p = points[*itr];
        fout << setiosflags(ios::fixed) << setprecision(6) << p.x << " " << p.y << "\n";
    }

#ifdef ONLINE_JUDGE
#else
    fout.close();
	fin.close();
#endif
}