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 long long INF64 = 1e18;
const long long INF32 = 1e9;
const double EPS = static_cast<double>(1e-10);
const double PI = 2.0 * acos(0.0);
const long long MOD = (long long)1e9 + 7;
long long powMod(long long a, long long b) {
  long long res = 1;
  a %= MOD;
  assert(b >= 0);
  for (; b; b >>= 1) {
    if (b & 1) res = res * a % MOD;
    a = a * a % MOD;
  }
  return res;
}
long long invMod(long long a) {
  long long b = MOD, u = 1, v = 0;
  while (b) {
    long long t = a / b;
    a -= t * b;
    swap(a, b);
    u -= t * v;
    swap(u, v);
  }
  return (MOD + u) % MOD;
}
const long long day[12] = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
mt19937 rnd(239);
vector<long long> prefixSum(vector<long long> &a) {
  vector<long long> b;
  std::partial_sum(a.begin(), a.end(), b.begin());
  return b;
}
long long mostSignDigit(long long n) {
  double k = log10(n);
  return (long long)pow(10, k - floor(k));
}
long long numOfDigits(long long n) { return (long long)floor(log10(n)) + 1; }
bool isPowerOfTwo(long long x) { return x && (!(x & (x - 1))); }
bool allPositive(vector<long long> &a) {
  return all_of(begin(a), end(a), [](long long x) { return x > 0; });
}
bool anyPositive(vector<long long> &a) {
  return any_of(begin(a), end(a), [](long long x) { return x > 0; });
}
bool nonePositive(vector<long long> &a) {
  return none_of(begin(a), end(a), [](long long x) { return x > 0; });
}
void FILEIO() {
  freopen("in.txt", "r", stdin);
  freopen("out.txt", "w", stdout);
}
void __print(long long x) { cerr << x; }
void __print(long x) { cerr << x; }
void __print(unsigned x) { cerr << x; }
void __print(unsigned long x) { cerr << x; }
void __print(unsigned long long x) { cerr << x; }
void __print(float x) { cerr << x; }
void __print(double x) { cerr << x; }
void __print(long double x) { cerr << x; }
void __print(char x) { cerr << '\'' << x << '\''; }
void __print(const char *x) { cerr << '\"' << x << '\"'; }
void __print(const string &x) { cerr << '\"' << x << '\"'; }
void __print(bool x) { cerr << (x ? "T" : "F"); }
template <typename T, typename V>
void __print(const pair<T, V> &x) {
  cerr << '{';
  __print(x.first);
  cerr << ',';
  __print(x.second);
  cerr << '}';
}
template <typename T>
void __print(const T &x) {
  long long f = 0;
  cerr << '{';
  for (auto &i : x) cerr << (f++ ? "," : ""), __print(i);
  cerr << "}";
}
void _print() { cerr << "]\n"; }
template <typename T, typename... V>
void _print(T t, V... v) {
  __print(t);
  if (sizeof...(v)) cerr << ", ";
  _print(v...);
}
const double INF = 1e100;
struct Point {
  long long x, y;
  Point() : x(0), y(0) {}
  Point(long long x, long long y) : x(x), y(y) {}
  Point(const Point &p) : x(p.x), y(p.y) {}
  Point operator=(const Point &p) {
    x = p.x, y = p.y;
    return *this;
  }
  Point operator+(const Point &p) const { return Point(x + p.x, y + p.y); }
  Point operator-(const Point &p) const { return Point(x - p.x, y - p.y); }
  Point operator*(double c) const { return Point(x * c, y * c); }
  bool operator==(const Point &p) const {
    return make_pair(x, y) == make_pair(p.x, p.y);
  }
};
double cross(Point p, Point q) { return p.x * q.y - p.y * q.x; }
double area(Point a, Point b, Point c) { return fabs(cross(b - a, c - a)); }
double angle(Point a) {
  if (a.x == 0) {
    if (a.y > 0)
      return PI / 2.0;
    else
      return 3.0 * PI / 2.0;
  }
  if (a.y == 0) {
    if (a.x > 0)
      return 0;
    else
      return PI;
  }
  double res = atan((double)a.y / (double)a.x);
  if (a.x < 0) return res + PI;
  if (a.y < 0) return res + 2.0 * PI;
  return res;
}
long long orientation(Point a, Point b, Point c) {
  double cr = cross(b - a, c - a);
  if (fabs(cr) <= EPS) return 0;
  if (cr > EPS) return 1;
  return -1;
}
bool pointCmp(Point p1, Point p2) {
  return make_pair(p1.y, p1.x) > make_pair(p2.y, p2.x);
}
struct seg {
  Point p;
  long long i, j;
};
bool segCmp(seg s1, seg s2) {
  Point P1 = s1.p, P2 = s2.p;
  if (P1.y < 0 and P2.y >= 0) return true;
  if (P1.y >= 0 and P2.y < 0) return false;
  return orientation(Point(), P1, P2) == 1;
}
vector<Point> vp;
long long n, second;
vector<pair<Point, long long>> points(n);
void yes(Point a, Point b, Point c) {
  cout << "Yes" << endl;
  cout << a.x << " " << a.y << endl;
  cout << b.x << " " << b.y << endl;
  cout << c.x << " " << c.y << endl;
}
bool check(long long a, long long b, long long x) {
  if (area(points[a].first, points[b].first, points[x].first) == 2 * second) {
    yes(points[a].first, points[b].first, points[x].first);
    return true;
  }
  return false;
}
void solve() {
  cin >> n >> second;
  for (long long i = (0); i < (n); i++) {
    Point P;
    cin >> P.x >> P.y;
    vp.push_back(P);
  }
  sort(begin(vp), end(vp), pointCmp);
  vector<long long> location(n);
  points.resize(n);
  for (long long i = (0); i < (n); i++) {
    points[i] = {vp[i], i};
    location[i] = i;
  }
  vector<seg> vs;
  for (long long i = (0); i < (n); i++)
    for (long long j = (i + 1); j < (n); j++) {
      Point pp = points[j].first - points[i].first;
      seg sg = {pp, i, j};
      vs.push_back(sg);
    }
  sort(begin(vs), end(vs), segCmp);
  for (long long i = (0); i < (((long long)(vs).size())); i++) {
    long long a = location[vs[i].i], b = location[vs[i].j];
    long long lo = 0, hi = b;
    while (hi - lo > 1) {
      long long mid = (lo + hi) / 2;
      long long ar = area(points[a].first, points[b].first, points[mid].first);
      if (ar > 2 * second)
        lo = mid;
      else
        hi = mid;
    }
    if (check(a, b, lo) or check(a, b, hi)) return;
    lo = a, hi = n - 1;
    while (hi - lo > 1) {
      long long mid = (lo + hi) / 2;
      long long ar = area(points[a].first, points[b].first, points[mid].first);
      if (ar > 2 * second)
        hi = mid;
      else
        lo = mid;
    }
    if (check(a, b, lo) or check(a, b, hi)) return;
    swap(points[a], points[b]);
    swap(location[vs[i].i], location[vs[i].j]);
  }
  cout << "No" << endl;
}
signed main() {
  ios_base::sync_with_stdio(false);
  cin.tie();
  { solve(); }
  return 0;
}