#include <bits/stdc++.h>
using namespace std;
namespace Geometry {
const double eps = 1e-8;
inline int Cmp(const double x) {
  if (fabs(x) < eps) return 0;
  return x < 0 ? -1 : 1;
}
class Point {
 public:
  double x, y;
  Point(double x = 0, double y = 0) : x(x), y(y) {}
  inline std::istream friend &operator>>(std::istream &cin, Point &a) {
    return cin >> a.x >> a.y;
  }
  inline std::ostream friend &operator<<(std::ostream &cout, Point a) {
    return cout << (long long)a.x << ' ' << (long long)a.y;
  }
  bool friend operator<(const Point a, const Point b) {
    return a.x != b.x ? a.x < b.x : a.y < b.y;
  }
};
class Line {
 public:
  Point p;
  Point v;
  double ang;
  Line() {}
  Line(Point p, Point v) : p(p), v(v) { ang = atan2(v.y, v.x); }
  inline bool friend operator<(const Line a, const Line b) {
    return a.ang < b.ang;
  }
};
Point operator+(Point a, Point b) { return Point(a.x + b.x, a.y + b.y); }
Point operator-(Point a, Point b) { return Point(a.x - b.x, a.y - b.y); }
Point operator*(Point a, double b) { return Point(a.x * b, a.y * b); }
Point operator/(Point a, double b) { return Point(a.x / b, a.y / b); }
bool operator==(Point a, Point b) {
  return (fabs(a.x - b.x) < eps && fabs(a.y - b.y) < eps);
}
inline double dot(Point a, Point b) { return a.x * b.x + a.y * b.y; }
inline double cross(Point a, Point b) { return a.x * b.y - a.y * b.x; }
inline double length(Point a) { return sqrt(dot(a, a)); }
inline double angle(Point a, Point b) {
  return acos(dot(a, b) / (length(a) * length(b)));
}
inline bool onleft(Line l, Point p) { return Cmp(cross(l.v, p - l.p)) > 0; }
inline bool onsegment(Point p, Point a1, Point a2) {
  return (Cmp(cross(a1 - p, a2 - p) == 0) && Cmp(dot(a1 - p, a2 - p)) < 0);
}
inline Point rotate(const Point a, const double rad) {
  double c = cos(rad), s = sin(rad);
  return Point(a.x * c - a.y * s, a.x * s + a.y * c);
}
inline Point normal(const Point a) {
  double l = length(a);
  return Point(-a.y / l, a.x / l);
}
inline bool segmentprointersection(Point a, Point b, Point c, Point d) {
  double c1 = cross(b - a, c - a), c2 = cross(b - a, d - a);
  double d1 = cross(d - c, a - c), d2 = cross(d - c, b - c);
  return (Cmp(c1) * Cmp(c2) < 0 && Cmp(d1) * Cmp(d2) < 0);
}
inline Point LineIntersection(Point a, Point a0, Point b, Point b0) {
  double a1, b1, c1, a2, b2, c2;
  a1 = a.y - a0.y;
  b1 = a0.x - a.x;
  c1 = cross(a, a0);
  a2 = b.y - b0.y;
  b2 = b0.x - b.x;
  c2 = cross(b, b0);
  double d = a1 * a2 - a2 * b1;
  return Point((b1 * c2 - b2 * c1) / d, (c1 * a2 - c2 * a1) / d);
}
inline Point LineIntersection(Line a, Line b) {
  return LineIntersection(a.p, a.p + a.v, b.p, b.p + b.v);
}
inline double distancetoline(Point p, Point a, Point b) {
  Point v = p - a, u = b - a;
  return fabs(cross(v, u)) / length(u);
}
inline double distancetosegment(Point p, Point a, Point b) {
  if (a == b) return length(p - a);
  Point v1 = b - a, v2 = p - a, v3 = p - b;
  if (Cmp(dot(v1, v2)) < 0) return length(v2);
  if (Cmp(dot(v1, v3)) > 0) return length(v3);
  return fabs(cross(v1, v2)) / length(v1);
}
inline std::vector<Point> Convex(std::vector<Point> e) {
  sort(e.begin(), e.end());
  e.erase(unique(e.begin(), e.end()), e.end());
  int m = 0, n = e.size();
  std::vector<Point> ch(n + 1);
  for (int i = 0; i < n; ++i) {
    while (m > 1 && cross(ch[m - 1] - ch[m - 2], e[i] - ch[m - 2]) <= 0) m--;
    ch[m++] = e[i];
  }
  int k = m;
  for (int i = n - 2; i >= 0; --i) {
    while (m > k && cross(ch[m - 1] - ch[m - 2], e[i] - ch[m - 2]) <= 0) m--;
    ch[m++] = e[i];
  }
  if (n > 1) m--;
  ch.resize(m);
  return ch;
}
}  // namespace Geometry
using namespace Geometry;
int n;
long long SS;
Point p, A, B, C;
std::vector<Point> poly, Con;
double Max;
int main() {
  ios::sync_with_stdio(0);
  cin >> n >> SS;
  for (int i = 1; i <= n; ++i) {
    cin >> p;
    poly.push_back(p);
  }
  Con = Convex(poly);
  int siz = Con.size();
  for (int i = 0; i < siz; ++i) {
    for (int j = i + 1, k = ((j == siz - 1) ? 0 : j + 1); j < siz && k != i;
         ++j) {
      while (Cmp(cross(Con[j] - Con[i], Con[k] - Con[i]) -
                 cross(Con[j] - Con[i], Con[k + 1] - Con[i])) < 0)
        k = ((k == siz - 1) ? 0 : (k + 1));
      if (k != i && k != j) {
        double S = cross(Con[j] - Con[i], Con[k] - Con[i]);
        if (S > Max) Max = S, A = Con[i], B = Con[j], C = Con[k];
      }
    }
  }
  cout << (A - C + B) << endl << (B - A + C) << endl << (C - B + A) << endl;
  return 0;
}
