#include "bits/stdc++.h"
using ll = long long;
using ld = long double;
using namespace std;

struct Point {
    ll x = 0, y = 0;

    Point() = default;
    Point(ll x, ll y) : x(x), y(y) {}
    Point(const Point &A, const Point &B) {
        x = B.x - A.x;
        y = B.y - A.y;
    }

    ll operator%(const Point &other) const {
        return x * other.y -y * other.x;
    }

    ll operator*(const Point &other) const {
        return x * other.x + y * other.y;
    }

    bool operator<(const Point &other) const {
        return y < other.y || (y == other.y && x < other.x);
    }

    bool operator==(const Point &other) const {
        return x == other.x && y == other.y;
    }

    bool operator!=(const Point &other) const {
        return !this->operator==(other);
    }

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

    friend istream& operator>>(istream &in, Point &other) {
        return in >> other.x >> other.y;
    }

    friend ostream& operator<<(ostream &out, const Point &other) {
        return out << other.x << ' ' << other.y;
    }
};

struct Frac {
    __int128 a = 0, b = 1;
    Frac() {}
    Frac(__int128 a, __int128 b) : a(a), b(b) {}

    bool operator<(const Frac &other) const {
        return a * other.b < b * other.a;
    }
};

struct Line {
    __int128 a = 0, b = 1, c = 0;

    Line() = default;
    Line(const Point &A, const Point &B) {
        a = A.y - B.y;
        b = B.x - A.x;
        c = -(a * A.x + b * A.y);
    }

    Frac y(const Line &other) const {
        return Frac(c * other.a - other.c * a, a * other.b - other.a * b);
    }
};

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);

    int n;
    cin >> n;

    static constexpr int INF = 100'000'000;

    Point V(Point(0, 0), Point(1, INF));
    Point H(Point(0, 0), Point(INF, -1));

    vector<pair<Point, Point>> S(n + 1);

    map<ll, pair<int, bool>> M;

    for (int i = 0; i < n; i++) {
        cin >> S[i].first >> S[i].second;
        if (H * S[i].first > H * S[i].second) {
            swap(S[i].first, S[i].second);
        }
        M[H * S[i].first] = pair(i, false);
        M[H * S[i].second] = pair(i, true);
    }

    Point current;

    auto getY = [&](int i) {
        Line C(current, current + V);
        return C.y(Line(S[i].first, S[i].second));
    };

    auto comp = [&](int i, int j) -> bool {
        if (i == n) {
            return (j != n);
        }
        
        if (j == n) {
            return false;
        }

        return getY(i) < getY(j);
    };

    set<int, decltype(comp)> Q(comp);

    S[n] = pair(Point(-INF, -INF), Point(INF, -INF - 2));
    Q.insert(n);

    vector<Point> T(n + 1);
    T[n] = S[n].first;

    for (auto [x, p] : M) {
        auto [i, closed] = p;

        if (closed) {
            current = S[i].second;
            auto it = Q.find(i);
            int j = *prev(it);
            T[j] = S[i].second;
            Q.erase(it);
        } else {
            current = S[i].first;
            auto it = Q.insert(i).first;
            int j = *prev(it);
            if (T[j] != S[n].first) {
                cout << T[j] << ' ' << S[i].first << '\n';
            }
            T[i] = S[i].first;
            T[j] = S[i].first;
        }
    }
    return 0;
}