It’s riot time on football stadium Ramacana! Raging fans have entered the field and the police find themselves in a difficult situation. The field can be represented as a square in the coordinate system defined by two diagonal vertices in (0,0) and (105, 105). The sides of that square are also considered to be inside the field, everything else is outside.

In the beginning, there are N fans on the field. For each fan we are given his speed, an integer vi as well as his integer coordinates (xi, yi). A fan with those coordinates might move and after one second he might be at any point (xi + p, yi + q) where 0 ≤ |p| + |q| ≤ vi. p, q are both integers.

Points that go outside of the square that represents the field are excluded and all others have equal probability of being the location of that specific fan after one second.

Andrej, a young and promising police officer, has sent a flying drone to take a photo of the riot from above. The drone’s camera works like this:

  1. It selects three points with integer coordinates such that there is a chance of a fan appearing there after one second. They must not be collinear or the camera won’t work. It is guaranteed that not all of the initial positions of fans will be on the same line. 
  2. Camera focuses those points and creates a circle that passes through those three points. A photo is taken after one second (one second after the initial state). 
  3. Everything that is on the circle or inside it at the moment of taking the photo (one second after focusing the points) will be on the photo. 



Your goal is to select those three points so that the expected number of fans seen on the photo is maximized. If there are more such selections, select those three points that give the circle with largest radius among them. If there are still more suitable selections, any one of them will be accepted. If your answer follows conditions above and radius of circle you return is smaller then the optimal one by 0.01, your output will be considered as correct.

No test will have optimal radius bigger than 1010.

Input

The first line contains the number of fans on the field, N. The next N lines contain three integers: xi ,yi, vi. They are the x-coordinate, y-coordinate and speed of fan i at the beginning of the one second interval considered in the task.

  * 3 ≤ N ≤ 105
  * 0 ≤ xi, yi ≤ 105
  * 0 ≤ vi ≤ 1000
  * All numbers are integers 

Output

You need to output the three points that camera needs to select. Print them in three lines, with every line containing the x-coordinate, then y-coordinate, separated by a single space. The order of points does not matter.

Examples

Input

3
1 1 1
1 1 1
1 2 1


Output

2 2
2 1
1 0
#include <bits/stdc++.h>
using namespace std;
double const eps = 1e-7;
struct Points {
  double x, y;
  Points(double _x = 0, double _y = 0) { x = _x, y = _y; }
  Points operator-(const Points &A) { return Points(x - A.x, y - A.y); }
  Points operator+(const Points &A) { return Points(x + A.x, y + A.y); }
  Points operator*(const double &k) { return Points(x * k, y * k); }
  bool operator<(const Points &A) const {
    return fabs(x - A.x) < eps ? y < A.y : x < A.x;
  }
} p1, p2, p3;
inline double sqr(double x) { return x * x; }
inline double Cross(Points A, Points B) { return A.x * B.y - A.y * B.x; }
inline double Dis(Points A, Points B) {
  return sqrt(sqr(A.x - B.x) + sqr(A.y - B.y));
}
inline Points Middle(Points A, Points B) {
  return Points((A.x + B.x) / 2.0, (A.y + B.y) / 2.0);
}
inline Points Rev(Points A) { return Points(-A.y, A.x); }
struct Lines {
  Points p, v;
  Lines(Points _p = 0, Points _v = 0) { p = _p, v = _v; }
};
inline Points Inter(Lines A, Lines B) {
  return A.v * (Cross(B.v, A.p - B.p) / Cross(A.v, B.v)) + A.p;
}
struct Circle {
  Points o;
  double r;
  Circle(Points _o = 0, double _r = 0) { o = _o, r = _r; }
  bool In(const Points &A) { return Dis(o, A) <= r; }
} O, ansO;
inline bool Check(Points A, Points B, Points C) {
  return Cross(A - B, A - C) != 0;
}
inline Circle MakeCircle(Points A, Points B, Points C) {
  Lines l1 = Lines(Middle(A, B), Rev(B - A));
  Lines l2 = Lines(Middle(A, C), Rev(C - A));
  Points o = Inter(l1, l2);
  double r = Dis(o, A);
  return Circle(o, r);
}
int const MAXN = 1e6 + 5;
vector<Points> G, Tb;
int stk1[MAXN], stk2[MAXN], top1, top2;
signed main() {
  int n, Mx = 1e5;
  scanf("%d", &n);
  for (register int i = 1; i <= n; ++i) {
    int x, y, d;
    scanf("%d %d %d", &x, &y, &d);
    int minx = (x - d >= 0), maxx = (x + d <= Mx);
    int miny = (y - d >= 0), maxy = (y + d <= Mx);
    if (minx)
      G.push_back(Points(x - d, y));
    else {
      G.push_back(Points(0, max(0, y - d + x)));
      G.push_back(Points(0, min(Mx, y + d - x)));
    }
    if (miny)
      G.push_back(Points(x, y - d));
    else {
      G.push_back(Points(max(0, x - d + y), 0));
      G.push_back(Points(min(Mx, x + d - y), 0));
    }
    if (maxx)
      G.push_back(Points(x + d, y));
    else {
      G.push_back(Points(Mx, max(0, y - d + (Mx - x))));
      G.push_back(Points(Mx, min(Mx, y + d - (Mx - x))));
    }
    if (maxy)
      G.push_back(Points(x, y + d));
    else {
      G.push_back(Points(max(0, x - d + (Mx - y)), Mx));
      G.push_back(Points(min(Mx, x + d - (Mx - y)), Mx));
    }
  }
  int si = G.size();
  sort(G.begin(), G.end());
  for (register int i = 0; i < si; ++i) {
    while (top1 > 1 && Cross(G[stk1[top1]] - G[stk1[top1 - 1]],
                             G[i] - G[stk1[top1 - 1]]) <= 0)
      --top1;
    stk1[++top1] = i;
  }
  for (register int i = 0; i < si; ++i) {
    while (top2 > 1 && Cross(G[stk2[top2]] - G[stk2[top2 - 1]],
                             G[i] - G[stk2[top2 - 1]]) >= 0)
      --top2;
    stk2[++top2] = i;
  }
  for (register int i = 1; i <= top1; ++i) Tb.push_back(G[stk1[i]]);
  for (register int i = top2 - 1; i > 1; --i) Tb.push_back(G[stk2[i]]);
  Tb.push_back(Tb[0]);
  Tb.push_back(Tb[1]);
  si = Tb.size();
  for (register int i = 0; i < si - 2; ++i) {
    O = MakeCircle(Tb[i], Tb[i + 1], Tb[i + 2]);
    if (O.r > ansO.r) ansO = O, p1 = Tb[i], p2 = Tb[i + 1], p3 = Tb[i + 2];
  }
  printf("%.0lf %.0lf\n", p1.x + 0.1, p1.y + 0.1);
  printf("%.0lf %.0lf\n", p2.x + 0.1, p2.y + 0.1);
  printf("%.0lf %.0lf\n", p3.x + 0.1, p3.y + 0.1);
  return 0;
}
