#include <bits/stdc++.h>
const int Maxn = 100000;
const int Maxv = 100000;
int n;
struct Node {
  int x, y;
  Node(int _x = 0, int _y = 0) { x = _x, y = _y; }
  friend Node operator+(Node a, Node b) { return Node(a.x + b.x, a.y + b.y); }
  friend Node operator-(Node a, Node b) { return Node(a.x - b.x, a.y - b.y); }
  friend long long operator/(Node a, Node b) {
    return 1ll * a.x * b.y - 1ll * a.y * b.x;
  }
  long long find_len() { return 1ll * x * x + 1ll * y * y; }
} a[Maxn * 6 + 5];
Node S;
bool cmp_1_less(Node a, Node b) {
  if (a.x == b.x) {
    return a.y < b.y;
  }
  return a.x < b.x;
}
bool cmp_1_equal(Node a, Node b) { return a.x == b.x && a.y == b.y; }
bool cmp_2(Node a, Node b) {
  if ((a - S) / (b - S) == 0) {
    return (a - S).find_len() < (b - S).find_len();
  }
  return (a - S) / (b - S) > 0;
}
int len;
int st[Maxn * 6 + 5], st_top;
int main() {
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
    int x, y, v;
    scanf("%d%d%d", &x, &y, &v);
    if (x < v) {
      a[++len] = Node(0, std::max(y - v + x, 0));
      a[++len] = Node(0, std::min(y + v - x, Maxv));
    } else {
      a[++len] = Node(x - v, y);
    }
    if (x + v > Maxv) {
      a[++len] = Node(Maxv, std::max(y - v + (Maxv - x), 0));
      a[++len] = Node(Maxv, std::min(y + v - (Maxv - x), Maxv));
    } else {
      a[++len] = Node(x + v, y);
    }
    if (y < v) {
      a[++len] = Node(std::max(x - v + y, 0), 0);
      a[++len] = Node(std::min(x + v - y, Maxv), 0);
    } else {
      a[++len] = Node(x, y - v);
    }
    if (y + v > Maxv) {
      a[++len] = Node(std::max(x - v + (Maxv - y), 0), Maxv);
      a[++len] = Node(std::min(x + v - (Maxv - y), Maxv), Maxv);
    } else {
      a[++len] = Node(x, y + v);
    }
  }
  std::sort(a + 1, a + 1 + len, cmp_1_less);
  len = std::unique(a + 1, a + 1 + len, cmp_1_equal) - a - 1;
  S = a[1];
  std::sort(a + 2, a + 1 + len, cmp_2);
  st[++st_top] = 1;
  for (int i = 2; i <= len; i++) {
    while (st_top > 1 &&
           (a[i] - a[st[st_top]]) / (a[st[st_top]] - a[st[st_top - 1]]) >= 0) {
      st_top--;
    }
    st[++st_top] = i;
  }
  st[0] = st[st_top], st[st_top + 1] = st[1];
  int pos = -1;
  double ans = 0;
  for (int i = 1; i <= st_top; i++) {
    Node e_a = a[st[i]] - a[st[i - 1]], e_b = a[st[i + 1]] - a[st[i]],
         e_c = a[st[i + 1]] - a[st[i - 1]];
    double tmp = sqrt(e_a.find_len()) * sqrt(e_b.find_len()) *
                 sqrt(e_c.find_len()) / (std::abs(e_a / e_b));
    if (tmp > ans) {
      pos = i;
      ans = tmp;
    }
  }
  printf("%d %d\n", a[st[pos - 1]].x, a[st[pos - 1]].y);
  printf("%d %d\n", a[st[pos]].x, a[st[pos]].y);
  printf("%d %d\n", a[st[pos + 1]].x, a[st[pos + 1]].y);
  return 0;
}

### Prompt

Your task is to create a cpp solution to the following problem:

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

### Response

```cpp
#include <bits/stdc++.h>
const int Maxn = 100000;
const int Maxv = 100000;
int n;
struct Node {
  int x, y;
  Node(int _x = 0, int _y = 0) { x = _x, y = _y; }
  friend Node operator+(Node a, Node b) { return Node(a.x + b.x, a.y + b.y); }
  friend Node operator-(Node a, Node b) { return Node(a.x - b.x, a.y - b.y); }
  friend long long operator/(Node a, Node b) {
    return 1ll * a.x * b.y - 1ll * a.y * b.x;
  }
  long long find_len() { return 1ll * x * x + 1ll * y * y; }
} a[Maxn * 6 + 5];
Node S;
bool cmp_1_less(Node a, Node b) {
  if (a.x == b.x) {
    return a.y < b.y;
  }
  return a.x < b.x;
}
bool cmp_1_equal(Node a, Node b) { return a.x == b.x && a.y == b.y; }
bool cmp_2(Node a, Node b) {
  if ((a - S) / (b - S) == 0) {
    return (a - S).find_len() < (b - S).find_len();
  }
  return (a - S) / (b - S) > 0;
}
int len;
int st[Maxn * 6 + 5], st_top;
int main() {
  scanf("%d", &n);
  for (int i = 1; i <= n; i++) {
    int x, y, v;
    scanf("%d%d%d", &x, &y, &v);
    if (x < v) {
      a[++len] = Node(0, std::max(y - v + x, 0));
      a[++len] = Node(0, std::min(y + v - x, Maxv));
    } else {
      a[++len] = Node(x - v, y);
    }
    if (x + v > Maxv) {
      a[++len] = Node(Maxv, std::max(y - v + (Maxv - x), 0));
      a[++len] = Node(Maxv, std::min(y + v - (Maxv - x), Maxv));
    } else {
      a[++len] = Node(x + v, y);
    }
    if (y < v) {
      a[++len] = Node(std::max(x - v + y, 0), 0);
      a[++len] = Node(std::min(x + v - y, Maxv), 0);
    } else {
      a[++len] = Node(x, y - v);
    }
    if (y + v > Maxv) {
      a[++len] = Node(std::max(x - v + (Maxv - y), 0), Maxv);
      a[++len] = Node(std::min(x + v - (Maxv - y), Maxv), Maxv);
    } else {
      a[++len] = Node(x, y + v);
    }
  }
  std::sort(a + 1, a + 1 + len, cmp_1_less);
  len = std::unique(a + 1, a + 1 + len, cmp_1_equal) - a - 1;
  S = a[1];
  std::sort(a + 2, a + 1 + len, cmp_2);
  st[++st_top] = 1;
  for (int i = 2; i <= len; i++) {
    while (st_top > 1 &&
           (a[i] - a[st[st_top]]) / (a[st[st_top]] - a[st[st_top - 1]]) >= 0) {
      st_top--;
    }
    st[++st_top] = i;
  }
  st[0] = st[st_top], st[st_top + 1] = st[1];
  int pos = -1;
  double ans = 0;
  for (int i = 1; i <= st_top; i++) {
    Node e_a = a[st[i]] - a[st[i - 1]], e_b = a[st[i + 1]] - a[st[i]],
         e_c = a[st[i + 1]] - a[st[i - 1]];
    double tmp = sqrt(e_a.find_len()) * sqrt(e_b.find_len()) *
                 sqrt(e_c.find_len()) / (std::abs(e_a / e_b));
    if (tmp > ans) {
      pos = i;
      ans = tmp;
    }
  }
  printf("%d %d\n", a[st[pos - 1]].x, a[st[pos - 1]].y);
  printf("%d %d\n", a[st[pos]].x, a[st[pos]].y);
  printf("%d %d\n", a[st[pos + 1]].x, a[st[pos + 1]].y);
  return 0;
}

```