#include <bits/stdc++.h>
using namespace std;
template <class Monoid, class Action>
struct StarrySky {
  const Monoid INF;
  const Action ZERO;
  int SIZE;
  vector<pair<Monoid, int> > dat;
  vector<Action> lazy;
  StarrySky(int n, const Monoid &inf, const Action &zero)
      : INF(inf), ZERO(zero) {
    init(n);
  }
  void init(int n) {
    SIZE = 1;
    while (SIZE < n) SIZE <<= 1;
    dat.assign(SIZE * 2, {-INF, -1});
    lazy.assign(SIZE * 2, ZERO);
  }
  void set(int a, const Monoid &v) { dat[a + SIZE] = {v, a}; }
  void build() {
    for (int k = SIZE - 1; k > 0; --k) dat[k] = max(dat[k * 2], dat[k * 2 + 1]);
  }
  inline void evaluate(int k) {
    if (lazy[k] == ZERO) return;
    if (k < SIZE) lazy[k * 2] += lazy[k], lazy[k * 2 + 1] += lazy[k];
    dat[k].first += lazy[k];
    lazy[k] = ZERO;
  }
  inline void update(int a, int b, const Action &v, int k, int l, int r) {
    evaluate(k);
    if (a <= l && r <= b)
      lazy[k] += v, evaluate(k);
    else if (a < r && l < b) {
      update(a, b, v, k * 2, l, (l + r) >> 1),
          update(a, b, v, k * 2 + 1, (l + r) >> 1, r);
      dat[k] = max(dat[k * 2], dat[k * 2 + 1]);
    }
  }
  inline void update(int a, int b, const Action &v) {
    update(a, b, v, 1, 0, SIZE);
  }
  inline pair<Monoid, int> get(int a, int b, int k, int l, int r) {
    evaluate(k);
    if (a <= l && r <= b)
      return dat[k];
    else if (a < r && l < b)
      return max(get(a, b, k * 2, l, (l + r) >> 1),
                 get(a, b, k * 2 + 1, (l + r) >> 1, r));
    else
      return {-INF, -1};
  }
  inline pair<Monoid, int> get(int a, int b) { return get(a, b, 1, 0, SIZE); }
  inline Monoid operator[](int a) { return get(a, a + 1).first; }
  void print() {
    for (int i = 0; i < SIZE; ++i) {
      cout << (*this)[i];
      if (i != SIZE) cout << ",";
    }
    cout << endl;
  }
};
const long long INF = 1LL << 60;
using pll = pair<long long, long long>;
using Item = pair<pll, long long>;
int main() {
  int N;
  cin >> N;
  vector<Item> v(N);
  for (int i = 0; i < N; ++i) {
    cin >> v[i].first.first >> v[i].first.second >> v[i].second;
    if (v[i].first.first > v[i].first.second)
      swap(v[i].first.first, v[i].first.second);
  }
  sort(v.begin(), v.end());
  vector<long long> alt;
  for (int i = 0; i < N; ++i) {
    alt.push_back(v[i].first.first);
    alt.push_back(v[i].first.second);
  }
  sort(alt.begin(), alt.end());
  alt.erase(unique(alt.begin(), alt.end()), alt.end());
  alt.push_back(alt.back() + 1);
  int M = alt.size();
  vector<vector<int> > ends(M + 1), starts(M + 1);
  for (int i = 0; i < N; ++i) {
    int right =
        lower_bound(alt.begin(), alt.end(), v[i].first.second) - alt.begin();
    int left =
        lower_bound(alt.begin(), alt.end(), v[i].first.first) - alt.begin();
    ends[right].push_back(i);
    starts[left].push_back(i);
  }
  StarrySky<long long, long long> ss(M + 1, INF, 0);
  long long sum = 0;
  for (int i = 0; i < M; ++i) {
    long long len = alt[i] - alt[0];
    for (auto id : ends[i]) sum += v[id].second;
    ss.set(i, sum - len);
  }
  ss.build();
  auto cur = ss.get(0, M);
  long long res = cur.first;
  int rx = alt[0];
  int ry = alt[cur.second];
  for (int i = 1; i < M; ++i) {
    long long lenadd = alt[i] - alt[i - 1];
    ss.update(i, M, lenadd);
    for (auto id : starts[i - 1]) {
      int right =
          lower_bound(alt.begin(), alt.end(), v[id].first.second) - alt.begin();
      ss.update(right, M, -v[id].second);
    }
    auto cur = ss.get(i, M);
    if (res < cur.first) res = cur.first, rx = alt[i], ry = alt[cur.second];
  }
  cout << res << endl;
  cout << rx << " " << rx << " " << ry << " " << ry << endl;
}
