#define _FORTIFY_SOURCE 0
#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,sse4,popcnt,abm,mmx,avx,tune=native")
#include <iostream>
#include <stdio.h>
#include <vector>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <deque>
#include <algorithm>
#include <math.h>
#include <random>
#define ff first
#define ss second
#define pb push_back
#define mp make_pair
#define int long long
#define double long double
#define Matrix vector<vector<int> >
#define kektor vector
#define pii pair<int, int>
#define pp pair
#define all(x) x.begin(), x.end()

using namespace std;

typedef long long ll;

int RandInt(int min, int max) {
    if (max < min) {
        swap(min, max);
    }
    random_device rd;
    mt19937 mt(rd());
    uniform_int_distribution<int> dist(min, max);
    return dist(mt);
}

const int maxn = 3e5, mod = 1e9 + 7, inf = 1e18; const double pi = 3.14159265359, eps = 1e-9;

struct State {
	int x, y, ty, y1;
	State(int _x, int _y, int _ty, int _y1) : x(_x), y(_y), ty(_ty), y1(_y1) {}
	State() : x(0), y(0), ty(0), y1(0) {}
};

struct Node {
	int x, id, push;
	Node(int _x, int _id, int _push) : x(_x), id(_id), push(_push) {}
	Node() : x(0), id(0), push(0) {}
};

Node operator+(Node p1, Node p2)  {
	if (p1.x > p2.x) {
		return p1;
	}
	return p2;
}

int n, len = 1;
vector<Node> tree;
vector<State> scan;

bool cmp(State p1, State p2)  {
	return (p1.x < p2.x) || (p1.x == p2.x && p1.ty < p2.ty);
}

void build() {
	while (len < 3e6) {
		len *= 2;
	}
	tree.resize(len + len - 1);
	for (int i = len - 1; i < len + 3e6 - 1; ++i) {
		tree[i].id = i - len + 1;
	}
	for (int i = len - 2; i >= 0; --i) {
		tree[i] = tree[i * 2 + 1];
	}
}

int push_ver(int root, int l, int r) {
	int push = tree[root].push;
	tree[root].x += push;
	tree[root].push = 0;
	if (l != r) {
		tree[root * 2 + 1].push += push;
		tree[root * 2 + 2].push += push;
	}
}

pii get(int l, int r, int l1, int r1, int root) {
	push_ver(root, l, r);
	if (l >= l1 && r <= r1) {
		return mp(tree[root].x, tree[root].id);
	} else if (max(l, l1) > min(r, r1)) {
		return mp(-inf, -inf);
	} else {
		int tm = (l + r) / 2;
		return max(get(l, tm, l1, r1, root * 2 + 1), get(tm + 1, r, l1, r1, root * 2 + 2));
	}
}

void upd(int l, int r, int l1, int r1, int root, int val) {
	push_ver(root, l, r);
	if (l >= l1 && r <= r1) {
		tree[root].push += val;
		push_ver(root, l, r);
	} else if (max(l, l1) > min(r, r1)) {
		return;
	} else {
		int tm = (l + r) / 2;
		upd(l, tm, l1, r1, root * 2 + 1, val);
		upd(tm + 1, r, l1, r1, root * 2 + 2, val);
		tree[root] = tree[root * 2 + 1] + tree[root * 2 + 2];
	}
}

void solve() {
	cin >> n;
	for (int i = 0; i < n; ++i)	{
		int x, y, x1, y1;
		cin >> x >> y >> x1 >> y1;
		x += 1e6;
		y += 1e6;
		x1 += 1e6;
		y1 += 1e6;
		scan.pb(State(x, y, -1, y1));
		scan.pb(State(x1, y1, 1, y));
	}
	sort(all(scan), cmp);
	build();
	int ans = -inf, a = -inf, b = -inf;
	for (int i = 0; i < scan.size(); ++i) {
		int L = min(scan[i].y, scan[i].y1);
		int R = max(scan[i].y, scan[i].y1);
		upd(0, len - 1, L, R, 0, -scan[i].ty);
		pii val = get(0, len - 1, L, R, 0);
		if (val.ff > ans) {
			ans = val.ff;
			a = scan[i].x;
			b = val.ss;
		}
	}
	cout << ans << '\n' << a - (int)1e6 << " " << b - (int)1e6;
}

signed main() {
    cout.precision(10);
    cout << fixed;
    ios_base::sync_with_stdio(false);
   	cin.tie(0);
    cout.tie(0);
    #ifdef offline_judge
   		freopen("TASK.in", "r", stdin);
    	freopen("TASK.out", "w", stdout);
    #endif
    solve();
    return 0;
}