#include <bits/stdc++.h>
using namespace std;

#define EPS (1e-10)
#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 + (Point p) { return Point(x + p.x, y + p.y); }
    Point operator - (Point p) { return Point(x - p.x, y - p.y); }
    Point operator * (double a) { return Point(a * x, a * y); }
    Point operator / (double a) { 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 fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
    }
};

typedef Point Vector;

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;
}

struct Segment {
    Point p1, p2;
};

typedef Segment Line;

class Circle {
    public:
        Point c;
        double r;
        Circle(Point c = Point(), double r = 0.0): c(c), r(r) {}
};

typedef vector<Point> Polygon;

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

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

bool isParallel(Segment s1, Segment s2) {
    return equals(cross((s1.p2 - s1.p1), (s2.p2 - s2.p1)), 0.0);
}

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

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

bool isOrthogonal(Segment s1, Segment s2) {
    return equals(dot((s1.p2 - s1.p1), (s2.p2 - s2.p1)), 0.0);
}

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

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

int ccw(Point p0, Point p1, Point p2) {
    Vector v1 = p1 - p0;
    Vector v2 = p2 - p0;

    // 反時計
    if (cross(v1, v2) > 0.0) return 1;
    // 時計
    if (cross(v1, v2) < 0.0) return -1;

    // p1, p2 が逆方向
    if (dot(v1, v2) < 0.0) return 2;

    // p1, p2 が同方向
    if (v1.abs() < v2.abs()) return -2;
    return 0;
}

bool intersect(Segment s1, Segment s2) {
    return (ccw(s1.p1, s1.p2, s2.p1) * ccw(s1.p1, s1.p2, s2.p2) <= 0
            && ccw(s2.p1, s2.p2, s1.p1) * ccw(s2.p1, s2.p2, s1.p2) <= 0);
}

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) return (p - s.p1).abs();
    if (dot(s.p1 - s.p2, p - s.p2) < 0) return (p - s.p2).abs();

    return getDistanceLP(s, p);
}

double getDistanceSS(Segment s1, Segment s2) {
    if (intersect(s1, s2)) {
        return 0.0;
    }

    return min(
        min(getDistanceSP(s1, s2.p1), getDistanceSP(s1, s2.p2)),
        min(getDistanceSP(s2, s1.p1), getDistanceSP(s2, s1.p2))
    );
}

double getDistancePP(Point p1, Point p2) {
    return (p2 - p1).abs();
}

Point getCrossPoint(Segment s1, Segment s2) {
    Vector base = s2.p2 - s2.p1;
    double d1 = abs(cross(base, s1.p1 - s2.p1));
    double d2 = abs(cross(base, s1.p2 - s2.p1));

    Vector hypo = s1.p2 - s1.p1;
    return s1.p1 + hypo * (d1 / (d1 + d2));
}

pair<Point, Point> getCircleSegmentCrossPoint(Circle c, Segment s) {
    Point projection = project(s, c.c);
    double dist = sqrt(c.r * c.r - (c.c - projection).norm());
    Vector base = s.p2 - s.p1;
    base = base / base.abs();
    Point a = projection + (base * dist);
    return make_pair(projection + (base * dist), projection - (base * dist));
}

pair<Point, Point> getCircleCrossPoint(Circle c1, Circle c2) {
    double d = (c2.c - c1.c).abs();
    double a = acos((d * d + c1.r * c1.r - c2.r * c2.r) / (2 * d * c1.r));
    double t = atan2((c2.c - c1.c).y, (c2.c - c1.c).x);
    Point crossPoint1 = {c1.c.x + c1.r * cos(a + t), c1.c.y + c1.r * sin(a + t)};
    Point crossPoint2 = {c1.c.x + c1.r * cos(t - a), c1.c.y + c1.r * sin(t - a)};
    return make_pair(crossPoint1, crossPoint2);
}

int isContainedInPolygon(Polygon polygon, Point target) {
    int n = polygon.size();
    bool contained = false;
    for (int i = 0; i < n; i++) {
        Point p1 = polygon.at(i);
        Point p2 = polygon.at((i + 1) % n);
        Vector a = p1 - target;
        Vector b = p2 - target;

        if (abs(cross(a, b)) < EPS && dot(a, b) < EPS) return 1;

        if (a.y > b.y) swap(a, b);

        if (a.y < EPS && b.y > EPS && cross(a, b) > 0) contained = !contained;
    }

    return contained ? 2 : 0;
}

Polygon getConvexHull(vector<Point> points) {
    vector<Point> upper, lower;
    sort(points.begin(), points.end());

    upper.push_back(points[0]);
    upper.push_back(points[1]);
    lower.push_back(points[points.size() - 1]);
    lower.push_back(points[points.size() - 2]);
    
    for (int i = 2; i < points.size(); i++) {
        Point a, b;
        int j = upper.size() - 1;
        while (j > 0) {
            Point a = upper[j];
            Point b = upper[j - 1];
            if (ccw(b, a, points[i]) != 1) {
                break;
            }
            upper.pop_back();
            j--;
        }
        upper.push_back(points[i]);
    }

    for (int i = points.size() - 3; i >= 0; i--) {
        Point a, b;
        int j = lower.size() - 1;
        while (j > 0) {
            Point a = lower[j];
            Point b = lower[j - 1];
            if (ccw(b, a, points[i]) != 1) {
                break;
            }
            lower.pop_back();
            j--;
        }
        lower.push_back(points[i]);
    }

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

    return lower;
}

int main() {
    // cout << fixed << setprecision(11);
    int n;
    cin >> n;
    Polygon polygon;
    double x, y;

    for (int i = 0; i < n; i++) {
        cin >> x >> y;
        Point p = {x, y};
        polygon.push_back(p);
    }

    Polygon convexHull = getConvexHull(polygon);

    int start = 0;
    double minY = 10001;
    for (int i = 0; i < convexHull.size(); i++) {
        if (convexHull[i].y < minY) {
            minY = convexHull[i].y;
            start = i;
        }
    }

    cout << convexHull.size() << endl;
    int j;
    for (int i = 0; i < convexHull.size(); i++) {
        j = start % convexHull.size();
        cout << convexHull[j].x << " " << convexHull[j].y << endl;
        start++;
    }

    return 0;
}



Measured memory_bytes: 9400