#include <bits/stdc++.h>
#pragma clang diagnostic ignored "-Wc++98-compat-pedantic"
#pragma clang diagnostic ignored "-Wunused-macros"
#pragma clang diagnostic ignored "-Wmissing-prototypes"
#pragma clang diagnostic ignored "-Wsign-conversion"
#pragma clang diagnostic ignored "-Wsign-compare"
using namespace std;
static bool debug = false;
template <typename T, typename Q, typename S>
bool Bounded(const T &x, const Q &a, const S &b) {
  return a <= x && x <= b;
}
template <typename T>
int sz(const T &x) {
  return x.size();
}
template <typename T, typename Q>
bool mem(const T &s, const Q &x) {
  return s.find(x) != s.end();
}
template <typename T>
void push(vector<T> &c, const T &e) {
  c.push_back(e);
}
template <typename T>
void push(queue<T> &c, const T &e) {
  c.push(e);
}
template <typename T>
void push(set<T> &c, const T &e) {
  c.insert(e);
}
template <typename T, typename... Args>
auto emplace(vector<T> &c, Args &&...args)
    -> decltype(c.emplace_back(args...)) {
  c.emplace_back(args...);
}
template <typename T, typename... Args>
auto emplace(queue<T> &c, Args &&...args) -> decltype(c.emplace(args...)) {
  c.emplace(args...);
}
template <typename T, typename... Args>
auto emplace(set<T> &c, Args &&...args) -> decltype(c.emplace(args...)) {
  c.emplace(args...);
}
template <typename T>
void umin(T &x, const T &y) {
  x = min(x, y);
}
template <typename T>
void umax(T &x, const T &y) {
  x = max(x, y);
}
template <typename T>
int sign(const T &x) {
  return x == 0 ? 0 : x > 0 ? 1 : -1;
}
template <typename T>
T square(const T &x) {
  return x * x;
}
template <typename S, typename T>
istream &operator>>(istream &in, pair<S, T> &p) {
  return in >> p.first >> p.second;
}
template <typename T, typename I = typename T::iterator>
void read(T &cnt) {
  for (auto &x : cnt) cin >> x;
}
template <typename S, typename T>
ostream &operator<<(ostream &out, const pair<S, T> &p) {
  return out << "{" << p.first << ", " << p.second << "}";
}
template <typename T>
struct show_container {
  const T &container;
  show_container(const T &container_) : container(container_) {}
};
template <typename T>
ostream &operator<<(ostream &o, const show_container<T> &thing) {
  bool first = true;
  o << "{";
  for (const auto &x : thing.container) {
    if (!first) o << ", ";
    first = false;
    o << x;
  }
  o << "}";
  return o;
}
template <typename T>
show_container<T> show(const T &container) {
  return show_container<T>(container);
}
struct dout_ {
} dout;
template <typename T>
dout_ &operator<<(dout_ &out, const T &thing) {
  if (debug) cout << thing;
  return out;
}
dout_ &operator<<(dout_ &out, ostream &(*thing)(ostream &)) {
  if (debug) cout << thing;
  return out;
}
struct outboth {
  ostream &a;
  ostream &b;
  outboth(ostream &a_, ostream &b_) : a(a_), b(b_) {}
};
template <typename T>
outboth &operator<<(outboth &both, const T &thing) {
  both.a << thing;
  both.b << thing;
  return both;
}
outboth &operator<<(outboth &both, ostream &(*thing)(ostream &)) {
  both.a << thing;
  both.b << thing;
  return both;
}
struct ScopeTiming_impl {
  string filename, function;
  int lineno;
  string label;
  int *counter;
  chrono::time_point<std::chrono::high_resolution_clock> startTime, endTime;
  ScopeTiming_impl(string filename_ = "<no file>", string function_ = "<>",
                   int lineno_ = -1, string label = "", int *counter_ = nullptr)
      : filename(filename_),
        function(function_),
        lineno(lineno_),
        label(label),
        counter(counter_) {
    startTime = std::chrono::high_resolution_clock::now();
  }
  ~ScopeTiming_impl() {
    if (!debug) return;
    endTime = std::chrono::high_resolution_clock::now();
    std::chrono::duration<double> elapsed = endTime - startTime;
    cout << filename << ":" << lineno << ":" << function;
    if (!label.empty()) cout << ":" << label;
    if (counter) cout << "[" << ++*counter << "]";
    cout << ": Time taken: ";
    int oldprec = cout.precision(3);
    auto oldflags = cout.setf(std::ios::fixed);
    cout << (1e3 * elapsed.count()) << "ms." << endl;
    cout.flags(oldflags);
    cout.precision(oldprec);
  }
};
template <typename T>
struct PT {
  T x, y;
  PT() : x(0), y(0) {}
  PT(T x, T y) : x(x), y(y) {}
  template <typename S>
  explicit PT(const PT<S> &p) : x(p.x), y(p.y) {}
  PT &operator+=(PT o) { return *this = *this + o; }
  PT &operator-=(PT o) { return *this = *this - o; }
  PT &operator*=(T o) { return *this = *this * o; }
  PT &operator/=(T o) { return *this = *this / o; }
  PT operator-() const { return PT(-x, -y); }
  PT operator+(PT o) const { return PT(x + o.x, y + o.y); }
  PT operator-(PT o) const { return PT(x - o.x, y - o.y); }
  PT operator*(T t) const { return PT(x * t, y * t); }
  PT operator/(T t) const { return PT(x / t, y / t); }
  T cross(PT o) const { return x * o.y - y * o.x; }
  T dot(PT o) const { return x * o.x + y * o.y; }
  PT cross() const { return PT(-y, x); }
  T abs2() const { return x * x + y * y; }
  T angle() const { return atan2(y, x); }
  T dist(PT o) const { return (*this - o).abs(); }
  T abs() const { return hypot(x, y); }
  PT normalize() const { return *this / abs(); }
  bool operator==(PT o) const { return x == o.x && y == o.y; }
  bool operator<(PT o) const { return tie(x, y) < tie(o.x, o.y); }
  bool operator>(PT o) const { return tie(x, y) > tie(o.x, o.y); }
  bool operator<=(PT o) const { return tie(x, y) <= tie(o.x, o.y); }
  bool operator>=(PT o) const { return tie(x, y) >= tie(o.x, o.y); }
  friend istream &operator>>(istream &i, PT &p) { return i >> p.x >> p.y; }
  friend ostream &operator<<(ostream &o, PT p) {
    return o << "PT(" << p.x << ", " << p.y << ")";
  }
};
template <typename T>
PT<T> operator*(T t, PT<T> p) {
  return p * t;
}
enum CCWt { CCW = 1, COLIN = 0, CW = -1 };
template <typename T>
CCWt ccw(PT<T> a, PT<T> b) {
  return CCWt(sign(a.cross(b)));
}
template <typename T>
CCWt ccw(PT<T> a, PT<T> b, PT<T> c) {
  return CCWt(sign((b - a).cross(c - a)));
}
typedef PT<long long int> P;
void solve(ostream &rout) {
  std::ios::sync_with_stdio(false);
  cin.tie(nullptr);
  int N;
  long long int S;
  cin >> N >> S;
  if (!cin) return;
  vector<P> points(N);
  read(points);
  sort(points.begin(), points.end());
  points.erase(unique(points.begin(), points.end()), points.end());
  while (sz(points) < 3) push(points, points[0]);
  int a = 0, b = 1, c = 2;
  auto eval = [&](int i, int j, int k) -> long long int {
    return abs((points[j] - points[i]).cross(points[k] - points[i]));
  };
  for (bool progress = true; progress;) {
    progress = false;
    long long int s = eval(a, b, c);
    for (int i = 0; i < int(N); ++i) {
      if (eval(a, b, i) > s) c = i, progress = true;
      if (eval(a, i, c) > s) b = i, progress = true;
      if (eval(i, b, c) > s) a = i, progress = true;
    }
  }
  rout << points[a].x + points[b].x - points[c].x << " "
       << points[a].y + points[b].y - points[c].y << "\n"
       << points[a].x + points[c].x - points[b].x << " "
       << points[a].y + points[c].y - points[b].y << "\n"
       << points[c].x + points[b].x - points[a].x << " "
       << points[c].y + points[b].y - points[a].y << "\n";
}
int main() {
  solve(cout);
  return 0;
}
