Problem: There is a strange peculiarity: if you connect the cities of Rostov, Taganrog and Shakhty, peculiarly, you get a triangle

«Unbelievable But True»

Students from many different parts of Russia and abroad come to Summer Informatics School. You marked the hometowns of the SIS participants on a map.

Now you decided to prepare an interesting infographic based on this map. The first thing you chose to do is to find three cities on this map, such that they form a triangle with area S.

Input

The first line of input contains two integers n and S (3 ≤ n ≤ 2000, 1 ≤ S ≤ 2 ⋅ 10^{18}) — the number of cities on the map and the area of the triangle to be found.

The next n lines contain descriptions of the cities, one per line. Each city is described by its integer coordinates x_i, y_i (-10^9 ≤ x_i, y_i ≤ 10^9). 

It is guaranteed that all cities are located at distinct points. It is also guaranteed that no three cities lie on the same line.

Output

If the solution doesn't exist — print «No».

Otherwise, print «Yes», followed by three pairs of coordinates (x, y) — the locations of the three cities, which form the triangle of area S.

Examples

Input

3 7
0 0
3 0
0 4


Output

No


Input

4 3
0 0
2 0
1 2
1 3


Output

Yes
0 0
1 3
2 0

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
const int N = 500050;
const int inf = 0x3f3f3f3f;
const long long llinf = 0x3f3f3f3f3f3f3f3f;
const int mod = 998244353;
const int MOD = 1e9 + 7;
const double PI = acos(-1.0);
clock_t TIME__START, TIME__END;
void program_end() {}
const double eps = 1e-6;
double dcmp(double x) {
  if (abs(x) < eps)
    return 0;
  else
    return x < 0 ? -1 : 1;
}
struct Point {
  double x, y;
  int id;
  Point() = default;
  Point(double x, double y) : x(x), y(y) {}
  bool operator==(const Point &a) const {
    return (abs(x - a.x) <= eps && abs(y - a.y) <= eps);
  }
  Point operator+(const Point &a) const { return Point(x + a.x, y + a.y); }
  Point operator-(const Point &a) const { return Point(x - a.x, y - a.y); }
  Point operator-() const { return Point(-x, -y); }
  Point operator*(const double &k) const { return Point(k * x, k * y); }
  Point operator/(const double &k) const { return Point(x / k, y / k); }
  double operator*(const Point &a) const { return x * a.x + y * a.y; }
  double operator^(const Point &a) const { return x * a.y - y * a.x; }
  bool operator<(const Point &a) const {
    if (abs(x - a.x) <= eps) return y < a.y - eps;
    return x < a.x - eps;
  }
  bool is_par(const Point &a) const { return abs((*this) ^ a) <= eps; }
  bool is_ver(const Point &a) const { return abs((*this) * a) <= eps; }
  int toleft(const Point &a) const {
    auto t = (*this) ^ a;
    return (t > eps) - (t < -eps);
  }
  double len() const { return sqrt((*this) * (*this)); }
  double dis(const Point &a) const { return (a - (*this)).len(); }
  double ang(const Point &a) const {
    return acos(((*this) * a) / (this->len() * a.len()));
  }
  Point rot(const double &rad) const {
    return Point(x * cos(rad) - y * sin(rad), x * sin(rad) + y * cos(rad));
  }
};
struct Line {
  Point p, v;
  Line() = default;
  Line(Point p, Point v) : p(p), v(v) {}
  bool operator==(const Line &a) const {
    return (v.is_par(a.v) && v.is_par(p - a.p));
  }
  bool is_par(const Line &a) const {
    return (v.is_par(a.v) && !v.is_par(p - a.p));
  }
  bool is_ver(const Line &a) const { return v.is_ver(a.v); }
  bool is_on(const Point &a) const { return v.is_par(a - p); }
  int toleft(const Point &a) const { return v.toleft(a - p); }
  Point inter(const Line &a) const {
    return p + v * ((a.v ^ (p - a.p)) / (v ^ a.v));
  }
  double dis(const Point &a) const { return abs(v ^ (a - p)) / v.len(); }
  Point proj(const Point &a) const { return p + v * ((v * (a - p)) / (v * v)); }
};
struct Segment {
  Point a, b;
  double k;
  Segment() = default;
  Segment(Point a, Point b) : a(a), b(b) {}
  bool is_on(const Point &c) const {
    return c == a || c == b ||
           ((c - a).is_par(b - c) && (c - a) * (b - c) >= -eps);
  }
  Point inter(const Segment &c) const {
    return Line(a, b - a).inter(Line(c.a, c.b - c.a));
  }
  bool is_cross(const Segment &c) {
    Point p = inter(c);
    return (p - a) * (b - p) >= -eps && (p - c.a) * (c.b - p) >= -eps;
  }
};
struct Polygon {
  vector<Point> p;
  Polygon() = default;
  Polygon(vector<Point> p) : p(move(p)) {}
  inline size_t nxt(const size_t &i) const {
    return i == p.size() - 1 ? 0 : i + 1;
  }
  inline size_t pre(const size_t &i) const {
    return i == 0 ? p.size() - 1 : i - 1;
  }
  bool is_in(const Point &a) const {
    Line l(a, Point(PI, exp(1)));
    int cnt = 0;
    for (size_t i = 0; i < p.size(); i++) {
      if (Segment(p[i], p[nxt(i)]).is_on(a)) return true;
      Point b = l.inter(Line(p[i], p[nxt(i)] - p[i]));
      if (l.v * (b - a) >= -eps && (b - p[i]) * (p[nxt(i)] - b) >= -eps) cnt++;
    }
    return cnt & 1;
  }
  double C() const {
    double sum = 0;
    for (size_t i = 0; i < p.size(); i++) sum += p[i].dis(p[nxt(i)]);
    return sum;
  }
  double S() const {
    double sum = 0;
    for (size_t i = 0; i < p.size(); i++) sum += p[i] ^ p[nxt(i)];
    return abs(sum) / 2;
  }
};
struct Circle {
  Point c;
  double r;
  Circle() = default;
  Circle(Point c, double r) : c(c), r(r) {}
  bool operator==(const Circle &a) const {
    return c == a.c && abs(r - a.r) <= eps;
  }
  double C() const { return 2 * PI * r; }
  double S() const { return PI * r * r; }
  bool is_in(const Point &p) const { return p.dis(c) <= r + eps; }
  vector<Point> inter(const Line &a) const {
    double d = a.dis(c);
    Point p = a.proj(c);
    if (d > r + eps) return vector<Point>();
    if (abs(d - r) <= eps) return vector<Point>{p};
    double l = sqrt(r * r - d * d);
    return vector<Point>{p + (a.v / a.v.len()) * l, p - (a.v / a.v.len()) * l};
  }
  vector<Point> inter(const Circle &a) const {
    double d = c.dis(a.c);
    Point e = a.c - c;
    e = e / e.len();
    if ((*this) == a) return vector<Point>();
    if (d > r + a.r + eps || d < abs(r - a.r) - eps) return vector<Point>();
    if (abs(d - r - a.r) <= eps) return vector<Point>{c + e * r};
    if (abs(d - abs(r - a.r)) <= eps) return vector<Point>{c - e * r};
    double th = acos((r * r + d * d - a.r * a.r) / (2 * r * d));
    return vector<Point>{c + e.rot(th) * r, c + e.rot(-th) * r};
  }
  double inter_S(const Circle &a) const {
    double d = c.dis(a.c);
    if ((*this) == a) return S();
    if (d >= r + a.r - eps) return 0;
    if (d <= abs(r - a.r) + eps) return min(S(), a.S());
    double th1 = acos((r * r + d * d - a.r * a.r) / (2 * r * d)),
           th2 = acos((a.r * a.r + d * d - r * r) / (2 * a.r * d));
    return S() * th1 / PI - r * r * cos(th1) * sin(th1) + a.S() * th2 / PI -
           a.r * a.r * cos(th2) * sin(th2);
  }
};
int n, m, pos[2050], id[2050];
long long S;
Point p[2050];
Segment sg[2050 * 1050];
bool cmp(const Point &x, const Point &y) { return x.x < y.x; }
bool cmpsg(const Segment &x, const Segment &y) { return x.k < y.k; }
inline void solve() {
  scanf("%d%lld", &n, &S);
  for (int i = 1; i <= n; ++i) cin >> p[i].x >> p[i].y, pos[i] = id[i] = i;
  sort(p + 1, p + n + 1, cmp);
  for (int i = 1; i <= n; ++i) p[i].id = i;
  for (int i = 1; i <= n; ++i)
    for (int j = i + 1; j <= n; ++j) {
      ++m;
      sg[m].a = p[i], sg[m].b = p[j];
      if (dcmp(p[i].x - p[j].x) == 0)
        sg[m].k = llinf;
      else
        sg[m].k = (p[i].y - p[j].y) / (p[i].x - p[j].x);
    }
  sort(sg + 1, sg + m + 1, cmpsg);
  for (int i = 1; i <= m; ++i) {
    Point a = sg[i].a, b = sg[i].b;
    if (pos[a.id] > pos[b.id]) swap(a, b);
    Point v1 = a - b;
    int xl = pos[a.id], xr = pos[b.id];
    int l = 1, r = xl - 1;
    while (l <= r) {
      int mid = (l + r) >> 1;
      Point v2 = a - p[mid];
      double area = abs(v1 ^ v2);
      if (dcmp(area - 2 * S) == 0) {
        puts("Yes");
        printf("%.0lf %.0lf\n", p[mid].x, p[mid].y);
        printf("%.0lf %.0lf\n", a.x, a.y);
        printf("%.0lf %.0lf\n", b.x, b.y);
        return;
      }
      if (dcmp(area - 2 * S) == 1)
        l = mid + 1;
      else
        r = mid - 1;
    }
    l = xr + 1, r = n;
    while (l <= r) {
      int mid = (l + r) >> 1;
      Point v2 = a - p[mid];
      double area = abs(v1 ^ v2);
      if (dcmp(area - 2 * S) == 0) {
        puts("Yes");
        printf("%.0lf %.0lf\n", p[mid].x, p[mid].y);
        printf("%.0lf %.0lf\n", a.x, a.y);
        printf("%.0lf %.0lf\n", b.x, b.y);
        return;
      }
      if (dcmp(area - 2 * S) == 1)
        r = mid - 1;
      else
        l = mid + 1;
    }
    swap(pos[a.id], pos[b.id]);
    swap(p[xl], p[xr]);
  }
  puts("No");
}
int main() {
  TIME__START = clock();
  int Test = 1;
  while (Test--) {
    solve();
  }
  TIME__END = clock();
  program_end();
  return 0;
}