#include <bits/stdc++.h>
const int MAXN = 800010;
const int UP = 100000;
template <class T>
T absx(T x) {
  return x < 0 ? -x : x;
}
struct Point {
  long long x, y;
  Point() { x = y = 0; }
  Point(long long a, long long b) { x = a, y = b; }
  long long operator^(Point b) const { return x * b.y - y * b.x; }
  long long operator*(Point b) const { return x * b.x + y * b.y; }
  long long norm() const { return x * x + y * y; }
  long double slen() const { return sqrt(x * x + y * y); }
  Point operator-(Point b) const { return Point(x - b.x, y - b.y); }
  Point operator+(Point b) const { return Point(x + b.x, y + b.y); }
  Point operator*(long double k) const { return Point(x * k, y * k); }
  bool operator<(const Point& b) const { return x == b.x ? y < b.y : x < b.x; }
  friend std::istream& operator>>(std::istream& in, Point& x) {
    in >> x.x >> x.y;
    return in;
  }
  friend std::ostream& operator<<(std::ostream& out, Point& x) {
    out << x.x << ' ' << x.y;
    return out;
  }
};
inline long long cross(Point a, Point b, Point c) { return (b - a) ^ (c - a); }
std::vector<Point> convexhull(std::vector<Point> ps) {
  std::iter_swap(ps.begin(), std::min_element(ps.begin(), ps.end()));
  auto be = ps[0];
  std::sort(ps.begin() + 1, ps.end(), [be](Point a, Point b) {
    a = a - be, b = b - be;
    long long t = a ^ b;
    return t == 0 ? a.norm() < b.norm() : t > 0;
  });
  static Point st[MAXN];
  int top = 0;
  for (auto t : ps) {
    while (top >= 2 && cross(st[top - 1], st[top], t) <= 0) --top;
    st[++top] = t;
  }
  return std::vector<Point>(st + 1, st + 1 + top);
}
int n;
long long R(long long x) { return std::max(0ll, std::min(x, (long long)UP)); }
int main() {
  std::ios_base::sync_with_stdio(false), std::cin.tie(0);
  std::cin >> n;
  std::vector<Point> li;
  for (int i = 1; i <= n; ++i) {
    int x, y, z, t;
    std::cin >> x >> y >> z;
    x >= z ? li.emplace_back(x - z, y)
           : (t = z - x, li.emplace_back(0, R(y - t)),
              li.emplace_back(0, R(y + t)));
    y >= z ? li.emplace_back(x, y - z)
           : (t = z - y, li.emplace_back(R(x - t), 0),
              li.emplace_back(R(x + t), 0));
    x + z <= UP ? li.emplace_back(x + z, y)
                : (t = x + z - UP, li.emplace_back(UP, R(y - t)),
                   li.emplace_back(UP, R(y + t)));
    y + z <= UP ? li.emplace_back(x, y + z)
                : (t = y + z - UP, li.emplace_back(R(x - t), UP),
                   li.emplace_back(R(x + t), UP));
  }
  std::vector<Point> ch = convexhull(li);
  const int SZ = ch.size();
  std::tuple<Point, Point, Point> ans;
  double av = 0;
  for (int i = 0; i != SZ; ++i) {
    auto A = ch[i], B = ch[(i + 1) % SZ], C = ch[(i + 2) % SZ];
    double R = (A - B).slen() * (B - C).slen() * (A - C).slen();
    R /= absx(cross(A, B, C));
    if (R > av) av = R, ans = std::make_tuple(A, B, C);
  }
  std::cout << std::get<0>(ans) << '\n';
  std::cout << std::get<1>(ans) << '\n';
  std::cout << std::get<2>(ans) << '\n';
  return 0;
}
