#include <iostream>
#include <limits>
#include <cmath>
#include <cstdio>
#include <vector>
#include <algorithm>

using namespace std;

#define EPS (numeric_limits<double>::epsilon())
#define equals(a, b) (fabs((a) - (b)) < EPS)

class Point {
public:
    double x, y;

    Point(double x = 0, double y = 0) : x(x), y(y) {}

    Point operator+(const Point &p) const
    {
        return Point(x + p.x, y + p.y);
    }

    Point operator-(const Point &p) const
    {
        return Point(x - p.x, y - p.y);
    }

    Point operator*(const double &a) const
    {
        return Point(a * x, a * y);
    }

    Point operator/(const double &a) const
    {
        return Point(x / a, y / a);
    }

    double abs()
    {
        return sqrt(norm());
    }

    double norm()
    {
        return x * x + y * y;
    }

    bool operator<(const Point &p) const
    {
        return x != p.x ? x < p.x : y < p.y;
    }

    bool operator==(const Point &p) const
    {
        return equals(x, p.x) && equals(y, p.y);
    }
};

typedef Point Vector;

struct Segment {
    Point p1, p2;
};
typedef Segment Line;

struct Circle {
    Point c;
    double r;
};


double dot(Vector a, Vector b)
{
    return a.x * b.x + a.y * b.y;
}

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

bool isParallel(Vector a, Vector b)
{
    return equals(cross(a, b), 0.0);
}

bool isParallel(Point a1, Point a2, Point b1, Point b2)
{
    return equals(cross(a2 - a1, b2 - b1), 0.0);
}

bool isOrthogonal(Vector a, Vector b)
{
    return equals(dot(a, b), 0.0);
}

bool isOrthogonal(Point a1, Point a2, Point b1, Point b2)
{
    return equals(dot(a2 - a1, b2 - b1), 0.0);
}

Point project(Segment s, Point p)
{
    Vector hypo = p - s.p1;
    Vector base = s.p2 - s.p1;
    return base * (dot(hypo, base) / base.norm()) + s.p1;
}

Point reflect(Segment s, Point p)
{
    return (project(s, p) - p) * 2.0 + p;
}

double getDistance(Point a, Point b)
{
    return (a - b).abs();
}

double getDistanceLP(Line l, Point p)
{
    return abs(cross(l.p2 - l.p1, p - l.p1)) / (l.p2 - l.p1).abs();
}

double getDistanceSP(Segment s, Point p)
{
    if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
        return getDistance(p, s.p1);
    else if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
        return getDistance(p, s.p2);
    else
        return getDistanceLP(s, p);
}

static const int COUNTER_CLOCKWISE = 1;
static const int CLOCKWISE = -1;
static const int ONLINE_BACK = 2;
static const int ONLINE_FRONT = -2;
static const int ON_SEGMENT = 0;

int ccw(Point p0, Point p1, Point p2)
{
    Vector a = p1 - p0;
    Vector b = p2 - p0;
    if (cross(a, b) > 0.0)
        return COUNTER_CLOCKWISE;
    else if (cross(a, b) < 0.0)
        return CLOCKWISE;
    else if (dot(a, b) < 0.0)
        return ONLINE_BACK;
    else if (a.norm() < b.norm())
        return ONLINE_FRONT;
    else
        return ON_SEGMENT;
}

bool intersect(Point p0, Point p1, Point p2, Point p3)
{
    return ccw(p0, p1, p2) * ccw(p0, p1, p3) <= 0
           && ccw(p2, p3, p0) * ccw(p2, p3, p1) <= 0;
}

double getDistance(Segment s1, Segment s2)
{
    if (intersect(s1.p1, s1.p2, s2.p1, s2.p2))
        return 0.0;
    else
        return min(min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)),
                   min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2)));
}

Point getCrossPoint(Segment s1, Segment s2)
{
    double d1 = getDistanceLP(s2, s1.p1);
    double d2 = getDistanceLP(s2, s1.p2);
    double t = d1 / (d1 + d2);
    return s1.p1 + (s1.p2 - s1.p1) * t;
}

pair<Point, Point> CrossPoints(Circle c, Line l)
{
    Point foot = project(l, c.c);
    double scale = sqrt(c.r * c.r - (foot - c.c).norm());
    Vector e = (l.p2 - l.p1) / (l.p2 - l.p1).abs();
    return make_pair(foot + e * scale, foot - e * scale);
}

pair<Point, Point> getRotatePoints(Point x, Point center, double cosine)
{
    double sine = sqrt(1 - cosine * cosine);
    Vector v = x - center;
    Vector u, u_inv;
    u.x = cosine * v.x - sine * v.y;
    u.y = sine * v.x + cosine * v.y;
    u_inv.x = cosine * v.x + sine * v.y;
    u_inv.y = -sine * v.x + cosine * v.y;
    return make_pair(u + center, u_inv + center);
}

pair<Point, Point> getCrossPoints(Circle c1, Circle c2)
{
    double d = (c2.c - c1.c).abs();
    double cosine = (c1.r * c1.r + d * d - c2.r * c2.r) / (2 * c1.r * d);
    Point x = (c2.c - c1.c) * (c1.r / d) + c1.c;
    return getRotatePoints(x, c1.c, cosine);
}

class Polygon {
private:
    vector<Point> points;
    int n;

public:
    explicit Polygon(int n = 0) : n(n)
    {
        points.reserve(n);
        int x, y;
        for (int i = 0; i < n; i++)
        {
            cin >> x >> y;
            points.emplace_back(x, y);
        }
    }

    int contains(Point p)
    {
        bool is_contain = false;

        for (int i = 0; i < n; i++)
        {
            Vector a = points[i] - p;
            Vector b = points[(i + 1) % n] - p;

            if (equals(cross(a, b), 0.0) && dot(a, b) < EPS) // 線分上にある
                return 1;

            if (a.y > b.y)
                swap(a, b);
            if (cross(a, b) > EPS && a.y<EPS && b.y>EPS) // 交差
                is_contain = !is_contain;
        }
        return is_contain ? 2 : 0;
    }

    vector<Point> andrew()
    {
        vector<Point> u, l;
        if (n < 3)
            return points;
        sort(points.begin(), points.end());
        u.push_back(points[0]);
        u.push_back(points[1]);
        l.push_back(points[n - 1]);
        l.push_back(points[n - 2]);

        for (int i = 2; i < n; i++)
        {
            for (int j = u.size(); j >= 2 && ccw(u[j - 2], u[j - 1], points[i]) == COUNTER_CLOCKWISE; j--)
                u.pop_back();
            u.push_back(points[i]);
        }

        for (int i = n - 3; i >= 0; i--)
        {
            for (int j = l.size(); j >= 2 && ccw(l[j - 2], l[j - 1], points[i]) == COUNTER_CLOCKWISE; j--)
                l.pop_back();
            l.push_back(points[i]);
        }

        reverse(l.begin(), l.end());
        for (int i = u.size() - 2; i >= 1; i--)
            l.push_back(u[i]);

        return l;
    }
};

Point argminx_in_miny(vector<Point> points)
{
    sort(points.begin(), points.end(), [](Point &p1, Point &p2) {
        return p1.y != p2.y ? p1.y < p2.y : p1.x < p2.x;
    });
    return points[0];
}

int main()
{
    int n;
    cin >> n;
    Polygon polygon(n);
    vector<Point> points = polygon.andrew();
    cout << points.size() << endl;
    int i;
    Point minp = argminx_in_miny(points);
    for (i = 0; i < points.size(); i++)
        if (minp == points[i])
            break;

    int loop = i;
    while (true)
    {
        cout << points[loop].x << " " << points[loop].y << endl;
        loop = (loop + 1) % points.size();
        if (loop == i)
            break;
    }

}


Measured memory_bytes: 6684