#include <bits/stdc++.h>
using namespace std;
long long MOD = 1000000007;
const int MAXX = 100000;
const double eps = 1e-8;
const double PI = acos(-1);
bool zero(double d = 0) { return abs(d) < eps; }
struct Point {
  double x, y;
  double dist2(Point p = {0, 0}) {
    return (p.x - x) * (p.x - x) + (p.y - y) * (p.y - y);
  }
  double dist(Point p = {0, 0}) { return sqrt(dist2(p)); }
  Point operator+(const Point& p) const { return {x + p.x, y + p.y}; }
  Point operator-(const Point& p) const { return {x - p.x, y - p.y}; }
  Point operator*(const double mul) const { return {x * mul, y * mul}; }
};
double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
struct line {
  double a, b, c;
  vector<Point> intersection(line l) {
    double p = l.a, q = l.b, r = l.c;
    if (zero(b * p - a * q)) {
      if (zero(b * r - c * q)) return {(Point){0, 0}, (Point){0, 0}};
      return {};
    }
    return {(Point){(b * r - c * q) / (a * q - b * p),
                    (c * p - a * r) / (a * q - b * p)}};
  }
  double dist(Point p) {
    double num = a * p.x + b * p.y + c;
    double den = sqrt(a * a + b * b);
    return num / den;
  }
  line perp(Point p) { return (line){b, -a, a * p.y - b * p.x}; }
  vector<Point> Points_at_d(Point p, double d) {
    Point dir = {-b, a};
    return {p + dir * (d / dir.dist()), p - dir * (d / dir.dist())};
  }
};
struct line_segment {
  Point a, b;
  line perp_bisec() {
    Point mid = (a + b) * 0.5;
    double l = a.x - b.x;
    double m = a.y - b.y;
    double n = -(mid.y * m + l * mid.x);
    return (line){l, m, n};
  }
  line get_line() {
    double l = b.y - a.y;
    double m = a.x - b.x;
    double n = -(a.y * m + a.x * l);
    return (line){l, m, n};
  }
  bool inside(Point p) {
    double d1 = p.dist(a);
    double d2 = p.dist(b);
    return zero(d1 + d2 - a.dist(b));
  }
  bool intersect(line_segment s) {
    line l1 = get_line();
    line l2 = s.get_line();
    vector<Point> v = l1.intersection(l2);
    if (v.empty()) return 0;
    if (v.size() > 1) {
      return (s.inside(a) || s.inside(b) || inside(s.a) || inside(s.b));
    }
    return s.inside(v[0]) && inside(v[0]);
  }
};
int max(int a, int b) {
  if (a > b) return a;
  return b;
}
int min(int a, int b) {
  if (a < b) return a;
  return b;
}
struct point {
  int x, y;
  bool operator==(const point& p) const { return (x == p.x && y == p.y); }
  bool operator<(const point& p) const {
    if (x == p.x) return y < p.y;
    return x < p.x;
  }
  long long dist2(const point& p) {
    long long d = (p.x - x) * 1LL * (p.x - x) + (p.y - y) * 1LL * (p.y - y);
    return d;
  }
} a0;
long long area(point& a, point& b, point& c) {
  long long ar = a.x * 1LL * b.y - a.y * 1LL * b.x;
  ar += b.x * 1LL * c.y - c.x * 1LL * b.y;
  ar += c.x * 1LL * a.y - a.x * 1LL * c.y;
  return ar;
}
double getR(point& a, point& b, point& c) {
  line_segment l1 = {{(double)a.x, (double)a.y}, {(double)b.x, (double)b.y}};
  line_segment l2 = {{(double)b.x, (double)b.y}, {(double)c.x, (double)c.y}};
  vector<Point> v = l1.perp_bisec().intersection(l2.perp_bisec());
  if (v.size() != 1) return 0;
  return v[0].dist2({(double)a.x, (double)a.y});
}
bool cmp(const point& a, const point& b) {
  long long x = (a.y - a0.y) * 1LL * (b.x - a0.x);
  long long y = (b.y - a0.y) * 1LL * (a.x - a0.x);
  if (x == y) return a.x + a.y < b.x + b.y;
  return x < y;
}
void getConvexHull(vector<point>& pts, vector<point>& hull) {
  sort(pts.begin(), pts.end());
  pts.resize(unique(pts.begin(), pts.end()) - pts.begin());
  int n = pts.size();
  a0 = pts.front();
  sort(pts.begin() + 1, pts.end(), cmp);
  hull.push_back(pts[0]);
  pts.push_back(a0);
  for (int i = 1; i <= n; ++i) {
    while (hull.size() > 1) {
      int h = hull.size();
      if (area(hull[h - 2], hull[h - 1], pts[i]) <= 0)
        hull.pop_back();
      else
        break;
    }
    hull.push_back(pts[i]);
  }
  pts.pop_back();
  hull.pop_back();
  return;
}
int main() {
  int n;
  scanf("%d", &n);
  vector<point> pts;
  for (int i = 0; i < (n); ++i) {
    int x, y, v;
    scanf("%d %d %d", &x, &y, &v);
    if (x - v < 0) {
      pts.push_back({0, min(y + v - x, MAXX)});
      pts.push_back({0, max(y - v + x, 0)});
    } else
      pts.push_back({x - v, y});
    if (x + v > MAXX) {
      pts.push_back({MAXX, min(y + x + v - MAXX, MAXX)});
      pts.push_back({MAXX, max(y - v + MAXX - x, 0)});
    } else
      pts.push_back({x + v, y});
    if (y - v < 0) {
      pts.push_back({max(0, x - v + y), 0});
      pts.push_back({min(MAXX, x + v - y), 0});
    } else
      pts.push_back({x, y - v});
    if (y + v > MAXX) {
      pts.push_back({max(0, x - v - y + MAXX), MAXX});
      pts.push_back({min(MAXX, x + y + v - MAXX), MAXX});
    } else
      pts.push_back({x, y + v});
  }
  vector<point> hull;
  getConvexHull(pts, hull);
  double maxr = 0;
  int idx = -1;
  for (int i = 0; i < hull.size(); ++i) {
    int j = (i + 1) % hull.size();
    int k = (i + 2) % hull.size();
    double r = getR(hull[i], hull[j], hull[k]);
    if (r > maxr) {
      idx = i;
      maxr = r;
    }
  }
  for (int i = 0; i < 3; ++i) {
    printf("%d %d\n", hull[(i + idx) % hull.size()].x,
           hull[(i + idx) % hull.size()].y);
  }
  return 0;
}
