#include<iostream>
#include <bits/stdc++.h>

#define ll long long
#define ld long double
#define IO ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0);

using namespace std;
const int N = 2e6 + 2, MOD = 998244353;
ld eps = 1e-5;

struct pt {
    long long x, y;

    pt() {}

    pt(long long _x, long long _y) : x(_x), y(_y) {}

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

    long long cross(const pt &p) const { return x * p.y - y * p.x; }

    long long cross(const pt &a, const pt &b) const { return (a - *this).cross(b - *this); }
};

int sgn(const long long &x) { return x >= 0 ? x ? 1 : 0 : -1; }

bool inter1(long long a, long long b, long long c, long long d) {
    if (a > b)
        swap(a, b);
    if (c > d)
        swap(c, d);
    return max(a, c) <= min(b, d);
}

bool check_inter(const pt &a, const pt &b, const pt &c, const pt &d) {
    if (c.cross(a, d) == 0 && c.cross(b, d) == 0)
        return inter1(a.x, b.x, c.x, d.x) && inter1(a.y, b.y, c.y, d.y);
    return sgn(a.cross(b, c)) != sgn(a.cross(b, d)) &&
           sgn(c.cross(d, a)) != sgn(c.cross(d, b));
}

vector<pair<pt, pt>> v;

bool check(pt a, pt b) {
    for (auto i: v) {
        if (!check_inter(a, b, i.first, i.second))return false;
    }
    return true;
}

vector<ld> solve(int w, int h) {
    ll l1 = 0, r1 = h, l2 = 0, r2 = h;

    for (int i = 0; i < v.size(); i++) {
        if (v[i].first.x > v[i].second.x)swap(v[i].first, v[i].second);
    }

    vector<pair<ll, ll> > rem;
    for (auto i: v) {
        if (i.first.x > 0 && i.second.x < w)continue;

        if (i.first.x == 0 && i.second.y == h) {
            l1 = max(l1, i.first.y);
        } else if (i.first.x == 0 && i.second.y == 0) {
            r1 = min(r1, i.first.y);
        } else if (i.first.x == 0) {
            rem.push_back({i.first.y, i.second.y});
        } else if (i.first.y == h) {
            l2 = max(l2, i.second.y);
        } else if (i.first.y == 0) {
            r2 = min(r2, i.second.y);
        } else {
            assert(false);
        }
    }
    if (l1 >= r1 || l2 >= r2)return {};

    if (rem.empty()) {
        return {0, l1 + eps, (ld) w, l2 + eps};
    }

    sort(rem.begin(), rem.end());
    stack<ll> st;
    st.push(0);

    for (int i = rem.size() - 1; i >= 0; i--) {
        st.push(max(st.top(), rem[i].second));
    }

    if (rem[0].first > l1 && st.top() < r2) {
        return {0, l1 + eps, (ld) w, r2 - eps};
    }

    for (int i = 0; i < rem.size(); i++) {
        st.pop();
        l1 = max(l1, rem[i].first);
        r2 = min(r2, rem[i].second);
        if (l1 >= r1 || l2 >= r2)return {};

        if (i + 1 < rem.size() && rem[i + 1].first <= l1)continue;

        if (st.top() < r2) {
            return {0, l1 + eps, (ld) w, r2 - eps};
        }
    }
    return {};
}

int getID(pt a, int w, int h) {
    if (a.y == h) return 1;
    if (a.x == w)return 2;
    if (a.y == 0)return 3;
    return 4;
}

bool f = false;

vector<ld> solve2(int w, int h) {
    ll l1 = 0, r1 = w, l2 = 0, r2 = h;


    vector<pair<ll, ll> > rem;
    for (auto &i: v) {
        int a = getID(i.first, w, h), b = getID(i.second, w, h);
        if (a > b) {
            swap(a, b);
            swap(i.first, i.second);
        }

        if (a == 1 && b == 2) {
            rem.push_back({i.first.x, i.second.y});
        } else if (a == 1 && b >= 3) {
            r1 = min(r1, i.first.x);
        } else if (a == 2) {
            r2 = min(r2, i.second.y);
        } else if (a == 3) {
            if (f)assert(false);
            return {};
        }
    }

    if (rem.empty()) {
        return {l1 + eps, (ld) h, (ld) w, l2 + eps};
    }

    sort(rem.begin(), rem.end());
    stack<ll> st;
    st.push(0);

    for (int i = rem.size() - 1; i >= 0; i--) {
        st.push(max(st.top(), rem[i].second));
    }

    if (rem[0].first > l1 && st.top() < r2) {
        return {l1 + eps, (ld) h, (ld) w, r2 - eps};
    }

    for (int i = 0; i < rem.size(); i++) {
        st.pop();
        l1 = max(l1, rem[i].first);
        r2 = min(r2, rem[i].second);
        if (l1 >= r1 || l2 >= r2){
            if(f)assert(false);
            return {};
        }

        if (i + 1 < rem.size() && rem[i + 1].first <= l1)continue;

        if (st.top() < r2) {
            return {l1 + eps, (ld) h, (ld) w, r2 - eps};
        }
    }
    return {};
}

void rotateLeft(ll &x, ll &y, int w, int h) {
    swap(x, y);
    x = h - x;
}

void rotateLeft(ld &x, ld &y, int w, int h) {
    swap(x, y);
    x = h - x;
}

void doWork() {
    int n, w, h;
    cin >> n >> w >> h;
    if (n == 1000000)f = true;
    for (int i = 0; i < n; i++) {
        pt a, b;
        cin >> a.x >> a.y;
        cin >> b.x >> b.y;

        v.push_back({a, b});
    }

    for (int k = 0; k < 4; k++) {
        vector<ld> temp = solve(w, h);
        if (temp.empty()) temp = solve2(w, h);

        if (!temp.empty()) {
            cout << "1\n";
            int temp_w = w, temp_h = h;
            for (int z = 0; z < 4 - k; z++) {
                rotateLeft(temp[0], temp[1], temp_w, temp_h);
                rotateLeft(temp[2], temp[3], temp_w, temp_h);
                swap(temp_w, temp_h);
            }
            for (auto i: temp)cout << fixed << i << " ";
            return;
        }

        for (int i = 0; i < v.size(); i++) {
            rotateLeft(v[i].first.x, v[i].first.y, w, h);
            rotateLeft(v[i].second.x, v[i].second.y, w, h);
        }
        swap(w, h);
        f= false;
    }

    cout << "2\n";
    cout << fixed << eps << " " << 0 << " " << w - eps << " " << h;
    cout << "\n";
    cout << fixed << eps << " " << h << " " << w - eps << " " << 0;
}

int main() {
    IO
    int t = 1;
//    cin >> t;
    for (int i = 1; i <= t; i++) {
        //  cout << "Case #" << i << ": ";
        doWork();
    }
}