#include <bits/stdc++.h>
using namespace std;
const int M = 500010, mod = 1000000007;
const double PI = acos(-1.0);
class PT {
 public:
  double first, second;
  PT() {}
  PT(double first, double second) : first(first), second(second) {}
  PT(const PT &p) : first(p.first), second(p.second) {}
  double Magnitude() { return sqrt(first * first + second * second); }
  PT operator+(const PT &p) const {
    return PT(first + p.first, second + p.second);
  }
  PT operator-(const PT &p) const {
    return PT(first - p.first, second - p.second);
  }
  PT operator*(double c) const { return PT(first * c, second * c); }
  PT operator/(double c) const { return PT(first / c, second / c); }
};
double dot(PT p, PT q) { return p.first * q.first + p.second * q.second; }
double dist2(PT p, PT q) { return dot(p - q, p - q); }
double dist(PT p, PT q) { return sqrt(dist2(p, q)); }
double cross(PT p, PT q) { return p.first * q.second - p.second * q.first; }
double myAsin(double a, double b) {
  if (a / b > 1) return PI * 0.5;
  if (a / b < -1) return -PI * 0.5;
  return asin(a / b);
}
double myAtan(double a, double b) {
  if (b == 0) return PI * 0.5;
  return atan(a / b);
}
ostream &operator<<(ostream &os, const PT &p) {
  os << "(" << p.first << "," << p.second << ")";
}
PT scale(PT p, PT pivot, double c) {
  PT trans = p - pivot;
  trans = (trans * c) / trans.Magnitude();
  return trans + pivot;
}
PT RotateCCW90(PT p) { return PT(-p.second, p.first); }
PT RotateCW90(PT p) { return PT(p.second, -p.first); }
PT RotateCCW(PT p, double t) {
  return PT(p.first * cos(t) - p.second * sin(t),
            p.first * sin(t) + p.second * cos(t));
}
PT RotateAroundPointCCW(PT p, PT pivot, double t) {
  PT trans = p - pivot;
  PT ret = RotateCCW(trans, t);
  ret = ret + pivot;
  return ret;
}
PT Reflection(PT ray, PT normal) {
  ray = ray / ray.Magnitude();
  normal = normal / normal.Magnitude();
  return normal * (2 * dot(ray, normal)) - ray;
}
PT ProjectPointLine(PT a, PT b, PT c) {
  return a + (b - a) * dot(c - a, b - a) / dot(b - a, b - a);
}
double DistancePointLine(PT a, PT b, PT c) {
  return dist(c, ProjectPointLine(a, b, c));
}
PT ProjectPointSegment(PT a, PT b, PT c) {
  double r = dot(b - a, b - a);
  if (fabs(r) < 1e-12) return a;
  r = dot(c - a, b - a) / r;
  if (r < 0) return a;
  if (r > 1) return b;
  return a + (b - a) * r;
}
double DistancePointSegment(PT a, PT b, PT c) {
  return sqrt(dist2(c, ProjectPointSegment(a, b, c)));
}
double DistancePointPlane(double first, double second, double z, double a,
                          double b, double c, double d) {
  return fabs(a * first + b * second + c * z - d) / sqrt(a * a + b * b + c * c);
}
bool LinesParallel(PT a, PT b, PT c, PT d) {
  return fabs(cross(b - a, c - d)) < 1e-12;
}
bool LinesCollinear(PT a, PT b, PT c, PT d) {
  return LinesParallel(a, b, c, d) && fabs(cross(a - b, a - c)) < 1e-12 &&
         fabs(cross(c - d, c - a)) < 1e-12;
}
bool SegmentsIntersect(PT a, PT b, PT c, PT d) {
  if (LinesCollinear(a, b, c, d)) {
    if (dist2(a, c) < 1e-12 || dist2(a, d) < 1e-12 || dist2(b, c) < 1e-12 ||
        dist2(b, d) < 1e-12)
      return true;
    if (dot(c - a, c - b) > 0 && dot(d - a, d - b) > 0 && dot(c - b, d - b) > 0)
      return false;
    return true;
  }
  if (cross(d - a, b - a) * cross(c - a, b - a) > 0) return false;
  if (cross(a - c, d - c) * cross(b - c, d - c) > 0) return false;
  return true;
}
PT ComputeLineIntersection(PT a, PT b, PT c, PT d) {
  b = b - a;
  d = c - d;
  c = c - a;
  assert(dot(b, b) > 1e-12 && dot(d, d) > 1e-12);
  return a + b * cross(c, d) / cross(b, d);
}
PT ComputeCircleCenter(PT a, PT b, PT c) {
  b = (a + b) / 2;
  c = (a + c) / 2;
  return ComputeLineIntersection(b, b + RotateCW90(a - b), c,
                                 c + RotateCW90(a - c));
}
bool PointInPolygon(const vector<PT> &p, PT q) {
  bool c = 0;
  for (int i = 0; i < p.size(); i++) {
    int j = (i + 1) % p.size();
    if ((p[i].second <= q.second && q.second < p[j].second ||
         p[j].second <= q.second && q.second < p[i].second) &&
        q.first < p[i].first + (p[j].first - p[i].first) *
                                   (q.second - p[i].second) /
                                   (p[j].second - p[i].second))
      c = !c;
  }
  return c;
}
bool PointOnPolygon(const vector<PT> &p, PT q) {
  for (int i = 0; i < p.size(); i++)
    if (dist2(ProjectPointSegment(p[i], p[(i + 1) % p.size()], q), q) < 1e-12)
      return true;
  return false;
}
vector<PT> CircleLineIntersection(PT a, PT b, PT c, double r) {
  vector<PT> ret;
  b = b - a;
  a = a - c;
  double A = dot(b, b);
  double B = dot(a, b);
  double C = dot(a, a) - r * r;
  double D = B * B - A * C;
  if (D < -1e-12) return ret;
  ret.push_back(c + a + b * (-B + sqrt(D + 1e-12)) / A);
  if (D > 1e-12) ret.push_back(c + a + b * (-B - sqrt(D)) / A);
  return ret;
}
vector<PT> CircleCircleIntersection(PT a, PT b, double r, double R) {
  vector<PT> ret;
  double d = sqrt(dist2(a, b));
  if (d > r + R || d + min(r, R) < max(r, R)) return ret;
  double first = (d * d - R * R + r * r) / (2 * d);
  double second = sqrt(r * r - first * first);
  PT v = (b - a) / d;
  ret.push_back(a + v * first + RotateCCW90(v) * second);
  if (second > 0) ret.push_back(a + v * first - RotateCCW90(v) * second);
  return ret;
}
double ComputeSignedArea(const vector<PT> &p) {
  double area = 0;
  for (int i = 0; i < p.size(); i++) {
    int j = (i + 1) % p.size();
    area += p[i].first * p[j].second - p[j].first * p[i].second;
  }
  return area / 2.0;
}
double ComputeArea(const vector<PT> &p) { return fabs(ComputeSignedArea(p)); }
PT ComputeCentroid(const vector<PT> &p) {
  PT c(0, 0);
  double scale = 6.0 * ComputeSignedArea(p);
  for (int i = 0; i < p.size(); i++) {
    int j = (i + 1) % p.size();
    c = c +
        (p[i] + p[j]) * (p[i].first * p[j].second - p[j].first * p[i].second);
  }
  return c / scale;
}
bool IsSimple(const vector<PT> &p) {
  for (int i = 0; i < p.size(); i++) {
    for (int k = i + 1; k < p.size(); k++) {
      int j = (i + 1) % p.size();
      int l = (k + 1) % p.size();
      if (i == l || j == k) continue;
      if (SegmentsIntersect(p[i], p[j], p[k], p[l])) return false;
    }
  }
  return true;
}
double PAngle(PT a, PT b, PT c) {
  PT temp1(a.first - b.first, a.second - b.second),
      temp2(c.first - b.first, c.second - b.second);
  double ans = asin((temp1.first * temp2.second - temp1.second * temp2.first) /
                    (temp1.Magnitude() * temp2.Magnitude()));
  if ((ans < 0 &&
       (temp1.first * temp2.first + temp1.second * temp2.second) < 0) ||
      (ans >= 0 &&
       (temp1.first * temp2.first + temp1.second * temp2.second) < 0))
    ans = PI - ans;
  ans = ans < 0 ? 2 * PI + ans : ans;
  return ans;
}
double SignedArea(PT a, PT b, PT c) {
  PT temp1(b.first - a.first, b.second - a.second),
      temp2(c.first - a.first, c.second - a.second);
  return 0.5 * (temp1.first * temp2.second - temp1.second * temp2.first);
}
bool XYasscending(PT a, PT b) {
  if (abs(a.first - b.first) < 1e-12) return a.second < b.second;
  return a.first < b.first;
}
void MakeConvexHull(vector<PT> given, vector<PT> &ans) {
  int i, n = given.size(), j = 0, k = 0;
  vector<PT> U, L;
  ans.clear();
  sort(given.begin(), given.end(), XYasscending);
  for (i = 0; i < n; i++) {
    while (true) {
      if (j < 2) break;
      if (SignedArea(L[j - 2], L[j - 1], given[i]) <= 0)
        j--;
      else
        break;
    }
    if (j == L.size()) {
      L.push_back(given[i]);
      j++;
    } else {
      L[j] = given[i];
      j++;
    }
  }
  for (i = n - 1; i >= 0; i--) {
    while (1) {
      if (k < 2) break;
      if (SignedArea(U[k - 2], U[k - 1], given[i]) <= 0)
        k--;
      else
        break;
    }
    if (k == U.size()) {
      U.push_back(given[i]);
      k++;
    } else {
      U[k] = given[i];
      k++;
    }
  }
  for (i = 0; i < j - 1; i++) ans.push_back(L[i]);
  for (i = 0; i < k - 1; i++) ans.push_back(U[i]);
}
vector<PT> p, h;
vector<pair<long long, long long> > hull;
double area(int a, int b, int c) {
  PT p(hull[a].first, hull[a].second);
  PT q(hull[b].first, hull[b].second);
  PT r(hull[c].first, hull[c].second);
  return fabs(SignedArea(p, q, r));
}
int main() {
  int n, i, j, k;
  double s;
  PT tmp;
  cin >> n >> s;
  for (i = 0; i < n; i++) {
    cin >> tmp.first >> tmp.second;
    p.push_back(tmp);
  }
  MakeConvexHull(p, h);
  for (i = 0; i < h.size(); i++)
    hull.push_back(make_pair((long long)h[i].first, (long long)h[i].second));
  n = hull.size();
  double maxx = 0;
  int I, J, K;
  for (i = 0; i < n; i++) hull.push_back(hull[i]);
  for (i = 0; i < n; i++) {
    j = i + 1;
    k = j + 1;
    int m = i + n;
    while (j < m) {
      while (k <= j) k++;
      while (k < m && area(i, j, k) <= area(i, j, k + 1)) k++;
      if (area(i, j, k) > maxx) {
        maxx = area(i, j, k);
        I = i;
        J = j;
        K = k;
      }
      j++;
    }
  }
  long long ax = hull[I].first + hull[J].first - hull[K].first;
  long long bx = hull[J].first + hull[K].first - hull[I].first;
  long long cx = hull[K].first + hull[I].first - hull[J].first;
  long long ay = hull[I].second + hull[J].second - hull[K].second;
  long long by = hull[J].second + hull[K].second - hull[I].second;
  long long cy = hull[K].second + hull[I].second - hull[J].second;
  cout << fixed << setprecision(11);
  cout << ax << " " << ay << endl;
  cout << bx << " " << by << endl;
  cout << cx << " " << cy << endl;
  return 0;
}
