//be naame khodaa
#include <bits/stdc++.h>
using namespace std;
 
typedef long long ll;
typedef long double ld;
typedef pair <int, int> pii;
typedef complex<ld> PT;
typedef vector<PT> Poly;
typedef pair<PT, PT> LS;
#define F first
#define S second
#define X real()
#define Y imag()
#define pb push_back
 
inline int in(){int x, y; y = scanf("%d", &x); return x; }
 
const int N = -1;
const ld EPS = 1e-12;
 
const int ON = 0, LEFT = 1, RIGHT = -1, BACK = -2, FRONT = 2, IN = 3, OUT = -3;
 
inline bool Geq(ld a, ld b){ return a + EPS > b; }
inline bool Grt(ld a, ld b){ return a > b + EPS; }
inline bool Leq(ld a, ld b){ return a < b + EPS; }
inline bool Lss(ld a, ld b){ return a + EPS < b; }
inline bool Equ(ld a, ld b){ return Geq(a, b) && Geq(b, a); }
 
istream& operator>> (istream& is, complex<ld>& p){
    ld val;
    is >> val;
    p.real(val);
    is >> val;
    p.imag(val);
    return is;
}
 
bool cmpXY(PT a, PT b){
    if (Equ(a.X, b.X))
        return Lss(a.Y, b.Y);
    return Lss(a.X, b.X);
}
 
ld dot(PT a, PT b){ return real(conj(a)*b); }
ld cross(PT a, PT b){ return imag(conj(a)*b); }
ld sqlen(PT a){ return dot(a, a); }
ld len(PT a){ return sqrt(sqlen(a)); }
 
PT proj(PT a, PT b, PT c){
    b -= a, c -= a;
    return a + b*real(c/b);
}
 
PT reflect(PT a, PT b, PT c){
    b -= a, c -= a;
    return a + conj(c/b)*b;
}
 
PT rotate(PT a, PT b, ld theta){
    return (b-a)*polar<ld>(1, theta) + a;
}
 
int relpos(PT a, PT b, PT c){
    b -= a, c -= a;
    c /= b;
    if (Grt(c.imag(), 0)) return LEFT;
    if (Lss(c.imag(), 0)) return RIGHT;
    if (Lss(c.real(), 0)) return BACK;
    if (Grt(c.real(), 1)) return FRONT;
    return ON;
}
 
int side(PT a, PT b, PT c){
    b -= a, c -= a;
    ld cr = cross(b, c);
    return Grt(cr, 0) ? 1 : (Lss(cr, 0) ? -1 : 0);
}
 
bool intersect(PT a, PT b, PT c, PT d){
    int as = side(c, d, a), bs = side(c, d, b), cs = side(a, b, c), ds = side(a, b, d);
    if (as && as == bs || cs && cs == ds) return false;
    else if (as || bs || cs || ds) return true;
    for (int j = 0; j < 2; j++, swap(a, c), swap(b, d)){
        ld mx = min(a.X, b.X), Mx = max(a.X, b.X), my = min(a.Y, b.Y), My = max(a.Y, b.Y);
        for (int k = 0; k < 2; k++, swap(c, d))
            if (Geq(c.X, mx) && Leq(c.X, Mx) && Geq(c.Y, my) && Leq(c.Y, My))
                return true;
    }
    return false;
}
 
PT intersection(PT a, PT b, PT c, PT d){
    ld c1 = cross(b-a, c-a), c2 = cross(b-a, d-a);
    return (c1*d - c2*c)/(c1-c2);
}
 
ld distLSP(PT a, PT b, PT c){
    int rpos = relpos(a, b, proj(a, b, c));
    if (rpos == BACK) return len(c-a);
    if (rpos == FRONT) return len(c-b);
    b -= a, c -= a;
    return abs(cross(b, c)/len(b));
}
 
ld distLS(PT a, PT b, PT c, PT d){
    if (intersect(a, b, c, d)) return 0;
    return min(min(distLSP(a, b, c), distLSP(a, b, d)), min(distLSP(c, d, a), distLSP(c, d, b)));
}
 
ld signedArea(Poly &po){
    int n = po.size();
    ld res = 0;
    for (int i = 0; i < n; i++)
        res += cross(po[i], po[(i+1)%n]);
    return res/2;
}
 
ld area(Poly &poly){
    return abs(signedArea(poly));
}
 
bool isConvex(Poly &po){
    int n = po.size();
    bool neg = false, pos = false;
    for (int i = 0; i < n; i++){
        int rpos = relpos(po[i], po[(i+1)%n], po[(i+2)%n]);
        if (rpos == LEFT) pos = true;
        if (rpos == RIGHT) neg = true;
    }   
    return (neg&pos) == false;
}
 
int crossingN(Poly &po, PT a){
    int n = po.size();
    PT b = a;
    for (PT p : po)
        b.real(max(b.X, p.X));
    int cn = 0;
    for (int i = 0; i < n; i++){
        PT p = po[i], q = po[(i+1)%n];
        if (intersect(a, b, p, q) && (side(a, b, p) == 1 || side(a, b, q) == 1))
            cn++;
    }
    return cn;
}
 
int windingN(Poly &po, PT a){
    int n = po.size();
    PT b = a;
    for (PT p : po)
        b.real(max(b.X, p.X));
    int wn = 0;
    for (int i = 0; i < n; i++){
        PT p = po[i], q = po[(i+1)%n];
        if (intersect(a, b, p, q)){
            int ps = side(a, b, p), qs = side(a, b, q);
            if (qs >= 0) wn++;
            if (ps >= 0) wn--;
        }
    }
    return wn;
}
 
int pointInPoly(Poly &po, PT a){
    int n = po.size();
    for (int i = 0; i < n; i++)
        if (relpos(po[i], po[(i+1)%n], a) == ON)
            return ON;  
    return (crossingN(po, a)%2 ? IN : OUT);
}
 
Poly getHull(Poly &po, bool lower){
    sort(po.begin(), po.end(), cmpXY);
    Poly res;
    int n = res.size();
    for (auto p : po){
        while (n >= 2 && side(res[n-2], res[n-1], p) == (lower ? RIGHT : LEFT))
            res.pop_back(), n--;
        res.pb(p), n++;
    }
    return res;
}
 
Poly convexHull(Poly &po){
    int n = po.size();
    Poly lower = getHull(po, true),
         upper = getHull(po, false);
    Poly res = lower;
    for (int i = (int)upper.size()-2; i; i--)
        res.pb(upper[i]);
    return res;
}
 
int main(){ 
    Poly poly;
    for (int i = in(); i; i--){
        PT p;
        cin >> p;
        poly.pb(p);
    }
    Poly CH = convexHull(poly);
    int st = 0;
    for (int i = 0; i < CH.size(); i++)
        if (Lss(CH[i].Y, CH[st].Y) || (Equ(CH[i].Y, CH[st].Y) && Lss(CH[i].X, CH[st].X)))
            st = i;
    int cur = st;
    cout << setprecision(0) << fixed;
    cout << CH.size() << endl;
    do{
        cout << CH[cur].X << ' ' << CH[cur].Y << '\n';
        cur = (cur+1)%(CH.size());
    }while (cur != st);
    return 0;
}


Measured memory_bytes: 12460