#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)
{
    return sqrt((a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y));
}

struct SortPredicate
{
    SortPredicate(const Point& p)
    {
        this->p = p;
    }
    bool operator()(const Point& a, const Point& b)
    {
        Point a0 = translate(a, p);
        Point b0 = translate(b, p);

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

        if(val1 < val2)
            return true;
        if(val1 > val2)
            return false;
        
        if(dist(a, p) < dist(b, p))
                return true;
        return false;
    }
    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(), SortPredicate(points[0]));


    vector<int> convexHull;
    convexHull.reserve(N);
    for(int i = 0; i < N; i++)
    {
        while(convexHull.size() >= 3)
        {
            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 c = cross(A, B);
            
            if(c < 0)
            {
                convexHull.pop_back();
            }
            else
            {
                break;
            }
        }
        convexHull.push_back(i);
    }

    fout << convexHull.size() << "\n";
    for(vector<int>::iterator itr = convexHull.begin();
            itr != convexHull.end();
            itr++)
    {

        fout << setiosflags(ios::fixed) << setprecision(6) << points[*itr].x << " " << points[*itr].y << "\n";
    }

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