#include <bits/stdc++.h>
using ul = std::uint32_t;
using li = std::int32_t;
using ull = std::uint64_t;
using ll = std::int64_t;
using vul = std::vector<ul>;
using vvul = std::vector<vul>;
using vb = std::vector<bool>;
using vvb = std::vector<vb>;
using vvvb = std::vector<vvb>;
using vull = std::vector<ull>;
using vvull = std::vector<vull>;
using vli = std::vector<li>;
using vll = std::vector<ll>;
using pulul = std::pair<ul, ul>;
using vpulul = std::vector<pulul>;
ul n;
ll s;
class point {
 public:
  li x = 0;
  li y = 0;
  point() = default;
  point(li a, li b) : x(a), y(b) {}
};
point operator-(const point& a, const point& b) {
  return point(a.x - b.x, a.y - b.y);
}
point operator+(const point& a, const point& b) {
  return point(a.x + b.x, a.y + b.y);
}
ul region(const point& a) {
  if (a.x < 0) {
    if (a.y < 0) {
      return 3;
    } else {
      return 2;
    }
  } else {
    if (a.y < 0) {
      return 4;
    } else {
      return 1;
    }
  }
}
class lessbydir {
 public:
  bool operator()(const point& a, const point& b) {
    if (region(a) != region(b)) {
      return region(a) < region(b);
    } else {
      return ll(a.x) * b.y > ll(b.x) * a.y;
    }
  }
} less;
std::vector<point> points(2000);
vul order(2000);
vul pos(2000);
std::vector<std::pair<ul, ul>> vecs;
ll det(const point& a, const point& b) { return ll(a.x) * b.y - ll(b.x) * a.y; }
ll inner(const point& a, const point& b) {
  return ll(a.x) * b.x + ll(a.y) * b.y;
}
int main() {
  std::ios::sync_with_stdio(false);
  std::cin.tie(0);
  std::cin >> n >> s;
  s <<= 1;
  points.resize(n);
  order.resize(n);
  for (ul i = 0; i != n; ++i) {
    std::cin >> points[i].x >> points[i].y;
    order[i] = i;
  }
  for (ul i = 0; i != n; ++i) {
    for (ul j = 0; j != n; ++j) {
      if (i == j) {
        continue;
      }
      vecs.push_back(std::pair<ul, ul>(i, j));
    }
  }
  std::sort(vecs.begin(), vecs.end(), [&](const pulul& a, const pulul& b) {
    return less(points[a.second] - points[a.first],
                points[b.second] - points[b.first]);
  });
  point dir0 = points[vecs[0].second] - points[vecs[0].first];
  std::sort(order.begin(), order.end(), [&](ul a, ul b) {
    return det(dir0, points[a]) < det(dir0, points[b]);
  });
  for (ul i = 0; i != n; ++i) {
    pos[order[i]] = i;
  }
  for (auto vec : vecs) {
    ul i = vec.first;
    ul j = vec.second;
    ul l = 0, r = n;
    point dir = points[j] - points[i];
    while (l + 1 != r) {
      ul mid = l + r >> 1;
      if (det(dir, points[order[mid]] - points[i]) > s) {
        r = mid;
      } else {
        l = mid;
      }
    }
    if (det(points[j] - points[i], points[order[l]] - points[i]) == s) {
      std::cout << "Yes" << std::endl;
      std::cout << points[i].x << ' ' << points[i].y << std::endl;
      std::cout << points[j].x << ' ' << points[j].y << std::endl;
      std::cout << points[order[l]].x << ' ' << points[order[l]].y << std::endl;
      return 0;
    }
    if (pos[j] > pos[i]) {
      std::swap(order[pos[j]], order[pos[i]]);
      std::swap(pos[j], pos[i]);
    }
  }
  std::cout << "No" << std::endl;
  return 0;
}
