#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/trie_policy.hpp>
#include <ext/rope>

#pragma 03

using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());

#define fi first
#define se second
#define pb push_back
#define eb emplace_back
#define mp make_pair
#define gcd __gcd
#define fastio ios_base::sync_with_stdio(0); cin.tie(0); cout.tie(0)
#define rep(i, n) for (int i=0; i<(n); i++)
#define rep1(i, n) for (int i=1; i<=(n); i++)
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define endl "\n"

typedef long long ll;
typedef unsigned long long ull;
typedef unsigned uint;
typedef long double ld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;
typedef vector<int> vi;
typedef vector<vector<int>> vvi;
typedef vector<ll> vll;
typedef vector<vector<ll>> vvll;
typedef vector<bool> vb;
typedef vector<vector<bool>> vvb;
template<typename _def> using ordered_set=tree<_def, null_type, less<_def>, rb_tree_tag, tree_order_statistics_node_update>;
typedef trie<string, null_type, trie_string_access_traits<>, pat_trie_tag, trie_prefix_search_node_update> pref_trie;

using pt=pll;
#define x fi
#define y se

bool cw(pt a, pt b, pt c) {
    return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y)<0;
}

bool ccw(pt a, pt b, pt c) {
    return a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y)>0;
}

void make_convex_hull(vector<pt>& a) {
    //cp-algo graham's scan
    if (a.size()==1) return;
    sort(all(a));
    pt p1=a[0], p2=a.back();
    vector<pt> up, down;
    up.pb(p1); down.pb(p1);
    rep1(i, a.size()-1) {
        if (i==a.size()-1||cw(p1, a[i], p2)) {
            while (up.size()>=2&&!cw(up[up.size()-2], up[up.size()-1], a[i])) up.pop_back();
            up.pb(a[i]);
        }
        if (i==a.size()-1||ccw(p1, a[i], p2)) {
            while(down.size()>=2&&!ccw(down[down.size()-2], down[down.size()-1], a[i])) down.pop_back();
            down.pb(a[i]);
        }
    }
    a.clear();
    for (int i=0; i<up.size(); i++) a.pb(up[i]);
    for (int i=down.size()-2; i>0; i--) a.pb(down[i]);
}

ll area(pt a, pt b, pt c) {
    return abs(a.x*(b.y-c.y)+b.x*(c.y-a.y)+c.x*(a.y-b.y));
}

tuple<pt, pt, pt> find_largest_rectangle(vector<pt>& a) {
    const int n=a.size();
    int A=0, B=1, C=2;
    int bA=A, bB=B, bC=C;
    while(1) {
        while(1) {
            while(area(a[A], a[B], a[C])<area(a[A], a[B], a[(C+1)%n])) C=(C+1)%n;
            if(area(a[A], a[B], a[C])<area(a[A], a[(B+1)%n], a[C])) B=(B+1)%n;
            else break;
        }
        if(area(a[A], a[B], a[C])>area(a[bA], a[bB], a[bC])) bA=A, bB=B, bC=C;
        A=(A+1)%n;
        if (A==B) B=(B+1)%n;
        if (B==C) C=(C+1)%n;
        if (A==0) break;
    }
    return make_tuple(a[bA], a[bB], a[bC]);
}

tuple<pt, pt, pt> refl(tuple<pt, pt, pt> a) {
    pt x, y, z;
    tie(x, y, z)=a;
    return make_tuple(mp(x.x+y.x-z.x, x.y+y.y-z.y), mp(x.x-y.x+z.x, x.y-y.y+z.y), mp(-x.x+y.x+z.x, -x.y+y.y+z.y));
}

int32_t main() {
    int n; ll S; cin>>n>>S;
    vector<pt> a(n); rep(i, n) cin>>a[i].x>>a[i].y;
    make_convex_hull(a);
    auto it=refl(find_largest_rectangle(a));
    pt x, y, z; tie(x, y, z)=it;
    cout<<x.fi<<' '<<x.se<<endl<<y.fi<<' '<<y.se<<endl<<z.fi<<' '<<z.se<<endl;
}


#include <bits/stdc++.h>
using namespace std;
struct node {
    int x, y;
    node() {}
    node(int a, int b) : x(a), y(b) {}
    void put() { cout << x << ' ' << y << endl; }
};
node operator+(node a, node b) { return node(a.x + b.x, a.y + b.y); }
node operator-(node a, node b) { return node(a.x - b.x, a.y - b.y); }
int operator*(node a, node b) { return a.x * b.x + a.y * b.y; }
int operator^(node a, node b) { return a.x * b.y - a.y * b.x; }
node a[10000], b[10000];
bool cmp(node a, node b) { return a.x < b.x || a.x == b.x && a.y < b.y; }
int andrew(int n) {
    sort(a + 1, a + 1 + n, cmp);
    int top = 0;
    for (int i = 1; i <= n; i++) {
        while (top > 1 && ((b[top] - b[top - 1]) ^ (a[i] - b[top - 1])) <= 0)
            --top;
        b[++top] = a[i];
    }
    int tem = top;
    for (int i = n - 1; i > 0; i--) {
        while (top > tem && ((b[top] - b[top - 1]) ^ (a[i] - b[top - 1])) <= 0)
            --top;
        b[++top] = a[i];
    }
    if (n > 1) --top;
    return top;
}
int main() {
    ios::sync_with_stdio(false);
    int n;
    double s;
    cin >> n >> s;
    for (int i = 1; i <= n; i++) {
        cin >> a[i].x >> a[i].y;
    }
    int k = andrew(n);
    int mmax = -1;

    node m[3];
    for (int i = 0; i < k; i++) b[i] = b[i + 1];
    for (int i = 0; i < k; i++) {
        int p = (i + 2) % k;
        for (int j = 1; j < k - 1; j++) {
            while (abs((b[i] - b[(p + 1) % k]) ^
                       (b[(i + j) % k] - b[(p + 1) % k])) >
                   abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p])))
                p = (p + 1) % k;
            if (abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p])) > mmax) {
                mmax = abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p]));
                m[0] = b[i];
                m[1] = b[(i + j) % k];
                m[2] = b[p];
            }
        }
    }
    (m[0] + m[1] - m[2]).put();
    (m[1] + m[2] - m[0]).put();
    (m[2] + m[0] - m[1]).put();
}


#include <bits/stdc++.h>
using namespace std;
struct node {
    int x, y;
    node() {}
    node(int a, int b) : x(a), y(b) {}
    void put() { cout << x << ' ' << y << endl; }
};
node operator+(node a, node b) { return node(a.x + b.x, a.y + b.y); }
node operator-(node a, node b) { return node(a.x - b.x, a.y - b.y); }
int operator*(node a, node b) { return a.x * b.x + a.y * b.y; }
int operator^(node a, node b) { return a.x * b.y - a.y * b.x; }
node a[10000], b[10000];
bool cmp(node a, node b) { return a.x < b.x || a.x == b.x && a.y < b.y; }
int andrew(int n) {
    sort(a + 1, a + 1 + n, cmp);
    int top = 0;
    for (int i = 0; i < n; i++) {
        while (top > 1 && ((b[top] - b[top - 1]) ^ (a[i] - b[top - 1])) <= 0)
            --top;
        b[++top] = a[i];
    }
    int tem = top;
    for (int i = n - 1; i > 0; i--) {
        while (top > tem && ((b[top] - b[top - 1]) ^ (a[i] - b[top - 1])) <= 0)
            --top;
        b[++top] = a[i];
    }
    if (n > 1) --top;
    return top;
}
int main() {
    ios::sync_with_stdio(false);
    int n;
    double s;
    cin >> n >> s;
    for (int i = 0; i < n; i++) {
        cin >> a[i].x >> a[i].y;
    }
    int k = andrew(n);
    int mmax = -1;

    node m[3];
    for (int i = 0; i < k; i++) b[i] = b[i + 1];
    for (int i = 0; i < n; i++) {
        int p = (i + 2) % k;
        for (int j = 1; j < k - 1; j++) {
            while (abs((b[i] - b[(p + 1) % k]) ^
                       (b[(i + j) % k] - b[(p + 1) % k])) >
                   abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p])))
                p = (p + 1) % k;
            if (abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p])) ==
                (int)(2 * s + 0.01)) {
                mmax = abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p]));
                m[0] = b[i];
                m[1] = b[(i + j) % k];
                m[2] = b[p];
            }
        }
    }
    (m[0] + m[1] - m[2]).put();
    (m[1] + m[2] - m[0]).put();
    (m[2] + m[0] - m[1]).put();
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
struct node {
    ll x, y;
    node() {}
    node(ll a, ll b) : x(a), y(b) {}
    void put() { cout << x << ' ' << y << endl; }
};
node operator+(node a, node b) { return node(a.x + b.x, a.y + b.y); }
node operator-(node a, node b) { return node(a.x - b.x, a.y - b.y); }
ll operator*(node a, node b) { return a.x * b.x + a.y * b.y; }
ll operator^(node a, node b) { return a.x * b.y - a.y * b.x; }
node a[10000], b[10000];
bool cmp(node a, node b) { return a.x < b.x || a.x == b.x && a.y < b.y; }
ll andrew(ll n) {
    sort(a + 1, a + 1 + n, cmp);
    int top = 0;
    for (int i = 1; i <= n; i++) {
        while (top > 1 && ((b[top] - b[top - 1]) ^ (a[i] - b[top - 1])) <= 0)
            --top;
        b[++top] = a[i];
    }
    int tem = top;
    for (int i = n - 1; i > 0; i--) {
        while (top > tem && ((b[top] - b[top - 1]) ^ (a[i] - b[top - 1])) <= 0)
            --top;
        b[++top] = a[i];
    }
    if (n > 1) --top;
    return top;
}
int main() {
    ios::sync_with_stdio(false);
    ll n;
    double s;
    cin >> n >> s;
    for (int i = 1; i <= n; i++) {
        cin >> a[i].x >> a[i].y;
    }
    ll k = andrew(n);
    ll mmax = -1;

    node m[3];
    for (int i = 0; i < k; i++) b[i] = b[i + 1];
    for (int i = 0; i < k; i++) {
        int p = (i + 2) % k;
        for (int j = 1; j < k - 1; j++) {
            while (abs((b[i] - b[(p + 1) % k]) ^
                       (b[(i + j) % k] - b[(p + 1) % k])) >
                   abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p])))
                p = (p + 1) % k;
            if (abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p])) > mmax) {
                mmax = abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p]));
                m[0] = b[i];
                m[1] = b[(i + j) % k];
                m[2] = b[p];
            }
        }
    }
    (m[0] + m[1] - m[2]).put();
    (m[1] + m[2] - m[0]).put();
    (m[2] + m[0] - m[1]).put();
}


#include <bits/stdc++.h>
using namespace std;
struct node {
    int x, y;
    node() {}
    node(int a, int b) : x(a), y(b) {}
    void put() { cout << x << ' ' << y << endl; }
};
node operator+(node a, node b) { return node(a.x + b.x, a.y + b.y); }
node operator-(node a, node b) { return node(a.x - b.x, a.y - b.y); }
int operator*(node a, node b) { return a.x * b.x + a.y * b.y; }
int operator^(node a, node b) { return a.x * b.y - a.y * b.x; }
node a[10000], b[10000];
bool cmp(node a, node b) { return a.x < b.x || a.x == b.x && a.y < b.y; }
int andrew(int n) {
    sort(a + 1, a + 1 + n, cmp);
    int top = 0;
    for (int i = 0; i < n; i++) {
        while (top > 1 && ((b[top] - b[top - 1]) ^ (a[i] - b[top - 1])) <= 0)
            --top;
        b[++top] = a[i];
    }
    int tem = top;
    for (int i = n - 1; i > 0; i--) {
        while (top > tem && ((b[top] - b[top - 1]) ^ (a[i] - b[top - 1])) <= 0)
            --top;
        b[++top] = a[i];
    }
    if (n > 1) --top;
    return top;
}
int main() {
    ios::sync_with_stdio(false);
    int n;
    double s;
    cin >> n >> s;
    for (int i = 0; i < n; i++) {
        cin >> a[i].x >> a[i].y;
    }
    int k = andrew(n);
    int mmax = -1;

    node m[3];
    for (int i = 0; i < k; i++) b[i] = b[i + 1];
    for (int i = 0; i < n; i++) {
        int p = (i + 2) % k;
        for (int j = 1; j < k - 1; j++) {
            while (abs((b[i] - b[(p + 1) % k]) ^
                       (b[(i + j) % k] - b[(p + 1) % k])) >
                   abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p])))
                p = (p + 1) % k;
            if (abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p])) > mmax) {
                mmax = abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p]));
                m[0] = b[i];
                m[1] = b[(i + j) % k];
                m[2] = b[p];
            }
        }
    }
    (m[0] + m[1] - m[2]).put();
    (m[1] + m[2] - m[0]).put();
    (m[2] + m[0] - m[1]).put();
}


#include <bits/stdc++.h>
using namespace std;
struct node {
    int x, y;
    node() {}
    node(int a, int b) : x(a), y(b) {}
    void put() { cout << x << ' ' << y << endl; }
};
node operator+(node a, node b) { return node(a.x + b.x, a.y + b.y); }
node operator-(node a, node b) { return node(a.x - b.x, a.y - b.y); }
int operator*(node a, node b) { return a.x * b.x + a.y * b.y; }
int operator^(node a, node b) { return a.x * b.y - a.y * b.x; }
node a[10000], b[10000];
bool cmp(node a, node b) { return a.x < b.x || a.x == b.x && a.y < b.y; }
int andrew(int n) {
    sort(a + 1, a + 1 + n, cmp);
    int top = 0;
    for (int i = 0; i < n; i++) {
        while (top > 1 && ((b[top] - b[top - 1]) ^ (a[i] - b[top - 1])) <= 0)
            --top;
        b[++top] = a[i];
    }
    int tem = top;
    for (int i = n - 1; i > 0; i--) {
        while (top > tem && ((b[top] - b[top - 1]) ^ (a[i] - b[top - 1])) <= 0)
            --top;
        b[++top] = a[i];
    }
    if (n > 1) --top;
    return top;
}
int main() {
    ios::sync_with_stdio(false);
    int n;
    double s;
    cin >> n >> s;
    for (int i = 0; i < n; i++) {
        cin >> a[i].x >> a[i].y;
    }
    int k = andrew(n);
    int mmax = -1;

    node m[3];
    for (int i = 0; i < k; i++) b[i] = b[i + 1];
    for (int i = 0; i < k; i++) {
        int p = (i + 2) % k;
        for (int j = 1; j < k - 1; j++) {
            while (abs((b[i] - b[(p + 1) % k]) ^
                       (b[(i + j) % k] - b[(p + 1) % k])) >
                   abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p])))
                p = (p + 1) % k;
            if (abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p])) > mmax) {
                mmax = abs((b[i] - b[p]) ^ (b[(i + j) % k] - b[p]));
                m[0] = b[i];
                m[1] = b[(i + j) % k];
                m[2] = b[p];
            }
        }
    }
    (m[0] + m[1] - m[2]).put();
    (m[1] + m[2] - m[0]).put();
    (m[2] + m[0] - m[1]).put();
}


#include <map>
#include <set>
#include <queue>
#include <cmath>
#include <stack>
#include <bitset>
#include <vector>
#include <string>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

#define PI 3.1415926535897932384626433832795
#define inf 0x3f3f3f3f
#define MAXN 1005
#define MAXM 10005
using namespace std;
typedef long long ll;
const double EPS=1e-6;

ll add(ll a,ll b){
	return a+b;
}

struct P{
	ll x,y;
	P(){}
	P(ll x,ll y) : x(x),y(y){
	}

	P operator +(P p){
		return P(add(x,p.x),add(y,p.y));
	}

	P operator -(P p){
		return P(add(x,-p.x),add(y,-p.y));
	}

	ll dot(P p){
		return add(x*p.x,y*p.y);
	}
	ll det(P p){
		return add(x*p.y,-y*p.x);
	}
};

bool cmp_x(const P&p,const P&q){
	if(p.x!=q.x)return p.x<q.x;
	return p.y<q.y;
}

vector
convex_hull(P* ps,int n){
	sort(ps,ps+n,cmp_x);
	int k=0;
	vector
qs(2*n);
	for(int i=0;i<n;i++){
		while(k>1&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
			k--;
		qs[k++]=ps[i];
	}

	for(int i=n-2,t=k;i>=0;i--){
		while(k>t&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
			k--;
		qs[k++]=ps[i];
	}
	qs.resize(k-1);
	return qs;
}

P ps[MAXN];

//������ʼ��
int main()
{
	//ios::sync_with_stdio(false);
	int n;
	ll s;
	scanf("%d%lld",&n,&s);
	for(int i=0;i<n;i++){
		scanf("%lld%lld",&ps[i].x,&ps[i].y);
	}
	vector
qs=convex_hull(ps,n);

	int len=qs.size();
	ll ans=-1;
	int x,y,z;
	for(int i=0;i<len;i++){
		int j=(i+1)%len;
		int k=(j+1)%len;
		while(j!=i&&k!=i){
			if(ans<abs((qs[j]-qs[i]).det(qs[k]-qs[i]))){
				ans=abs((qs[j]-qs[i]).det(qs[k]-qs[i]));
				x=i;y=j;z=k;
			}
			while((qs[j]-qs[i]).det(qs[k]-qs[i])<0)
				k=(k+1)%len;
			j=(j+1)%len;
		}
	}

	printf("%lld %lld\n",qs[x].x+qs[y].x-qs[z].x,qs[x].y+qs[y].y-qs[z].y);
	printf("%lld %lld\n",qs[x].x-qs[y].x+qs[z].x,qs[x].y-qs[y].y+qs[z].y);
	printf("%lld %lld\n",-qs[x].x+qs[y].x+qs[z].x,-qs[x].y+qs[y].y+qs[z].y);
	return 0;
}


#include <map>
#include <set>
#include <queue>
#include <cmath>
#include <stack>
#include <bitset>
#include <vector>
#include <string>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

#define PI 3.1415926535897932384626433832795
#define inf 0x3f3f3f3f
#define MAXN 1005
#define MAXM 10005
using namespace std;
typedef long long ll;
const double EPS=1e-6;

ll add(ll a,ll b){
	return a+b;
}

struct P{
	ll x,y;
	P(){}
	P(ll x,ll y) : x(x),y(y){
	}

	P operator +(P p){
		return P(add(x,p.x),add(y,p.y));
	}

	P operator -(P p){
		return P(add(x,-p.x),add(y,-p.y));
	}

	ll dot(P p){
		return add(x*p.x,y*p.y);
	}
	ll det(P p){
		return add(x*p.y,-y*p.x);
	}
};

bool cmp_x(const P&p,const P&q){
	if(p.x!=q.x)return p.x<q.x;
	return p.y<q.y;
}

vector
convex_hull(P* ps,int n){
	sort(ps,ps+n,cmp_x);
	int k=0;
	vector
qs(2*n);
	for(int i=0;i<n;i++){
		while(k>1&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
			k--;
		qs[k++]=ps[i];
	}

	for(int i=n-2,t=k;i>=0;i--){
		while(k>t&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
			k--;
		qs[k++]=ps[i];
	}
	qs.resize(k-1);
	return qs;
}

P ps[MAXN];

//������ʼ��
int main()
{
	//ios::sync_with_stdio(false);
	int n;
	ll s;
	scanf("%d%lld",&n,&s);
	for(int i=0;i<n;i++){
		scanf("%lld%lld",&ps[i].x,&ps[i].y);
	}
	vector
qs=convex_hull(ps,n);

	int len=qs.size();
	ll ans=-1;
	int x,y,z;
	for(int i=0;i<len;i++){
		int j=(i+1)%len;
		int k=(j+1)%len;
		while(j!=i&&k!=i){
			if(ans<abs((qs[j]-qs[i]).det(qs[k]-qs[i]))){
				ans=abs((qs[j]-qs[i]).det(qs[k]-qs[i]));
				x=i;y=j;z=k;
			}
			j=(j+1)%len;
		}
	}

	printf("%lld %lld\n",qs[x].x+qs[y].x-qs[z].x,qs[x].y+qs[y].y-qs[z].y);
	printf("%lld %lld\n",qs[x].x-qs[y].x+qs[z].x,qs[x].y-qs[y].y+qs[z].y);
	printf("%lld %lld\n",-qs[x].x+qs[y].x+qs[z].x,-qs[x].y+qs[y].y+qs[z].y);
	return 0;
}


#include <map>
#include <set>
#include <queue>
#include <cmath>
#include <stack>
#include <bitset>
#include <vector>
#include <string>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

#define PI 3.1415926535897932384626433832795
#define inf 0x3f3f3f3f
#define MAXN 5005
#define MAXM 10005
using namespace std;
typedef long long ll;
const double EPS=1e-6;

ll add(ll a,ll b){
	return a+b;
}

struct P{
	ll x,y;
	P(){}
	P(ll x,ll y) : x(x),y(y){
	}

	P operator +(P p){
		return P(add(x,p.x),add(y,p.y));
	}

	P operator -(P p){
		return P(add(x,-p.x),add(y,-p.y));
	}

	ll dot(P p){
		return add(x*p.x,y*p.y);
	}
	ll det(P p){
		return add(x*p.y,-y*p.x);
	}
};

bool cmp_x(const P&p,const P&q){
	if(p.x!=q.x)return p.x<q.x;
	return p.y<q.y;
}

vector
convex_hull(P* ps,int n){
	sort(ps,ps+n,cmp_x);
	int k=0;
	vector
qs(2*n);
	for(int i=0;i<n;i++){
		while(k>1&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
			k--;
		qs[k++]=ps[i];
	}

	for(int i=n-2,t=k;i>=0;i--){
		while(k>t&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
			k--;
		qs[k++]=ps[i];
	}
	qs.resize(k-1);
	return qs;
}

P ps[MAXN];

//������ʼ��
int main()
{
	//ios::sync_with_stdio(false);
	int n;
	ll s;
	scanf("%d%lld",&n,&s);
	for(int i=0;i<n;i++){
		scanf("%lld%lld",&ps[i].x,&ps[i].y);
	}
	vector
qs=convex_hull(ps,n);

	int len=qs.size();
	ll ans=0;
	int x,y,z;
	x=y=z=0;
	for(int i=0;i<len;i++){
		int j=(i+1)%len;
		int k=(j+1)%len;
		while(j!=i&&k!=i){
			if(ans<abs((qs[j]-qs[i]).det(qs[k]-qs[i]))){
				ans=abs((qs[j]-qs[i]).det(qs[k]-qs[i]));
				x=i;y=j;z=k;
			}
			j=(j+1)%len;
		}
	}

	printf("%lld %lld\n",qs[x].x+qs[y].x-qs[z].x,qs[x].y+qs[y].y-qs[z].y);
	printf("%lld %lld\n",qs[x].x-qs[y].x+qs[z].x,qs[x].y-qs[y].y+qs[z].y);
	printf("%lld %lld\n",-qs[x].x+qs[y].x+qs[z].x,-qs[x].y+qs[y].y+qs[z].y);
	return 0;
}


#include <map>
#include <set>
#include <queue>
#include <cmath>
#include <stack>
#include <bitset>
#include <vector>
#include <string>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

#define PI 3.1415926535897932384626433832795
#define inf 0x3f3f3f3f
#define MAXN 5005
#define MAXM 10005
using namespace std;
typedef long long ll;
const double EPS=1e-6;

ll add(ll a,ll b){
	return a+b;
}

struct P{
	ll x,y;
	P(){}
	P(ll x,ll y) : x(x),y(y){
	}

	P operator +(P p){
		return P(add(x,p.x),add(y,p.y));
	}

	P operator -(P p){
		return P(add(x,-p.x),add(y,-p.y));
	}

	ll dot(P p){
		return add(x*p.x,y*p.y);
	}
	ll det(P p){
		return add(x*p.y,-y*p.x);
	}
};

bool cmp_x(const P&p,const P&q){
	if(p.x!=q.x)return p.x<q.x;
	return p.y<q.y;
}

vector
convex_hull(P* ps,int n){
	sort(ps,ps+n,cmp_x);
	int k=0;
	vector
qs(2*n);
	for(int i=0;i<n;i++){
		while(k>1&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
			k--;
		qs[k++]=ps[i];
	}

	for(int i=n-2,t=k;i>=0;i--){
		while(k>t&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
			k--;
		qs[k++]=ps[i];
	}
	qs.resize(k-1);
	return qs;
}

P ps[MAXN];

//������ʼ��
int main()
{
	//ios::sync_with_stdio(false);
	int n;
	ll s;
	scanf("%d%lld",&n,&s);
	for(int i=0;i<n;i++){
		scanf("%lld%lld",&ps[i].x,&ps[i].y);
	}
	vector
qs=convex_hull(ps,n);

	int len=qs.size();
	ll ans=-1;
	int x,y,z;
	x=y=z=0;
	for(int i=0;i<len;i++){
		int j=(i+1)%len;
		int k=(j+1)%len;
		while(j!=i&&k!=i){
			if(ans<abs((qs[j]-qs[i]).det(qs[k]-qs[i]))){
				ans=abs((qs[j]-qs[i]).det(qs[k]-qs[i]));
				x=i;y=j;z=k;
			}
			while((qs[i]-qs[j]).det(qs[(k+1)%n]-qs[k])<0)
				k=(k+1)%len;
			j=(j+1)%len;
		}
	}

	printf("%lld %lld\n",qs[x].x+qs[y].x-qs[z].x,qs[x].y+qs[y].y-qs[z].y);
	printf("%lld %lld\n",qs[x].x-qs[y].x+qs[z].x,qs[x].y-qs[y].y+qs[z].y);
	printf("%lld %lld\n",-qs[x].x+qs[y].x+qs[z].x,-qs[x].y+qs[y].y+qs[z].y);
	return 0;
}


#include <map>
#include <set>
#include <queue>
#include <cmath>
#include <stack>
#include <bitset>
#include <vector>
#include <string>
#include <cstdio>
#include <cstring>
#include <cstdlib>
#include <iostream>
#include <algorithm>

#define PI 3.1415926535897932384626433832795
#define inf 0x3f3f3f3f
#define MAXN 1005
#define MAXM 10005
using namespace std;
typedef long long ll;
const double EPS=1e-6;

ll add(ll a,ll b){
	return a+b;
}

struct P{
	ll x,y;
	P(){}
	P(ll x,ll y) : x(x),y(y){
	}

	P operator +(P p){
		return P(add(x,p.x),add(y,p.y));
	}

	P operator -(P p){
		return P(add(x,-p.x),add(y,-p.y));
	}

	ll dot(P p){
		return add(x*p.x,y*p.y);
	}
	ll det(P p){
		return add(x*p.y,-1ll*y*p.x);
	}
};

bool cmp_x(const P&p,const P&q){
	if(p.x!=q.x)return p.x<q.x;
	return p.y<q.y;
}

vector
convex_hull(P* ps,int n){
	sort(ps,ps+n,cmp_x);
	int k=0;
	vector
qs(2*n);
	for(int i=0;i<n;i++){
		while(k>1&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
			k--;
		qs[k++]=ps[i];
	}

	for(int i=n-2,t=k;i>=0;i--){
		while(k>t&&(qs[k-1]-qs[k-2]).det(ps[i]-qs[k-1])<=0)
			k--;
		qs[k++]=ps[i];
	}
	qs.resize(k-1);
	return qs;
}

P ps[MAXN];

//������ʼ��
int main()
{
	//ios::sync_with_stdio(false);
	int n;
	ll s;
	scanf("%d%lld",&n,&s);
	for(int i=0;i<n;i++){
		scanf("%lld%lld",&ps[i].x,&ps[i].y);
	}
	vector
qs=convex_hull(ps,n);

	int len=qs.size();
	ll ans=-1;
	int x,y,z;
	for(int i=0;i<len;i++){
		int j=(i+1)%len;
		int k=(j+1)%len;
		while(j!=i&&k!=i){
			if(ans<abs((qs[j]-qs[i]).det(qs[k]-qs[i]))){
				ans=abs((qs[j]-qs[i]).det(qs[k]-qs[i]));
				x=i;y=j;z=k;
			}
			while((qs[j]-qs[i]).det(qs[k]-qs[i])<0)
				k=(k+1)%n;
			j=(j+1)%n;
		}
	}

	printf("%lld %lld\n",qs[x].x+qs[y].x-qs[z].x,qs[x].y+qs[y].y-qs[z].y);
	printf("%lld %lld\n",qs[x].x-qs[y].x+qs[z].x,qs[x].y-qs[y].y+qs[z].y);
	printf("%lld %lld\n",-qs[x].x+qs[y].x+qs[z].x,-qs[x].y+qs[y].y+qs[z].y);
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const long long INF = 1e18;
const double eps = 1e-8;
const long long maxn = 200005;

struct point {
	double x, y;
	point(double x = 0, double y = 0):x(x),y(y) {};
};
struct segment { //线段
	point a, b;
};

double dis(point p1, point p2) {
	return sqrt((p2.x-p1.x)*(p2.x-p1.x)+(p2.y-p1.y)*(p2.y-p1.y));   //距离
}
double cross(point A,point B) {
	return A.x*B.y-A.y*B.x;   //叉乘
}
//返回结果为正说明p2在向量p0p1的左边（三点构成逆时针方向）；为负则相反；为0则三点共线(叉积的性质很重要)
double cross(point p0,point p1,point p2) {
	return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);
}
double min(double a, double b, double c) {
	return min(a, min(b, c));
}
double max(double a, double b, double c) {
	return max(a, max(b, c));
}
long long dcmp(double x) { //判断x是=0(0), >0(1), <0(-1);
	if(fabs(x)<eps) return 0;
	return x<0?-1:1;
}
long long dcmp(ll x) { //判断x是=0(0), >0(1), <0(-1);
	if(x==0) return 0;
	return x<0?-1:1;
}
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 p) {
	return point(A.x*p,A.y*p);
}
point operator / (point A,double p) {
	return point(A.x/p,A.y/p);
}
bool operator == (point A,point B) {
	return dcmp(A.x - B.x)==0&&dcmp(A.y-B.y)==0;
}

bool Exclusion(segment p,segment q) { //快速排斥试验
	if(min(p.a.x,p.b.x)-max(q.a.x,q.b.x)>eps||min(p.a.y,p.b.y)-max(q.a.y,q.b.y)>eps||min(q.a.x,q.b.x)-max(p.a.x,p.b.x)>eps||min(q.a.y,q.b.y)-max(p.a.y,p.b.y)>eps)
		return 0;
	return 1;
}
bool Straddling(segment p,segment q) { //跨立实验
	if(dcmp(cross(p.b-p.a,q.a-p.a))*dcmp(cross(p.b-p.a,q.b-p.a))<=0&&dcmp(cross(q.b-q.a,p.a-q.a))*dcmp(cross(q.b-q.a,p.b-q.a))<=0)
		return 1;
	return 0;
}
bool check(segment p,segment q) { //判断两线段是否相交
	if(Exclusion(p, q) && Straddling(p,q))
		return 1;
	return 0;
}
/*------------------------------------------------------------------------------------*/

point plist[maxn], pstack[maxn],X,Y,Z;
bool cmp(const point &p1, const point &p2) {
	double tmp = cross(plist[0], p1, p2);
	if (tmp > 0.0)return true;
	else if (tmp == 0.0 && dis(plist[0], p1) < dis(plist[0], p2))return true;
	else return false;
}

void init(long long n) {
	long long k = 0;
	scanf("%lf%lf", &plist[0].x, &plist[0].y);
	for (long long i = 1; i < n; i++) {
		scanf("%lf%lf", &plist[i].x, &plist[i].y);
		if ((plist[k].y > plist[i].y) || ((plist[k].y == plist[i].y) && (plist[k].x > plist[i].x)))
			k = i;
	}
	swap(plist[0], plist[k]);
	sort(plist+1,plist+n,cmp);
}

long long Graham(long long n) {
	if(n == 1)
		return 1;
	long long top = 1;
	pstack[0] = plist[0];
	pstack[1] = plist[1];
	for (long long i = 2; i < n; i++) {
		while (top>0 && cross(pstack[top - 1], pstack[top], plist[i]) <= 0)top--;
		pstack[++top] = plist[i];
	}
	return top + 1;
}

double convex_minlen(long long n) {
	if(n == 1)
		return 0;
	if(n == 2)
		return dis(pstack[0], pstack[1]);
	double ans = 0;
	long long k = 0;
	pstack[n] = pstack[0];
	for (long long i = 0; i < n; i++) {
		while(cross(pstack[i], pstack[i + 1], pstack[k]) < cross(pstack[i], pstack[i + 1], pstack[k + 1])) {
			k = (k + 1) % n;
		}
		double t1 = dis(pstack[i], pstack[k]);
		double t2 = dis(pstack[i + 1], pstack[k]);
		ans = max(ans, t1, t2);
	}
	return ans;
}
double convex_maxlen(long long n) {
	if(n == 1)
		return 0;
	if(n == 2)
		return dis(pstack[0], pstack[1]);
	double ans = 0;

	for (long long i = 0; i < n - 1; i++) {
		long long k = 0;
		for (long long j = i + 1; j < n; j++) {
			while (cross(pstack[i], pstack[j], pstack[k]) < cross(pstack[i], pstack[j], pstack[k + 1])) {
				k = (k + 1) % n;
			}
			if(cross(pstack[i], pstack[j], pstack[k])>ans) ans=cross(pstack[i], pstack[j], pstack[k]),X=pstack[i],Y=pstack[j],Z=pstack[k];
		}
	}
	return ans;
}
map <pair<int,int>,int> mp;
signed main() {
	long long n,s;
	scanf("%lld%lld",&n,&s);
	init(n);
	n = Graham(n);
	double ans = convex_maxlen(n);
	point a[10]={X+Y-Z,X-Y+Z,Y+Z-X};
//	cout << X.x << " " << X.y << "*\n";
//	cout << Y.x << " " << Y.y << "*\n";
//	cout << Z.x << " " << Z.y << "*\n";
	for(int i=0;i<=2;i++)
	{
	//	cout << a[i].x << " " << a[i].y << "\n";
		cout << floor(a[i].x+0.5) << " " << floor(a[i].y+0.5) << "\n";
	}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const long long INF = 1e18;
const double eps = 1e-8;
const long long maxn = 200005;

struct point {
	double x, y;
	point(double x = 0, double y = 0):x(x),y(y) {};
};
struct segment { //线段
	point a, b;
};

double dis(point p1, point p2) {
	return sqrt((p2.x-p1.x)*(p2.x-p1.x)+(p2.y-p1.y)*(p2.y-p1.y));   //距离
}
double cross(point A,point B) {
	return A.x*B.y-A.y*B.x;   //叉乘
}
//返回结果为正说明p2在向量p0p1的左边（三点构成逆时针方向）；为负则相反；为0则三点共线(叉积的性质很重要)
double cross(point p0,point p1,point p2) {
	return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);
}
double min(double a, double b, double c) {
	return min(a, min(b, c));
}
double max(double a, double b, double c) {
	return max(a, max(b, c));
}
long long dcmp(double x) { //判断x是=0(0), >0(1), <0(-1);
	if(fabs(x)<eps) return 0;
	return x<0?-1:1;
}
long long dcmp(ll x) { //判断x是=0(0), >0(1), <0(-1);
	if(x==0) return 0;
	return x<0?-1:1;
}
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 p) {
	return point(A.x*p,A.y*p);
}
point operator / (point A,double p) {
	return point(A.x/p,A.y/p);
}
bool operator == (point A,point B) {
	return dcmp(A.x - B.x)==0&&dcmp(A.y-B.y)==0;
}

bool Exclusion(segment p,segment q) { //快速排斥试验
	if(min(p.a.x,p.b.x)-max(q.a.x,q.b.x)>eps||min(p.a.y,p.b.y)-max(q.a.y,q.b.y)>eps||min(q.a.x,q.b.x)-max(p.a.x,p.b.x)>eps||min(q.a.y,q.b.y)-max(p.a.y,p.b.y)>eps)
		return 0;
	return 1;
}
bool Straddling(segment p,segment q) { //跨立实验
	if(dcmp(cross(p.b-p.a,q.a-p.a))*dcmp(cross(p.b-p.a,q.b-p.a))<=0&&dcmp(cross(q.b-q.a,p.a-q.a))*dcmp(cross(q.b-q.a,p.b-q.a))<=0)
		return 1;
	return 0;
}
bool check(segment p,segment q) { //判断两线段是否相交
	if(Exclusion(p, q) && Straddling(p,q))
		return 1;
	return 0;
}
/*------------------------------------------------------------------------------------*/

point plist[maxn], pstack[maxn],X,Y,Z;
bool cmp(const point &p1, const point &p2) {
	double tmp = cross(plist[0], p1, p2);
	if (tmp > 0.0)return true;
	else if (tmp == 0.0 && dis(plist[0], p1) < dis(plist[0], p2))return true;
	else return false;
}

void init(long long n) {
	long long k = 0;
	scanf("%lf%lf", &plist[0].x, &plist[0].y);
	for (long long i = 1; i < n; i++) {
		scanf("%lf%lf", &plist[i].x, &plist[i].y);
		if ((plist[k].y > plist[i].y) || ((plist[k].y == plist[i].y) && (plist[k].x > plist[i].x)))
			k = i;
	}
	swap(plist[0], plist[k]);
	sort(plist+1,plist+n,cmp);
}

long long Graham(long long n) {
	if(n == 1)
		return 1;
	long long top = 1;
	pstack[0] = plist[0];
	pstack[1] = plist[1];
	for (long long i = 2; i < n; i++) {
		while (top>0 && cross(pstack[top - 1], pstack[top], plist[i]) <= 0)top--;
		pstack[++top] = plist[i];
	}
	return top + 1;
}

double convex_minlen(long long n) {
	if(n == 1)
		return 0;
	if(n == 2)
		return dis(pstack[0], pstack[1]);
	double ans = 0;
	long long k = 0;
	pstack[n] = pstack[0];
	for (long long i = 0; i < n; i++) {
		while(cross(pstack[i], pstack[i + 1], pstack[k]) < cross(pstack[i], pstack[i + 1], pstack[k + 1])) {
			k = (k + 1) % n;
		}
		double t1 = dis(pstack[i], pstack[k]);
		double t2 = dis(pstack[i + 1], pstack[k]);
		ans = max(ans, t1, t2);
	}
	return ans;
}
double convex_maxlen(long long n) {
	if(n == 1)
		return 0;
	if(n == 2)
		return dis(pstack[0], pstack[1]);
	double ans = 0;

	for (long long i = 0; i < n - 1; i++) {
		long long k = 0;
		for (long long j = i + 1; j < n; j++) {
			while (cross(pstack[i], pstack[j], pstack[k]) < cross(pstack[i], pstack[j], pstack[k + 1])) {
				k = (k + 1) % n;
			}
			if(cross(pstack[i], pstack[j], pstack[k])>ans) ans=cross(pstack[i], pstack[j], pstack[k]) / 2.0,X=pstack[i],Y=pstack[j],Z=pstack[k];
		}
	}
	return ans;
}
map <pair<int,int>,int> mp;
signed main() {
	long long n,s;
	scanf("%lld%lld",&n,&s);
	init(n);
	n = Graham(n);
	double ans = convex_maxlen(n);
	point a[10]={X+Y-Z,X-Y+Z,Y+Z-X};
//	cout << X.x << " " << X.y << "*\n";
//	cout << Y.x << " " << Y.y << "*\n";
//	cout << Z.x << " " << Z.y << "*\n";
	for(int i=0;i<=2;i++)
	{
	//	cout << a[i].x << " " << a[i].y << "\n";
		cout << floor(a[i].x+0.5) << " " << floor(a[i].y+0.5) << "\n";
	}
	return 0;
}


#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const long long INF = 1e18;
const long long eps = 1e-8;
const long long maxn = 200005;

struct point {
	long long x, y;
	point(long long x = 0, long long y = 0):x(x),y(y) {};
};
struct segment { //线段
	point a, b;
};

long long dis(point p1, point p2) {
	return sqrt((p2.x-p1.x)*(p2.x-p1.x)+(p2.y-p1.y)*(p2.y-p1.y));   //距离
}
long long cross(point A,point B) {
	return A.x*B.y-A.y*B.x;   //叉乘
}
//返回结果为正说明p2在向量p0p1的左边（三点构成逆时针方向）；为负则相反；为0则三点共线(叉积的性质很重要)
long long cross(point p0,point p1,point p2) {
	return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);
}
long long min(long long a, long long b, long long c) {
	return min(a, min(b, c));
}
long long max(long long a, long long b, long long c) {
	return max(a, max(b, c));
}
long long dcmp(ll x) { //判断x是=0(0), >0(1), <0(-1);
	if(x==0) return 0;
	return x<0?-1:1;
}
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,long long p) {
	return point(A.x*p,A.y*p);
}
point operator / (point A,long long p) {
	return point(A.x/p,A.y/p);
}
bool operator == (point A,point B) {
	return dcmp(A.x - B.x)==0&&dcmp(A.y-B.y)==0;
}

bool Exclusion(segment p,segment q) { //快速排斥试验
	if(min(p.a.x,p.b.x)-max(q.a.x,q.b.x)>eps||min(p.a.y,p.b.y)-max(q.a.y,q.b.y)>eps||min(q.a.x,q.b.x)-max(p.a.x,p.b.x)>eps||min(q.a.y,q.b.y)-max(p.a.y,p.b.y)>eps)
		return 0;
	return 1;
}
bool Straddling(segment p,segment q) { //跨立实验
	if(dcmp(cross(p.b-p.a,q.a-p.a))*dcmp(cross(p.b-p.a,q.b-p.a))<=0&&dcmp(cross(q.b-q.a,p.a-q.a))*dcmp(cross(q.b-q.a,p.b-q.a))<=0)
		return 1;
	return 0;
}
bool check(segment p,segment q) { //判断两线段是否相交
	if(Exclusion(p, q) && Straddling(p,q))
		return 1;
	return 0;
}
/*------------------------------------------------------------------------------------*/

point plist[maxn], pstack[maxn],X,Y,Z;
bool cmp(const point &p1, const point &p2) {
	long long tmp = cross(plist[0], p1, p2);
	if (tmp > 0.0)return true;
	else if (tmp == 0.0 && dis(plist[0], p1) < dis(plist[0], p2))return true;
	else return false;
}

void init(long long n) {
	long long k = 0;
	scanf("%lld%lld", &plist[0].x, &plist[0].y);
	for (long long i = 1; i < n; i++) {
		scanf("%lld%lld", &plist[i].x, &plist[i].y);
		if ((plist[k].y > plist[i].y) || ((plist[k].y == plist[i].y) && (plist[k].x > plist[i].x)))
			k = i;
	}
	swap(plist[0], plist[k]);
	sort(plist+1,plist+n,cmp);
}

long long Graham(long long n) {
	if(n == 1)
		return 1;
	long long top = 1;
	pstack[0] = plist[0];
	pstack[1] = plist[1];
	for (long long i = 2; i < n; i++) {
		while (top>0 && cross(pstack[top - 1], pstack[top], plist[i]) <= 0)top--;
		pstack[++top] = plist[i];
	}
	return top + 1;
}

long long convex_minlen(long long n) {
	if(n == 1)
		return 0;
	if(n == 2)
		return dis(pstack[0], pstack[1]);
	long long ans = 0;
	long long k = 0;
	pstack[n] = pstack[0];
	for (long long i = 0; i < n; i++) {
		while(cross(pstack[i], pstack[i + 1], pstack[k]) < cross(pstack[i], pstack[i + 1], pstack[k + 1])) {
			k = (k + 1) % n;
		}
		long long t1 = dis(pstack[i], pstack[k]);
		long long t2 = dis(pstack[i + 1], pstack[k]);
		ans = max(ans, t1, t2);
	}
	return ans;
}
long long convex_maxlen(long long n) {
	if(n == 1)
		return 0;
	if(n == 2)
		return dis(pstack[0], pstack[1]);
	long long ans = 0;

	for (long long i = 0; i < n - 1; i++) {
		long long k = 0;
		for (long long j = i + 1; j < n; j++) {
			while (cross(pstack[i], pstack[j], pstack[k]) < cross(pstack[i], pstack[j], pstack[k + 1])) {
				k = (k + 1) % n;
			}
			if(cross(pstack[i], pstack[j], pstack[k])>ans) ans=cross(pstack[i], pstack[j], pstack[k]),X=pstack[i],Y=pstack[j],Z=pstack[k];
		}
	}
	return ans;
}
signed main() {
	long long n,s;
	scanf("%lld%lld",&n,&s);
	init(n);
	n = Graham(n);
	long long ans = convex_maxlen(n);
	point a[10]={X+Y-Z,X-Y+Z,Y+Z-X};
//	cout << X.x << " " << X.y << "*\n";
//	cout << Y.x << " " << Y.y << "*\n";
//	cout << Z.x << " " << Z.y << "*\n";
	for(int i=0;i<=2;i++)
	{
	//	cout << a[i].x << " " << a[i].y << "\n";
		cout << a[i].x << " " << a[i].y << "\n";
	}
	return 0;
}


#include<bits/stdc++.h>
#define ll long long
using namespace std;

const int N=5005;
struct point
{
    int x,y;
    point(){}
    point(int _x,int _y):x(_x),y(_y){}
    inline friend point operator - (const point &a,const point &b)
    {return point(a.x-b.x,a.y-b.y);}
    inline friend point operator + (const point &a,const point &b)
    {return point(a.x+b.x,a.y+b.y);}
    inline friend ll operator * (const point &a,const point &b)
    {return 1ll*a.x*b.y-1ll*a.y*b.x;}
    inline ll dis(){return 1ll*x*x+1ll*y*y;}
}p[N],A,B,C;
int n,top;
ll S;

inline bool cmp(const point &a,const point &b)
{
    ll res=(a-p[1])*(b-p[1]);
    if(res)return res>0;
    return (a-p[1]).dis()<(b-p[1]).dis();
}

inline ll area(int i,int j,int k)
{
    return abs((p[j]-p[i])*(p[k]-p[i]));
}

void graham()
{
    for(int i=2;i<=n;i++)
        if((p[i].x<p[1].x)||(p[i].x==p[1].x&&p[i].y<p[1].y))swap(p[1],p[i]);
    sort(p+2,p+n+1,cmp),top=1;
    for(int i=2;i<=n;i++)
    {
        while(top>1&&(p[top-1]-p[i])*(p[top]-p[i])<0)top--;
        p[++top]=p[i];
    }n=top;
}

int main()
{
    //freopen("lx.in","r",stdin);
    scanf("%d%lld",&n,&S);
    for(int i=1;i<=n;i++)scanf("%d%d",&p[i].x,&p[i].y);
    graham();
    S=0;point a,b,c;
    for(int i=1;i<=n-2;i++)
        for(int j=i+1,k=j+1;j<=n-1;j++)
        {
            while(k<=n&&area(i,j,k+1)>=area(i,j,k))k++;
            if(area(i,j,k)>S)S=area(i,j,k),a=p[i],b=p[j],c=p[k];
        }
    A=a+(b-c),B=b+(c-a),C=c+(a-b);
    printf("%d %d\n%d %d\n%d %d\n",A.x,A.y,B.x,B.y,C.x,C.y);
    return 0;
}


#include<iostream>
#include<cstdio>
#include<cstring>
#include<string>
#include<algorithm>
#include<cstdlib>
#include<cmath>
#define INF 0x3fffffff
using namespace std;
typedef long long ll;
const int MAX_N = 5000+10;
ll x[MAX_N];
ll y[MAX_N];
int n;
ll s;
int a,b,c;

ll ar(int a,int b,int c)
{
    return abs((x[b]-x[a])*(y[c]-y[a])-(y[b]-y[a])*(x[c]-x[a]));
}

void finds()
{
    a=1;b=2;c=3;
    int flag=0;
    while(1)
    {
        flag=0;
        for(int i=1;i<=n;i++)
        {
            if(ar(i,b,c)>ar(a,b,c))
                a=i,flag=1;
            if(ar(a,i,c)>ar(a,b,c))
                b=i,flag=1;
            if(ar(a,b,i)>ar(a,b,c))
                c=i,flag=1;
        }

        if(flag == 0)
            break;
    }
}

int main()
{
    while(scanf("%d%I64d",&n,&s)!=EOF)
    {
        for(int i=1;i<=n;i++)
        {
            cin>>x[i]>>y[i];
        }
        finds();
        cout<<x[c]-x[a]+x[b]<<" "<<y[b]-y[a]+y[c]<<endl;
        cout<<x[a]-x[c]+x[b]<<" "<<y[b]-y[c]+y[a]<<endl;
        cout<<x[c]-x[b]+x[a]<<" "<<y[c]-y[b]+y[a]<<endl;
    }
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <vector>
#define LL long long
#define double LL
#define eps 1e-8
#define maxn 5100
#define mod 1000000007
#define inf 0x3f3f3f3f
#define IN freopen("in.txt","r",stdin);
using namespace std;
struct Point{
    double x,y;
    Point(){}
    Point(double tx,double ty) {x=tx;y=ty;}
}p[maxn];
double xmul(Point p0,Point p1,Point p2){
	return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);
}
double triangle_area(Point a,Point b,Point c) {
    return abs(xmul(a,b,c));
}
int main()
{
    int n; LL S;
    while(scanf("%d %I64d", &n,&S) != EOF)
    {
        for(int i=1; i<=n; i++)
            scanf("%I64d %I64d", &p[i].x,&p[i].y);
        bool flag = 1;
        int a=1, b=2, c=3;
        double ans = triangle_area(p[a],p[b],p[c]);
        while(flag) {
            flag = 0;
            for(int i=1; i<=n; i++) {
                double tmp;
                tmp = triangle_area(p[a],p[b],p[i]);
                if(tmp > ans) {
                    ans = tmp; c = i; flag = 1;
                }
                tmp = triangle_area(p[a],p[i],p[c]);
                if(tmp > ans) {
                    ans = tmp; b = i; flag = 1;
                }
                tmp = triangle_area(p[i],p[b],p[c]);
                if(tmp > ans) {
                    ans = tmp; a = i; flag = 1;
                }
            }
        }
        cout << p[a].x+p[b].x-p[c].x << ' ' << p[b].y+p[a].y-p[c].y << endl;
        cout << p[a].x+p[c].x-p[b].x << ' ' << p[c].y+p[a].y-p[b].y << endl;
        cout << p[c].x+p[b].x-p[a].x << ' ' << p[b].y+p[c].y-p[a].y << endl;
    }
    return 0;
}


//cf682e
#include<cstdio>
#include<iostream>
#include<cstring>
#include<cstdlib>
#include<algorithm>
#include<queue>
#include<deque>
#include<set>
#include<map>
#include<ctime>
#define LL long long
#define inf 0x7ffffff
#define pa pair<int,int>
#define pi 3.1415926535897932384626433832795028841971
using namespace std;
inline LL read()
{
    LL x=0,f=1;char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
inline void write(LL a)
{
    if (a<0){printf("-");a=-a;}
    if (a>=10)write(a/10);
    putchar(a%10+'0');
}
inline void writeln(LL a){write(a);printf("\n");}
LL n,k;
struct point{
    LL x,y;
}p[100010];
int a,b,c;
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};}
inline LL calc(int a,int b,int c) //计算三点围成面积
{
    LL x1=p[c].x-p[a].x,y1=p[c].y-p[a].y,x2=p[b].x-p[a].x,y2=p[b].y-p[a].y;
    LL ans=x1*y2-x2*y1;
    if (ans<0)ans=-ans;
    return ans;
}
int main()
{
    n=read();k=read();
    for (int i=1;i<=n;i++)p[i].x=read(),p[i].y=read();
    a=1;b=2;c=3;
    bool refresh=0;
    while (!refresh)
    {
        refresh=1;
        for (int i=1;i<=n;i++)
        if (i!=a&&i!=b&&i!=c) //一开始就选123号点，然后每次尝试把一个点替换之后面积会不会变大
        {
            if (calc(a,b,c)<calc(i,b,c))a=i,refresh=0;
            else if (calc(a,b,c)<calc(a,i,c))b=i,refresh=0;
            else if (calc(a,b,c)<calc(a,b,i))c=i,refresh=0;
        }
    }
    point d=p[a]+p[b]-p[c],e=p[a]+p[c]-p[b],f=p[c]+p[b]-p[a];
    printf("%lld %lld\n",d.x,d.y);
    printf("%lld %lld\n",e.x,e.y);
    printf("%lld %lld\n",f.x,f.y);
}


/*
题目大意：
给出n个点，任意三个点组成的三角形面积不超过S，
S大于n个点可以组成三角形的最大面积；
构造一个大三角形覆盖上述所有n个点，
并且面积不超过4S；

思路：
先求出最大三角形ABCABC，
再以abc分别作为三边中点
所得三角形A′B′C′
A′B′C′即是所求三角形

*/
#include<bits/stdc++.h>
#define ll long long
using namespace std;

const int N=5005;
struct point
{
    int x,y;
    point(){}
    point(int _x,int _y):x(_x),y(_y){}
    inline friend point operator - (const point &a,const point &b)
    {return point(a.x-b.x,a.y-b.y);}
    inline friend point operator + (const point &a,const point &b)
    {return point(a.x+b.x,a.y+b.y);}
    inline friend ll operator * (const point &a,const point &b)
    {return 1ll*a.x*b.y-1ll*a.y*b.x;}
    inline ll dis(){return 1ll*x*x+1ll*y*y;}
}p[N],A,B,C;
int n,top;
ll S;

inline bool cmp(const point &a,const point &b)
{
    ll res=(a-p[1])*(b-p[1]);
    if(res)return res>0;
    return (a-p[1]).dis()<(b-p[1]).dis();
}

inline ll area(int i,int j,int k)
{
    return abs((p[j]-p[i])*(p[k]-p[i]));
}

void graham()
{
    for(int i=2;i<=n;i++)
        if((p[i].x<p[1].x)||(p[i].x==p[1].x&&p[i].y<p[1].y))swap(p[1],p[i]);
    sort(p+2,p+n+1,cmp),top=1;
    for(int i=2;i<=n;i++)
    {
        while(top>1&&(p[top-1]-p[i])*(p[top]-p[i])<0)top--;
        p[++top]=p[i];
    }n=top;
}

int main()
{
    //freopen("lx.in","r",stdin);
    scanf("%d%lld",&n,&S);
    for(int i=1;i<=n;i++)scanf("%d%d",&p[i].x,&p[i].y);
    graham();
    S=0;point a,b,c;
    for(int i=1;i<=n-2;i++)
        for(int j=i+1,k=j+1;j<=n-1;j++)
        {
            while(k<=n&&area(i,j,k+1)>=area(i,j,k))k++;
            if(area(i,j,k)>S)S=area(i,j,k),a=p[i],b=p[j],c=p[k];
        }
    A=a+(b-c),B=b+(c-a),C=c+(a-b);
    printf("%d %d\n%d %d\n%d %d\n",A.x,A.y,B.x,B.y,C.x,C.y);
    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <vector>
#define LL long long
#define double LL
#define eps 1e-8
#define maxn 5100
#define mod 1000000007
#define inf 0x3f3f3f3f
#define IN freopen("in.txt","r",stdin);
using namespace std;

struct Point{
    double x,y;
    Point(){}
    Point(double tx,double ty) {x=tx;y=ty;}
}p[maxn];;

double xmul(Point p0,Point p1,Point p2)
{return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);}

double triangle_area(Point a,Point b,Point c) {
    return abs(xmul(a,b,c));
}

int main(void)
{
    //IN;

    int n; LL S;
    while(scanf("%d %I64d", &n,&S) != EOF)
    {
        for(int i=1; i<=n; i++)
            scanf("%I64d %I64d", &p[i].x,&p[i].y);

        bool flag = 1;
        int a=1, b=2, c=3;
        double ans = triangle_area(p[a],p[b],p[c]);
        while(flag) {
            flag = 0;
            for(int i=1; i<=n; i++) {
                double tmp;
                tmp = triangle_area(p[a],p[b],p[i]);
                if(tmp > ans) {
                    ans = tmp; c = i; flag = 1;
                }
                tmp = triangle_area(p[a],p[i],p[c]);
                if(tmp > ans) {
                    ans = tmp; b = i; flag = 1;
                }
                tmp = triangle_area(p[i],p[b],p[c]);
                if(tmp > ans) {
                    ans = tmp; a = i; flag = 1;
                }
            }
        }

        cout << p[a].x+p[b].x-p[c].x << ' ' << p[b].y+p[a].y-p[c].y << endl;
        cout << p[a].x+p[c].x-p[b].x << ' ' << p[c].y+p[a].y-p[b].y << endl;
        cout << p[c].x+p[b].x-p[a].x << ' ' << p[b].y+p[c].y-p[a].y << endl;
    }

    return 0;
}


#include <iostream>
#include <cstdio>
#include <cstring>
#include <cmath>
#include <algorithm>
#include <queue>
#include <map>
#include <set>
#include <vector>
#define LL long long
#define double LL
#define eps 1e-8
#define maxn 5100
#define mod 1000000007
#define inf 0x3f3f3f3f
#define IN freopen("in.txt","r",stdin);
using namespace std;
struct Point{
    double x,y;
    Point(){}
    Point(double tx,double ty) {x=tx;y=ty;}
}p[maxn];
double xmul(Point p0,Point p1,Point p2){
	return (p1.x-p0.x)*(p2.y-p0.y)-(p2.x-p0.x)*(p1.y-p0.y);
}
double triangle_area(Point a,Point b,Point c) {
    return abs(xmul(a,b,c));
}
int main()
{
    int n; LL S;
    while(scanf("%d %I64d", &n,&S) != EOF)
    {
        for(int i=1; i<=n; i++)
            scanf("%I64d %I64d", &p[i].x,&p[i].y);
        bool flag = 1;
        int a=1, b=2, c=3;
        double ans = triangle_area(p[a],p[b],p[c]);
        while(flag) {
            flag = 0;
            for(int i=3; i<=n; i++) {
                double tmp;
                tmp = triangle_area(p[a],p[b],p[i]);
                if(tmp > ans) {
                    ans = tmp; c = i; flag = 1;
                }
                tmp = triangle_area(p[a],p[i],p[c]);
                if(tmp > ans) {
                    ans = tmp; b = i; flag = 1;
                }
                tmp = triangle_area(p[i],p[b],p[c]);
                if(tmp > ans) {
                    ans = tmp; a = i; flag = 1;
                }
            }
        }
        cout << p[a].x+p[b].x-p[c].x << ' ' << p[b].y+p[a].y-p[c].y << endl;
        cout << p[a].x+p[c].x-p[b].x << ' ' << p[c].y+p[a].y-p[b].y << endl;
        cout << p[c].x+p[b].x-p[a].x << ' ' << p[b].y+p[c].y-p[a].y << endl;
    }
    return 0;
}


#include <bits/stdc++.h>
#define ll long long
using namespace std;

struct Point
{
    ll x, y;
    Point() {}
    Point(ll tx, ll ty)
    {
        x = tx;
        y = ty;
    }
} p[5100];

ll xmul(Point p0, Point p1, Point p2)
{
    return (p1.x - p0.x) * (p2.y - p0.y) - (p2.x - p0.x) * (p1.y - p0.y);
}

ll triangle_area(Point a, Point b, Point c)
{
    return abs(xmul(a, b, c));
}

int n;
ll S;
int main()
{
    while (scanf("%d %I64d", &n, &S) != EOF)
    {
        for (int i = 1; i <= n; i++)
            scanf("%I64d %I64d", &p[i].x, &p[i].y);

        bool flag = 1;
        int a = 1, b = 2, c = 3;
        ll ans = triangle_area(p[a], p[b], p[c]);
        while (flag)
        {
            flag = 0;
            for (int i = 1; i <= n; i++)
            {
                ll tmp;
                tmp = triangle_area(p[a], p[b], p[i]);
                if (tmp > ans)
                {
                    ans = tmp;
                    c = i;
                    flag = 1;
                }
                tmp = triangle_area(p[a], p[i], p[c]);
                if (tmp > ans)
                {
                    ans = tmp;
                    b = i;
                    flag = 1;
                }
                tmp = triangle_area(p[i], p[b], p[c]);
                if (tmp > ans)
                {
                    ans = tmp;
                    a = i;
                    flag = 1;
                }
            }
        }

        cout << p[a].x + p[b].x - p[c].x << ' ' << p[b].y + p[a].y - p[c].y << endl;
        cout << p[a].x + p[c].x - p[b].x << ' ' << p[c].y + p[a].y - p[b].y << endl;
        cout << p[c].x + p[b].x - p[a].x << ' ' << p[b].y + p[c].y - p[a].y << endl;
    }
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

ll dist(pair<int, int> a, pair<int, int> b) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	return 1LL * dx1 * dx1 + 1LL * dy1 * dy1;
}

ll ccw(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	int dx2 = c.first - a.first;
	int dy2 = c.second - a.second;
	return 1LL * dx1 * dy2 - 1LL * dy1 * dx2;
}

vector<pair<int, int>> getHull(vector<pair<int, int> > &poly) {
    int n = poly.size();
	pair<int, int> least = poly[0];
	int pos = 0;
	for(int i = 0; i < n; i++) {
	    if(poly[i] < least) {
	        least = poly[i];
	        pos = i;
	    }
	}
	swap(poly[0], poly[pos]);
	sort(poly.begin() + 1, poly.end(), [&](const pair<int, int> &a, const pair<int, int> &b){
		auto x = ccw(poly[0], a, b);
		if(x != 0) return x > 0;
		return dist(poly[0], a) < dist(poly[0], b);
	});
	vector<pair<int, int> > hull;
	for(auto &i : poly) {
		while(hull.size() >= 2 && ccw(hull[hull.size()-2], hull.back(), i) <= 0){
			hull.pop_back();
		}
		hull.push_back(i);
	}
	return hull;
}

void helper(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    pair<int, int> mid = {y.first+z.first, y.second+z.second};
    cout << mid.first - x.first << ' ' << mid.second - x.second << '\n';
}

void print(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    helper(x, y, z);
    helper(y, x, z);
    helper(z, x, y);
}

ll polyArea(vector<pair<int, int> >& points) {
    ll result = 0;
    int n = points.size();
    for(int i=0, j=1; i<n; i++, j=(j+1)%n) {
        result += 1LL*points[i].first * points[j].second;
        result -= 1LL*points[i].second * points[j].first;
    }
    return abs(result);
}

ll polyArea(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    vector<pair<int, int> > arr(3);
    arr[0] = x;
    arr[1] = y;
    arr[2] = z;
    return polyArea(arr);
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    ll s;
    cin >> n >> s;
    vector<pair<int, int> > poly(n);
    for(int i = 0; i < n; ++i) {
        cin >> poly[i].first >> poly[i].second;
    }
    poly = getHull(poly);
    n = poly.size();
    ll maxArea = -1;
    int i1 = 0, j1 = 1, k1 = 2;
    for(int i = 0; i < n; ++i) {
        int k = i+2;
        for(int j = i+1; j < i+n; ++j) {
            ll prevArea = -1e18;
            k = max(k, j+1);
            while(k < i+n) {
                ll res = polyArea(poly[i], poly[j%n], poly[k%n]);
                if(res > maxArea) {
                    maxArea = res;
                    i1 = i, j1 = j%n, k1 = k%n;
                }
                if(res < prevArea) break;
                prevArea = res;
                k++;
            }
            k -= 2;
        }
    }
    print(poly[i1], poly[j1], poly[k1]);
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

ll dist(pair<int, int> a, pair<int, int> b) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	return 1LL * dx1 * dx1 + 1LL * dy1 * dy1;
}

ll ccw(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	int dx2 = c.first - a.first;
	int dy2 = c.second - a.second;
	return 1LL * dx1 * dy2 - 1LL * dy1 * dx2;
}

vector<pair<int, int>> getHull(vector<pair<int, int> > &poly) {
    int n = poly.size();
	pair<int, int> least = poly[0];
	int pos = 0;
	for(int i = 0; i < n; i++) {
	    if(poly[i] < least) {
	        least = poly[i];
	        pos = i;
	    }
	}
	swap(poly[0], poly[pos]);
	sort(poly.begin() + 1, poly.end(), [&](const pair<int, int> &a, const pair<int, int> &b){
		auto x = ccw(poly[0], a, b);
		if(x != 0) return x > 0;
		return dist(poly[0], a) < dist(poly[0], b);
	});
	vector<pair<int, int> > hull;
	for(auto &i : poly) {
		while(hull.size() >= 2 && ccw(hull[hull.size()-2], hull.back(), i) <= 0){
			hull.pop_back();
		}
		hull.push_back(i);
	}
	return hull;
}

void helper(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    pair<int, int> mid = {y.first+z.first, y.second+z.second};
    cout << mid.first - x.first << ' ' << mid.second - x.second << '\n';
}

void print(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    helper(x, y, z);
    helper(y, x, z);
    helper(z, x, y);
}

ll polyArea(vector<pair<int, int> >& points) {
    ll result = 0;
    int n = points.size();
    for(int i=0, j=1; i<n; ++i, ++j) {
        if(j == n) j = 0;
        result += 1LL*points[i].first * points[j].second;
        result -= 1LL*points[i].second * points[j].first;
    }
    return abs(result);
}

inline ll polyArea(const pair<int, int> &x, const pair<int, int> &y, const pair<int, int> &z) {
    ll result = 0;
    result += 1LL * x.first * y.second;
    result += 1LL * y.first * z.second;
    result += 1LL * z.first * x.second;

    result -= 1LL * x.second * y.first;
    result -= 1LL * y.second * z.first;
    result -= 1LL * z.second * x.first;
    return abs(result);
    vector<pair<int, int> > arr(3);
    arr[0] = x;
    arr[1] = y;
    arr[2] = z;
    return polyArea(arr);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    ll s;
    cin >> n >> s;
    vector<pair<int, int> > poly(n);
    for(int i = 0; i < n; ++i) {
        cin >> poly[i].first >> poly[i].second;
    }
    poly = getHull(poly);
    n = poly.size();
    ll maxArea = -1;
    int i1 = 0, j1 = 1, k1 = 2;
    for(int i = 0; i < n; ++i) {
        int k = i+2;
        for(int j = i+1; j < i+n; ++j) {
            ll prevArea = -1e18;
            k = max(k, j+1);
            while(k < i+n) {
                //ll res = polyArea(poly[i], poly[j%n], poly[k%n]);
                ll res = polyArea(poly[i], poly[j>=n?j-n:j], poly[k>=n?k-n:k]);
                if(res > maxArea) {
                    maxArea = res;
                    i1 = i, j1 = j, k1 = k;
                }
                if(res < prevArea) break;
                prevArea = res;
                k++;
            }
            k -= 2;
        }
    }
    print(poly[i1], poly[j1%n], poly[k1%n]);
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

ll dist(pair<int, int> a, pair<int, int> b) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	return 1LL * dx1 * dx1 + 1LL * dy1 * dy1;
}

ll ccw(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	int dx2 = c.first - a.first;
	int dy2 = c.second - a.second;
	return 1LL * dx1 * dy2 - 1LL * dy1 * dx2;
}

vector<pair<int, int>> getHull(vector<pair<int, int> > &poly) {
    int n = poly.size();
	pair<int, int> least = poly[0];
	int pos = 0;
	for(int i = 0; i < n; i++) {
	    if(poly[i] < least) {
	        least = poly[i];
	        pos = i;
	    }
	}
	swap(poly[0], poly[pos]);
	sort(poly.begin() + 1, poly.end(), [&](const pair<int, int> &a, const pair<int, int> &b){
		auto x = ccw(poly[0], a, b);
		if(x != 0) return x > 0;
		return dist(poly[0], a) < dist(poly[0], b);
	});
	vector<pair<int, int> > hull;
	for(auto &i : poly) {
		while(hull.size() >= 2 && ccw(hull[hull.size()-2], hull.back(), i) <= 0){
			hull.pop_back();
		}
		hull.push_back(i);
	}
	return hull;
}

void helper(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    pair<int, int> mid = {y.first+z.first, y.second+z.second};
    cout << mid.first - x.first << ' ' << mid.second - x.second << '\n';
}

void print(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    helper(x, y, z);
    helper(y, x, z);
    helper(z, x, y);
}

ll polyArea(vector<pair<int, int> >& points) {
    ll result = 0;
    int n = points.size();
    for(int i=0, j=1; i<n; ++i, ++j) {
        if(j == n) j = 0;
        result += 1LL*points[i].first * points[j].second;
        result -= 1LL*points[i].second * points[j].first;
    }
    return abs(result);
}

ll polyArea(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    vector<pair<int, int> > arr(3);
    arr[0] = x;
    arr[1] = y;
    arr[2] = z;
    return polyArea(arr);
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    ll s;
    cin >> n >> s;
    vector<pair<int, int> > poly(n);
    for(int i = 0; i < n; ++i) {
        cin >> poly[i].first >> poly[i].second;
    }
    poly = getHull(poly);
    n = poly.size();
    ll maxArea = -1;
    int i1 = 0, j1 = 1, k1 = 2;
    for(int i = 0; i < n; ++i) {
        int k = i+2;
        for(int j = i+1; j < i+n; ++j) {
            ll prevArea = -1e18;
            k = max(k, j+1);
            while(k < i+n) {
                //ll res = polyArea(poly[i], poly[j%n], poly[k%n]);
                ll res = polyArea(poly[i], poly[j>=n?j-n:j], poly[k>=n?k-n:k]);
                if(res > maxArea) {
                    maxArea = res;
                    i1 = i, j1 = j, k1 = k;
                }
                if(res < prevArea) break;
                prevArea = res;
                k++;
            }
            k -= 2;
        }
    }
    print(poly[i1], poly[j1%n], poly[k1%n]);
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

ll dist(pair<int, int> a, pair<int, int> b) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	return 1LL * dx1 * dx1 + 1LL * dy1 * dy1;
}

ll ccw(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	int dx2 = c.first - a.first;
	int dy2 = c.second - a.second;
	return 1LL * dx1 * dy2 - 1LL * dy1 * dx2;
}

vector<pair<int, int>> getHull(vector<pair<int, int> > &poly) {
    int n = poly.size();
	pair<int, int> least = poly[0];
	int pos = 0;
	for(int i = 0; i < n; i++) {
	    if(poly[i] < least) {
	        least = poly[i];
	        pos = i;
	    }
	}
	swap(poly[0], poly[pos]);
	sort(poly.begin() + 1, poly.end(), [&](const pair<int, int> &a, const pair<int, int> &b){
		auto x = ccw(poly[0], a, b);
		if(x != 0) return x > 0;
		return dist(poly[0], a) < dist(poly[0], b);
	});
	vector<pair<int, int> > hull;
	for(auto &i : poly) {
		while(hull.size() >= 2 && ccw(hull[hull.size()-2], hull.back(), i) <= 0){
			hull.pop_back();
		}
		hull.push_back(i);
	}
	return hull;
}

void helper(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    pair<int, int> mid = {y.first+z.first, y.second+z.second};
    cout << mid.first - x.first << ' ' << mid.second - x.second << '\n';
}

void print(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    helper(x, y, z);
    helper(y, x, z);
    helper(z, x, y);
}

ll polyArea(vector<pair<int, int> >& points) {
    ll result = 0;
    int n = points.size();
    for(int i=0, j=1; i<n; i++, j=(j+1)%n) {
        result += 1LL*points[i].first * points[j].second;
        result -= 1LL*points[i].second * points[j].first;
    }
    return abs(result);
}

ll polyArea(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    vector<pair<int, int> > arr(3);
    arr[0] = x;
    arr[0] = y;
    arr[0] = z;
    return polyArea(arr);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    ll s;
    cin >> n >> s;
    vector<pair<int, int> > poly(n);
    for(int i = 0; i < n; ++i) {
        cin >> poly[i].first >> poly[i].second;
    }
    poly = getHull(poly);
    n = poly.size();
    ll maxArea = -1;
    int i1 = 0, j1 = 1, k1 = 2;
    for(int i = 0; i < n; ++i) {
        int k = i+1;
        ll currArea = polyArea(poly[i], poly[(i+1)%n], poly[(i+2)%n]);
        if(currArea > maxArea) {
            maxArea = currArea;
            i1 = i, j1 = (i+1)%n, k1 = (i+2)%n;
        }
        for(int j = i+1; j < i+n; ++j) {
            while(k < i+n) {
                k++;
                ll res = polyArea(poly[i], poly[j%n], poly[k%n]);
                if(res > maxArea) {
                    maxArea = res;
                    i1 = i, j1 = j%n, k1 = k%n;
                }
                if(res >= currArea) {
                    currArea = res;
                } else break;
            }
            k -= 3;
            k = max(k, j+1);
        }
    }
    print(poly[i1], poly[j1], poly[k1]);
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int long long

ll dist(pair<int, int> a, pair<int, int> b) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	return 1LL * dx1 * dx1 + 1LL * dy1 * dy1;
}

ll ccw(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	int dx2 = c.first - a.first;
	int dy2 = c.second - a.second;
	return 1LL * dx1 * dy2 - 1LL * dy1 * dx2;
}

vector<pair<int, int>> getHull(vector<pair<int, int> > &poly) {
    int n = poly.size();
	pair<int, int> least = poly[0];
	int pos = 0;
	for(int i = 0; i < n; i++) {
	    if(poly[i] < least) {
	        least = poly[i];
	        pos = i;
	    }
	}
	swap(poly[0], poly[pos]);
	sort(poly.begin() + 1, poly.end(), [&](const pair<int, int> &a, const pair<int, int> &b){
		auto x = ccw(poly[0], a, b);
		if(x != 0) return x > 0;
		return dist(poly[0], a) < dist(poly[0], b);
	});
	vector<pair<int, int> > hull;
	for(auto &i : poly) {
		while(hull.size() >= 2 && ccw(hull[hull.size()-2], hull.back(), i) <= 0){
			hull.pop_back();
		}
		hull.push_back(i);
	}
	return hull;
}

void helper(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    pair<int, int> mid = {y.first+z.first, y.second+z.second};
    cout << mid.first - x.first << ' ' << mid.second - x.second << '\n';
}

void print(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    helper(x, y, z);
    helper(y, x, z);
    helper(z, x, y);
}

ll polyArea(vector<pair<int, int> >& points) {
    ll result = 0;
    int n = points.size();
    for(int i=0, j=1; i<n; i++, j=(j+1)%n) {
        result += 1LL*points[i].first * points[j].second;
        result -= 1LL*points[i].second * points[j].first;
    }
    return abs(result);
}

ll polyArea(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    vector<pair<int, int> > arr(3);
    arr[0] = x;
    arr[0] = y;
    arr[0] = z;
    return polyArea(arr);
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    ll s;
    cin >> n >> s;
    vector<pair<int, int> > poly(n);
    for(int i = 0; i < n; ++i) {
        cin >> poly[i].first >> poly[i].second;
    }
    poly = getHull(poly);
    n = poly.size();
    ll maxArea = -1;
    int i1 = 0, j1 = 1, k1 = 2;
    for(int i = 0; i < n; ++i) {
        int k = i+2;
        for(int j = i+1; j < i+n; ++j) {
            int prevArea = -1e18;
            while(k < i+n) {
                ll res = polyArea(poly[i], poly[j%n], poly[k%n]);
                if(res > maxArea) {
                    maxArea = res;
                    i1 = i, j1 = j%n, k1 = k%n;
                }
                if(res < prevArea) break;
                prevArea = res;
                k++;
            }
            k -= 3;
            k = max(k, j+1);
        }
    }
    print(poly[i1], poly[j1], poly[k1]);
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;

ll dist(pair<int, int> a, pair<int, int> b) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	return 1LL * dx1 * dx1 + 1LL * dy1 * dy1;
}

ll ccw(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	int dx2 = c.first - a.first;
	int dy2 = c.second - a.second;
	return 1LL * dx1 * dy2 - 1LL * dy1 * dx2;
}

vector<pair<int, int>> getHull(vector<pair<int, int> > &poly) {
    int n = poly.size();
	pair<int, int> least = poly[0];
	int pos = 0;
	for(int i = 0; i < n; i++) {
	    if(poly[i] < least) {
	        least = poly[i];
	        pos = i;
	    }
	}
	swap(poly[0], poly[pos]);
	sort(poly.begin() + 1, poly.end(), [&](const pair<int, int> &a, const pair<int, int> &b){
		auto x = ccw(poly[0], a, b);
		if(x != 0) return x > 0;
		return dist(poly[0], a) < dist(poly[0], b);
	});
	vector<pair<int, int> > hull;
	for(auto &i : poly) {
		while(hull.size() >= 2 && ccw(hull[hull.size()-2], hull.back(), i) <= 0){
			hull.pop_back();
		}
		hull.push_back(i);
	}
	return hull;
}

void helper(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    pair<int, int> mid = {y.first+z.first, y.second+z.second};
    cout << mid.first - x.first << ' ' << mid.second - x.second << '\n';
}

void print(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    helper(x, y, z);
    helper(y, x, z);
    helper(z, x, y);
}

ll polyArea(vector<pair<int, int> >& points) {
    ll result = 0;
    int n = points.size();
    for(int i=0, j=1; i<n; i++, j=(j+1)%n) {
        result += 1LL*points[i].first * points[j].second;
        result -= 1LL*points[i].second * points[j].first;
    }
    return abs(result);
}

ll polyArea(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    vector<pair<int, int> > arr(3);
    arr[0] = x;
    arr[0] = y;
    arr[0] = z;
    return polyArea(arr);
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    ll s;
    cin >> n >> s;
    vector<pair<int, int> > poly(n);
    for(int i = 0; i < n; ++i) {
        cin >> poly[i].first >> poly[i].second;
    }
    poly = getHull(poly);
    n = poly.size();
    ll maxArea = -1;
    int i1 = 0, j1 = 1, k1 = 2;
    for(int i = 0; i < n; ++i) {
        int k = i+1;
        ll currArea = polyArea(poly[i], poly[(i+1)%n], poly[(i+2)%n]);
        if(currArea > maxArea) {
            maxArea = currArea;
            i1 = i, j1 = (i+1)%n, k1 = (i+2)%n;
        }
        for(int j = i+1; j < i+n; ++j) {
            while(k < i+n) {
                k++;
                ll res = polyArea(poly[i], poly[j%n], poly[k%n]);
                if(res > maxArea) {
                    maxArea = res;
                    i1 = i, j1 = j%n, k1 = k%n;
                }
                if(res >= currArea) {
                    currArea = res;
                } else break;
            }
            k -= 2;
            k = max(k, j+1);
            currArea = polyArea(poly[i], poly[j%n], poly[k%n]);
        }
    }
    print(poly[i1], poly[j1], poly[k1]);
}


#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define int long long

ll dist(pair<int, int> a, pair<int, int> b) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	return 1LL * dx1 * dx1 + 1LL * dy1 * dy1;
}

ll ccw(pair<int, int> a, pair<int, int> b, pair<int, int> c) {
	int dx1 = b.first - a.first;
	int dy1 = b.second - a.second;
	int dx2 = c.first - a.first;
	int dy2 = c.second - a.second;
	return 1LL * dx1 * dy2 - 1LL * dy1 * dx2;
}

vector<pair<int, int>> getHull(vector<pair<int, int> > &poly) {
    int n = poly.size();
	pair<int, int> least = poly[0];
	int pos = 0;
	for(int i = 0; i < n; i++) {
	    if(poly[i] < least) {
	        least = poly[i];
	        pos = i;
	    }
	}
	swap(poly[0], poly[pos]);
	sort(poly.begin() + 1, poly.end(), [&](const pair<int, int> &a, const pair<int, int> &b){
		auto x = ccw(poly[0], a, b);
		if(x != 0) return x > 0;
		return dist(poly[0], a) < dist(poly[0], b);
	});
	vector<pair<int, int> > hull;
	for(auto &i : poly) {
		while(hull.size() >= 2 && ccw(hull[hull.size()-2], hull.back(), i) <= 0){
			hull.pop_back();
		}
		hull.push_back(i);
	}
	return hull;
}

void helper(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    pair<int, int> mid = {y.first+z.first, y.second+z.second};
    cout << mid.first - x.first << ' ' << mid.second - x.second << '\n';
}

void print(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    helper(x, y, z);
    helper(y, x, z);
    helper(z, x, y);
}

ll polyArea(vector<pair<int, int> >& points) {
    ll result = 0;
    int n = points.size();
    for(int i=0, j=1; i<n; i++, j=(j+1)%n) {
        result += 1LL*points[i].first * points[j].second;
        result -= 1LL*points[i].second * points[j].first;
    }
    return abs(result);
}

ll polyArea(pair<int, int> x, pair<int, int> y, pair<int, int> z) {
    vector<pair<int, int> > arr(3);
    arr[0] = x;
    arr[1] = y;
    arr[2] = z;
    return polyArea(arr);
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(0);
    cout.tie(0);
    int n;
    ll s;
    cin >> n >> s;
    vector<pair<int, int> > poly(n);
    for(int i = 0; i < n; ++i) {
        cin >> poly[i].first >> poly[i].second;
    }
    poly = getHull(poly);
    n = poly.size();
    ll maxArea = -1;
    int i1 = 0, j1 = 1, k1 = 2;
    for(int i = 0; i < n; ++i) {
        int k = i+2;
        for(int j = i+1; j < i+n; ++j) {
            int prevArea = -1e18;
            k = max(k, j+1);
            while(k < i+n) {
                //cout << "before\n";
                ll res = polyArea(poly[i], poly[j%n], poly[k%n]);
                //cout << "after\n\n";
                //cout << "here, res: " << res << endl;
                if(res > maxArea) {
                    maxArea = res;
                    i1 = i, j1 = j%n, k1 = k%n;
                }
                if(res < prevArea) break;
                prevArea = res;
                k++;
            }
            k -= 3;
        }
    }
    //cout << "maxArea: " << maxArea << endl;
    print(poly[i1], poly[j1], poly[k1]);
}


#include <bits/stdc++.h>

using namespace std;

struct point{
	int x, y;
};

const int INF = 1e9;

int n;
point pvt = point({INF, INF});
vector<point> pt, ch;

long long cross(point o, point a, point b){
	point oa, ob;
	oa.x = a.x - o.x, oa.y = a.y - o.y;
	ob.x = b.x - o.x, ob.y = b.y - o.y;

	return (long long) oa.x * ob.y - (long long) oa.y * ob.x;
}

long long dist(point a, point b){
	long long x = a.x - b.x, y = a.y - b.y;
	return x*x + y*y;
}

bool cmp(point a, point b){
	if(cross(pvt, a, b) == 0) return dist(pvt, a) < dist(pvt, b);
	return (cross(pvt, a, b) > 0);
}

long long s;
int main(){
	scanf("%d%lld", &n, &s);

	pt.resize(n);

	for(int i = 0; i < n; i++){
		scanf("%d%d", &pt[i].x, &pt[i].y);

		if(pvt.x > pt[i].x){
			pvt = pt[i];
		} else if (pvt.x == pt[i].x){
			if(pvt.y > pt[i].y) pvt = pt[i];
		}
	}

	sort(pt.begin(), pt.end(), cmp);

	for(int i = 0; i < n; i++){
		while(ch.size() >= 2 && cross(ch[ch.size() - 2], ch.back(), pt[i]) <= 0) ch.pop_back();
		ch.emplace_back(pt[i]);
	}

	point a, b, c;
	a = b = c = point({0, 0});

	for(int i = 0; i < (int) ch.size(); i++){
		int k = 1;
		for(int j = i + 2; j < (int) ch.size(); j++){
			while(k < j - 1 && abs(cross(ch[i], ch[j], ch[k])) < abs(cross(ch[i], ch[j], ch[k + 1]))) k++;

			if(abs(cross(a, b, c)) < abs(cross(ch[i], ch[j], ch[k]))){
				a = ch[i], b = ch[j], c = ch[k];
			}
		}
	}

	printf("%d %d\n", -a.x + b.x + c.x, -a.y + b.y + c.y);
	printf("%d %d\n", a.x - b.x + c.x, a.y - b.y + c.y);
	printf("%d %d\n", a.x + b.x - c.x, a.y + b.y - c.y);

	return 0;
}


#include <bits/stdc++.h>

using namespace std;

struct point{
	int x, y;
};

const int INF = 1e9;

int n;
point pvt = point({INF, INF});
vector<point> pt, ch;

long long cross(point o, point a, point b){
	point oa, ob;
	oa.x = a.x - o.x, oa.y = a.y - o.y;
	ob.x = b.x - o.x, ob.y = b.y - o.y;

	return (long long) oa.x * ob.y - (long long) oa.y * ob.x;
}

long long dist(point a, point b){
	long long x = a.x - b.x, y = a.y - b.y;
	return x*x + y*y;
}

bool cmp(point a, point b){
	if(cross(pvt, a, b) == 0) return dist(pvt, a) < dist(pvt, b);
	return (cross(pvt, a, b) > 0);
}

int main(){
	scanf("%d", &n);

	pt.resize(n);

	for(int i = 0; i < n; i++){
		scanf("%d%d", &pt[i].x, &pt[i].y);

		if(pvt.x > pt[i].x){
			pvt = pt[i];
		} else if (pvt.x == pt[i].x){
			if(pvt.y > pt[i].y) pvt = pt[i];
		}
	}

	sort(pt.begin(), pt.end(), cmp);

	for(int i = 0; i < n; i++){
		while(ch.size() >= 2 && cross(ch[ch.size() - 2], ch.back(), pt[i]) <= 0) ch.pop_back();
		ch.emplace_back(pt[i]);
	}

	point a, b, c;
	a = b = c = point({0, 0});

	for(int i = 0; i < (int) ch.size(); i++){
		int k = 1;
		for(int j = i + 2; j < (int) ch.size(); j++){
			while(k < j && abs(cross(ch[i], ch[j], ch[k])) < abs(cross(ch[i], ch[j], ch[k + 1]))) k++;

			if(abs(cross(a, b, c)) < abs(cross(ch[i], ch[j], ch[k]))){
				a = ch[i], b = ch[j], c = ch[k];
			}
		}
	}

	printf("%d %d\n", -a.x + b.x + c.x, -a.y + b.y + c.y);
	printf("%d %d\n", a.x - b.x + c.x, a.y - b.y + c.y);
	printf("%d %d\n", a.x + b.x - c.x, a.y + b.y - c.y);

	return 0;
}


#include <bits/stdc++.h>

using namespace std;

struct point{
	int x, y;
};

const int INF = 1e9;

int n;
point pvt = point({INF, INF});
vector<point> pt, ch;

long long cross(point o, point a, point b){
	point oa, ob;
	oa.x = a.x - o.x, oa.y = a.y - o.y;
	ob.x = b.x - o.x, ob.y = b.y - o.y;

	return (long long) oa.x * ob.y - (long long) oa.y * ob.x;
}

long long dist(point a, point b){
	long long x = a.x - b.x, y = a.y - b.y;
	return x*x + y*y;
}

bool cmp(point a, point b){
	if(cross(pvt, a, b) == 0) return dist(pvt, a) < dist(pvt, b);
	return (cross(pvt, a, b) > 0);
}

int main(){
	scanf("%d", &n);

	pt.resize(n);

	for(int i = 0; i < n; i++){
		scanf("%d%d", &pt[i].x, &pt[i].y);

		if(pvt.x > pt[i].x){
			pvt = pt[i];
		} else if (pvt.x == pt[i].x){
			if(pvt.y > pt[i].y) pvt = pt[i];
		}
	}

	sort(pt.begin(), pt.end(), cmp);

	for(int i = 0; i < n; i++){
		while(ch.size() >= 2 && cross(ch[ch.size() - 2], ch.back(), pt[i]) <= 0) ch.pop_back();
		ch.emplace_back(pt[i]);
	}

	point a, b, c;
	a = b = c = point({0, 0});

	for(int i = 0; i < (int) ch.size(); i++){
		int k = 1;
		for(int j = i + 2; j < (int) ch.size(); j++){
			while(k < j - 1 && abs(cross(ch[i], ch[j], ch[k])) < abs(cross(ch[i], ch[j], ch[k + 1]))) k++;

			if(abs(cross(a, b, c)) < abs(cross(ch[i], ch[j], ch[k]))){
				a = ch[i], b = ch[j], c = ch[k];
			}
		}
	}

	printf("%d %d\n", -a.x + b.x + c.x, -a.y + b.y + c.y);
	printf("%d %d\n", a.x - b.x + c.x, a.y - b.y + c.y);
	printf("%d %d\n", a.x + b.x - c.x, a.y + b.y - c.y);

	return 0;
}


#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
using namespace std;
typedef long long ll;
#define INF 0x3f3f3f3f
#define maxn 5555
int n,x[maxn],y[maxn];
ll S;
ll get_s(int i,int j,int k)
{
    int x1=x[k]-x[i],y1=y[k]-y[i],x2=x[k]-x[j],y2=y[k]-y[j];
    return abs(1ll*x1*y2-1ll*x2*y1);
}
int main()
{
    while(~scanf("%d%I64d",&n,&S))
    {
        for(int i=1;i<=n;i++)scanf("%d%d",&x[i],&y[i]);
        int a=1,b=2,c=3,flag=1;
        ll s=get_s(1,2,3);
        while(flag)
        {
            flag=0;
            for(int i=1;i<=n;i++)
            {
                if(s<get_s(i,b,c))s=get_s(i,b,c),a=i,flag=1;
                if(s<get_s(a,i,c))s=get_s(a,i,c),b=i,flag=1;
                if(s<get_s(a,b,i))s=get_s(a,b,i),c=i,flag=1;
            }
        }
        printf("%d %d\n",x[a]+x[b]-x[c],y[a]+y[b]-y[c]);
        printf("%d %d\n",x[a]+x[c]-x[b],y[a]+y[c]-y[b]);
        printf("%d %d\n",x[b]+x[c]-x[a],y[b]+y[c]-y[a]);
    }
    return 0;
}
————————————————
版权声明：本文为CSDN博主「v5zsq」的原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/v5zsq/article/details/75109970


#include<cstdio>
#include<iostream>
#include<cstring>
#include<algorithm>
#include<cmath>
#include<vector>
#include<queue>
#include<map>
#include<set>
#include<ctime>
using namespace std;
typedef long long ll;
#define INF 0x3f3f3f3f
#define maxn 5555
int n,x[maxn],y[maxn];
ll S;
ll get_s(int i,int j,int k)
{
    int x1=x[k]-x[i],y1=y[k]-y[i],x2=x[k]-x[j],y2=y[k]-y[j];
    return abs(1ll*x1*y2-1ll*x2*y1);
}
int main()
{
    while(~scanf("%d%I64d",&n,&S))
    {
        for(int i=1;i<=n;i++)scanf("%d%d",&x[i],&y[i]);
        int a=1,b=2,c=3,flag=1;
        ll s=get_s(1,2,3);
        while(flag)
        {
            flag=0;
            for(int i=1;i<=n;i++)
            {
                if(s<get_s(i,b,c))s=get_s(i,b,c),a=i,flag=1;
                if(s<get_s(a,i,c))s=get_s(a,i,c),b=i,flag=1;
                if(s<get_s(a,b,i))s=get_s(a,b,i),c=i,flag=1;
            }
        }
        printf("%d %d\n",x[a]+x[b]-x[c],y[a]+y[b]-y[c]);
        printf("%d %d\n",x[a]+x[c]-x[b],y[a]+y[c]-y[b]);
        printf("%d %d\n",x[b]+x[c]-x[a],y[b]+y[c]-y[a]);
    }
    return 0;
}


#include <functional>
#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdlib>
#include <cassert>
#include <sstream>
#include <numeric>
#include <string>
#include <vector>
#include <cstdio>
#include <bitset>
#include <cmath>
#include <ctime>
#include <queue>
#include <stack>
#include <map>
#include <set>

using namespace std;

#define pll pair < long long, long long>
#define all(a) a.begin(), a.end()
#define ull unsigned long long
#define pii pair < int, int >
#define np next_permutation
#define sz(a) (int)a.size()
#define sqr(x) ((x) * (x))
#define right stupid_right
#define left stupid_left
#define vi vector <int>
#define y1 stupid_cmath
#define ld long double
#define pb push_back
#define mp make_pair
#define ll long long
#define pi acos(-1)
#define s second
#define f first
#define endl "\n"

const int inf = (int)1e9;
const double eps = 1e-6;
const int mod = inf + 7;
const int N = 100000;

ll n, s;

struct point{
    ll x, y;
    point(){};
    point(ll x, ll y): x(x), y(y){};

    void read(){
        cin >> x >> y;
    }

    ll operator * (point p){return x * p.x + y * p.y;}//skalyarnoe proizvedenie (cos)

    ll operator % (point p){ return x * p.y - y * p.x;}//vectornoe proizvedenie (sin)

    bool operator == (const point &p) const{
        return p.x == x && p.y == y;
    }
    bool operator < (const point &p) const{
        return x < p.x || (x == p.x && y < p.y);
    }
    ll area(point a, point b){
        return ((a.x - x)*(b.y - y) - (b.x - x)*(a.y - y));
    }
}p1, p2, p3;
vector <point> a;

void convexhull(vector <point> &a){
    if((int)a.size() == 1) return;
    sort(a.begin(), a.end());
    point p1 = a[0];
    point p2 = a.back();
    vector <point> up, down;
    up.pb(p1);
    down.pb(p1);
    for(int i = 1; i < (int)a.size(); ++i){
        if((i == (int)a.size() - 1) || a[i].area(p1, p2) < 0){
            while((int)up.size() >= 2 && up[(int)up.size() - 1].area(up[(int)up.size() - 2], a[i]) >= 0){
                up.pop_back();
            }
            up.pb(a[i]);
        }
        if((i == (int)a.size() - 1) || a[i].area(p1, p2) > 0){
            while((int)down.size() >= 2 && down[(int)down.size() - 1].area(down[(int)down.size() - 2], a[i]) <= 0){
                down.pop_back();
            }
            down.pb(a[i]);
        }
    }
    a.clear();
    for(int i = 0; i < (int)up.size(); ++i){
        a.pb(up[i]);
    }
    for(int i = (int)down.size() - 2; i > 0; --i){
        a.pb(down[i]);
    }
}

int main() {
    ios_base::sync_with_stdio(0), cin.tie(0);
    cin >> n >> s;
    point x;
    for(int i = 0; i < n; ++i){
        x.read();
        a.pb(x);
    }
    convexhull(a);
    n = (int)a.size();
    ll ans = 0;
    for(int i = 0; i < n; ++i){
        int k = i + 1;
        for(int j = i + 1; j < n; ++j){
            while(abs(a[k % n].area(a[i], a[j])) < abs(a[(k + 1) % n].area(a[i], a[j]))){
                k++;
            }
            if(ans < abs(a[k % n].area(a[i], a[j]))){
                ans = abs(a[k % n].area(a[i], a[j]));
                p1 = a[i];
                p2 = a[k % n];
                p3 = a[j];
            }
        }
    }
//    cout << "!" << endl;
//    p1.print();
//    p2.print();
//    p3.print();
//    cout << "!" << endl;
    cout << (p1.x + p2.x - p3.x) << " " << (p1.y + p2.y - p3.y) << endl;
    cout << (p1.x - p2.x + p3.x) << " " << (p1.y - p2.y + p3.y) << endl;
    cout << (-p1.x + p2.x + p3.x) << " " << (-p1.y + p2.y + p3.y) << endl;
}


#include <bits/stdc++.h>

using namespace std;

#define pll pair < long long, long long>
#define all(a) a.begin(), a.end()
#define ull unsigned long long
#define pii pair < int, int >
#define np next_permutation
#define sz(a) (int)a.size()
#define sqr(x) ((x) * (x))
#define right stupid_right
#define left stupid_left
#define vi vector <int>
#define y1 stupid_cmath
#define ld long double
#define pb push_back
#define mp make_pair
#define ll long long
#define pi acos(-1)
#define s second
#define f first
#define endl "\n"

const int inf = (int)1e9;
const double eps = 1e-6;
const int mod = inf + 7;
const int N = 100000;

ll n, s;

struct point{
    ll x, y;
    point(){};
    point(ll x, ll y): x(x), y(y){};
    void read(){
        scanf("%I64d%I64d", &x, &y);
    }
    bool operator < (const point &p) const{
        return x < p.x || (x == p.x && y < p.y);
    }
    ll area(point a, point b){
        return ((a.x - x)*(b.y - y) - (b.x - x)*(a.y - y));
    }
} p1, p2, p3;
vector <point> a;

void convexhull(vector <point> &a){
    if((int)a.size() == 1) return;
    sort(a.begin(), a.end());
    point p1 = a[0];
    point p2 = a.back();
    vector <point> up, down;
    up.pb(p1);
    down.pb(p1);
    for(int i = 1; i < (int)a.size(); ++i){
        if((i == (int)a.size() - 1) || a[i].area(p1, p2) < 0){
            while((int)up.size() >= 2 && up[(int)up.size() - 1].area(up[(int)up.size() - 2], a[i]) >= 0){
                up.pop_back();
            }
            up.pb(a[i]);
        }
        if((i == (int)a.size() - 1) || a[i].area(p1, p2) > 0){
            while((int)down.size() >= 2 && down[(int)down.size() - 1].area(down[(int)down.size() - 2], a[i]) <= 0){
                down.pop_back();
            }
            down.pb(a[i]);
        }
    }
    a.clear();
    for(int i = 0; i < (int)up.size(); ++i){
        a.pb(up[i]);
    }
    for(int i = (int)down.size() - 2; i > 0; --i){
        a.pb(down[i]);
    }
}

int main() {
//    ios_base::sync_with_stdio(false);
//    cin.tie(NULL);
    scanf("%I64d %I64d", &n, &s);
    point x;
    for(int i = 0; i < n; ++i){
        x.read();
        a.pb(x);
    }
    convexhull(a);
    double ans = 0;
    for(int i = 0; i < n; ++i){
        int k = i + 1;
        for(int j = i + 1; j < n; ++j){
            while(abs(a[k % n].area(a[i], a[j])) < abs(a[(k + 1) % n].area(a[i], a[j]))){
                k++;
            }
            if(ans < abs(a[k % n].area(a[i], a[j]))){
                ans = abs(a[k % n].area(a[i], a[j]));
                p1 = a[i];
                p2 = a[k % n];
                p3 = a[j];
            }
        }
    }
    printf("%I64d %I64d\n",(p1.x + p2.x - p3.x),(p1.y + p2.y - p3.y));
    printf("%I64d %I64d\n",(p1.x - p2.x + p3.x),(p1.y - p2.y + p3.y));
    printf("%I64d %I64d",(-p1.x + p2.x + p3.x),(-p1.y + p2.y + p3.y));
}


#include <bits/stdc++.h>

using namespace std;

#define pii pair<int,int>
#define fi first
#define se second
#define int long long

const int N = 5000;

pii p[N];

int dist(pii a,pii b){
	return abs(a.fi-b.fi)+abs(a.se-b.se);
}

signed main(){
	int n, S;
	cin >> n >> S;
	for(int i=0;i<n;++i) cin >> p[i].fi >> p[i].se;
	sort(p,p+n);
	cout << p[0].fi << " " << p[0].se << endl;
	int l = 0, r = 1e9, s = 0;
	while(l<=r){
		int mid = (l+r)/2;
		bool all_in = true;
		for(int i=0;i<n;++i) all_in &= (dist(p[i],p[0])<=mid);
		if(all_in) s = mid, r = mid-1;
		else l = mid+1;
	}
	cout << p[0].fi+s << " " << p[0].se << endl;
	cout << p[0].fi << " " << p[0].se+s << endl;
}


#include <bits/stdc++.h>

using namespace std;

#define int long long
#define pt pair<int,int>
#define x first
#define y second

int cross(pt a, pt o, pt b){
	return (o.x-a.x)*(o.y-b.y)-(o.y-a.y)*(o.x-b.x);
}

int area(pt a, pt b, pt c){ // ez to remember
	return abs(a.x*(b.y-c.y) + b.x*(c.y-a.y) + c.x*(a.y-b.y));
}

vector<pt> build(vector<pt> &a){ // Andrew's monotone chain
	int n = a.size();
	sort(begin(a),end(a));
	vector<pt> up, down, hull;

	for(int i=0;i<n;++i){
		while(up.size()>=2 && cross(up[up.size()-2],up.back(),a[i])<=0)
			up.pop_back();
		up.push_back(a[i]);

		while(down.size()>=2 && cross(down[down.size()-2],down.back(),a[n-i-1])<=0)
			down.pop_back();
		down.push_back(a[n-i-1]);
	}
	for(auto p:up) hull.push_back(p);
	hull.pop_back();
	for(auto p:down) hull.push_back(p);
	hull.pop_back();

	return hull;
}

signed main(){
	int n,S;
	cin >> n >> S;
	vector<pt> A(n);
	for(int i=0;i<n;++i) cin >> A[i].x >> A[i].y;
	vector<pt> hull = build(A);

	int a = 0, b = 1, c = 2, s = hull.size(); // the max area triangle

	for(int i=0;i<s;++i){
		int p1 = (i+1)%s, p2 = (i+2)%s;
		while(p1!=(i+s-1)%s && p2!=(i+s-1)%s){
			if(area(hull[a],hull[b],hull[c])<area(hull[i],hull[p1],hull[p2]))
				a = i, b = p1, c = p2;
			if(area(hull[i],hull[p1],hull[p2])<area(hull[i],hull[p1],hull[(p2+1)%s]))
				p2 = (p2+1)%s;
			else p1 = (p1+1)%s;
		}
	}
	int arr[3] = {a,b,c};
	for(int i=0;i<3;++i){
		cout << hull[arr[i]].x+hull[arr[(i+1)%3]].x-hull[arr[(i+2)%3]].x << " ";
		cout << hull[arr[i]].y+hull[arr[(i+1)%3]].y-hull[arr[(i+2)%3]].y << endl;
	}
}


#include <bits/stdc++.h>

using namespace std;

#define int long long
#define pt pair<int,int>
#define x first
#define y second

int cross(pt a, pt o, pt b){
	return (o.x-a.x)*(o.y-b.y)-(o.y-a.y)*(o.x-b.x);
}

int area(pt a, pt b, pt c){ // ez to remember
	return abs(a.x*(b.y-c.y) + b.x*(c.y-a.y) + c.x*(a.y-b.y));
}

vector<pt> build(vector<pt> &a){ // Andrew's monotone chain
	int n = a.size();
	sort(begin(a),end(a));
	vector<pt> up, down, hull;

	for(int i=0;i<n;++i){
		while(up.size()>=2 && cross(up[up.size()-2],up.back(),a[i])<=0)
			up.pop_back();
		up.push_back(a[i]);

		while(down.size()>=2 && cross(down[down.size()-2],down.back(),a[n-i-1])<=0)
			down.pop_back();
		down.push_back(a[n-i-1]);
	}
	for(auto p:up) hull.push_back(p);
	hull.pop_back();
	for(auto p:down) hull.push_back(p);
	hull.pop_back();

	return hull;
}

signed main(){
	int n;
	cin >> n;
	vector<pt> A(n);
	for(int i=0;i<n;++i) cin >> A[i].x >> A[i].y;
	vector<pt> hull = build(A);

	int a = 0, b = 1, c = 2, s = hull.size(); // the max area triangle

	for(int i=0;i<s;++i){
		int p1 = (i+1)%s, p2 = (i+2)%s;
		while(p1!=(i+s-1)%s && p2!=(i+s-1)%s){
			if(area(hull[a],hull[b],hull[c])<area(hull[i],hull[p1],hull[p2]))
				a = i, b = p1, c = p2;
			if(area(hull[i],hull[p1],hull[p2])<area(hull[i],hull[p1],hull[(p2+1)%s]))
				p2 = (p2+1)%s;
			else p1 = (p1+1)%s;
		}
	}
	int arr[3] = {a,b,c};
	for(int i=0;i<3;++i){
		clog << i << ": " << hull[arr[i]].x << " " << hull[arr[i]].y << endl;
	}
	for(int i=0;i<3;++i){
		cout << hull[arr[i]].x+hull[arr[(i+1)%3]].x-hull[arr[(i+2)%3]].x << " ";
		cout << hull[arr[i]].y+hull[arr[(i+1)%3]].y-hull[arr[(i+2)%3]].y << endl;
	}
}


#include <bits/stdc++.h>

using namespace std;

#define pii pair<int,int>
#define fi first
#define se second
#define int long long

const int N = 5000;

pii p[N];

int dist(pii a,pii b){
	return abs(a.fi-b.fi)+abs(a.se-b.se);
}

signed main(){
	int n;
	cin >> n;
	for(int i=0;i<n;++i) cin >> p[i].fi >> p[i].se;
	sort(p,p+n);
	cout << p[0].fi << " " << p[0].se << endl;
	int l = 0, r = 1e9, s = 0;
	while(l<=r){
		int mid = (l+r)/2;
		bool all_in = true;
		for(int i=0;i<n;++i) all_in &= (dist(p[i],p[0])<=mid);
		if(all_in) s = mid, r = mid-1;
		else l = mid+1;
	}
	cout << p[0].fi+s << " " << p[0].se << endl;
	cout << p[0].fi << " " << p[0].se+s << endl;
}


#include <bits/stdc++.h>

using namespace std;

#define int long long
#define pt pair<int,int>
#define x first
#define y second

int cross(pt a, pt o, pt b){
	return (o.x-a.x)*(o.y-b.y)-(o.y-a.y)*(o.x-b.x);
}

int area(pt a, pt b, pt c){ // ez to remember
	return abs(a.x*(b.y-c.y) + b.x*(c.y-a.y) + c.x*(a.y-b.y));
}

vector<pt> build(vector<pt> &a){ // Andrew's monotone chain
	int n = a.size();
	sort(begin(a),end(a));
	vector<pt> up, down, hull;

	for(int i=0;i<n;++i){
		while(up.size()>=2 && cross(up[up.size()-2],up.back(),a[i])<=0)
			up.pop_back();
		up.push_back(a[i]);

		while(down.size()>=2 && cross(down[down.size()-2],down.back(),a[n-i-1])<=0)
			down.pop_back();
		down.push_back(a[n-i-1]);
	}
	for(auto p:up) hull.push_back(p);
	hull.pop_back();
	for(auto p:down) hull.push_back(p);
	hull.pop_back();

	return hull;
}

signed main(){
	int n;
	cin >> n;
	vector<pt> A(n);
	for(int i=0;i<n;++i) cin >> A[i].x >> A[i].y;
	vector<pt> hull = build(A);

	int a = 0, b = 1, c = 2, s = hull.size(); // the max area triangle

	for(int i=0;i<s;++i){
		int p1 = (i+1)%s, p2 = (i+2)%s;
		while(p1!=(i+s-1)%s && p2!=(i+s-1)%s){
			if(area(hull[a],hull[b],hull[c])<area(hull[i],hull[p1],hull[p2]))
				a = i, b = p1, c = p2;
			if(area(hull[i],hull[p1],hull[p2])<area(hull[i],hull[p1],hull[(p2+1)%s]))
				p2 = (p2+1)%s;
			else p1 = (p1+1)%s;
		}
	}
	int arr[3] = {a,b,c};
	for(int i=0;i<3;++i){
		cerr << i << ": " << hull[arr[i]].x << " " << hull[arr[i]].y << endl;
	}
	for(int i=0;i<3;++i){
		cout << hull[arr[i]].x+hull[arr[(i+1)%3]].x-hull[arr[(i+2)%3]].x << " ";
		cout << hull[arr[i]].y+hull[arr[(i+1)%3]].y-hull[arr[(i+2)%3]].y << endl;
	}
}


#include <bits/stdc++.h>

using namespace std;

#define int long long
#define pt pair<int,int>
#define x first
#define y second

int cross(pt a, pt o, pt b){
	return (o.x-a.x)*(o.y-b.y)-(o.y-a.y)*(o.x-b.x);
}

int area(pt a, pt b, pt c){ // ez to remember
	return abs(a.x*(b.y-c.y) + b.x*(c.y-a.y) + c.x*(a.y-b.y));
}

vector<pt> build(vector<pt> &a){ // Andrew's monotone chain
	int n = a.size();
	sort(begin(a),end(a));
	vector<pt> up, down, hull;

	for(int i=0;i<n;++i){
		while(up.size()>=2 && cross(up[up.size()-2],up.back(),a[i])<=0)
			up.pop_back();
		up.push_back(a[i]);

		while(down.size()>=2 && cross(down[down.size()-2],down.back(),a[n-i-1])<=0)
			down.pop_back();
		down.push_back(a[n-i-1]);
	}
	for(auto p:up) hull.push_back(p);
	hull.pop_back();
	for(auto p:down) hull.push_back(p);
	hull.pop_back();

	return hull;
}

signed main(){
	int n;
	cin >> n;
	vector<pt> A(n);
	for(int i=0;i<n;++i) cin >> A[i].x >> A[i].y;
	vector<pt> hull = build(A);

	int a = 0, b = 1, c = 2, s = hull.size(); // the max area triangle

	for(int i=0;i<s;++i){
		int p1 = (i+1)%s, p2 = (i+2)%s;
		while(p1!=(i+s-1)%s && p2!=(i+s-1)%s){
			if(area(hull[a],hull[b],hull[c])<area(hull[i],hull[p1],hull[p2]))
				a = i, b = p1, c = p2;
			if(area(hull[i],hull[p1],hull[p2])<area(hull[i],hull[p1],hull[(p2+1)%s]))
				p2 = (p2+1)%s;
			else p1 = (p1+1)%s;
		}
	}
	int arr[3] = {a,b,c};
	for(int i=0;i<3;++i){
		cout << hull[arr[i]].x+hull[arr[(i+1)%3]].x-hull[arr[(i+2)%3]].x << " ";
		cout << hull[arr[i]].y+hull[arr[(i+1)%3]].y-hull[arr[(i+2)%3]].y << endl;
	}
}


#include <bits/stdc++.h>
using namespace std;

#define FAST cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false)
#define endl "\n"
#define mp make_pair
#define pb push_back
#define F first
#define S second
typedef pair<int, int> pii;
typedef long long ll;

const long MAX_N = 100 * 1000 + 24, MAX_L = 20, INF = 1e9;

ll n, s;
pii points[MAX_N];

ll area (pii x, pii y, pii z) {
  return abs((x.F - y.F) * (z.S - y.S) - (z.F - y.F) * (x.S - y.S));
}

int32_t main() {
  FAST;
  cin>>n>>s;
  for (int i = 0; i < n; i++) {
    cin>>points[i].F>>points[i].S;
  }
  bool flag = true;
  int p1 = 0, p2 = 1, p3 = 2;
  while (flag) {
    flag = false;
    for (int i = 0; i < n; i++) {
      s = area(points[p1], points[p2], points[p3]);
      if (s < area(points[i], points[p2], points[p3])) {
        p1 = i;
        flag = true;
      }
      else if (s < area(points[p1], points[i], points[p3])) {
        p2 = i;
        flag = true;
      }
      else if (s < f(points[p1], points[p2], points[i])) {
        p3 = i;
        flag = true;
      }
    }
  }
  cout<<points[p1].F + points[p2].F - points[p3].F<<" "<<points[p1].S + points[p2].S - points[p3].S<<endl;
  cout<<points[p1].F - points[p2].F + points[p3].F<<" "<<points[p1].S - points[p2].S + points[p3].S<<endl;
  cout<<-points[p1].F + points[p2].F + points[p3].F<<" "<<-points[p1].S + points[p2].S + points[p3].S<<endl;

}


#include <bits/stdc++.h>
using namespace std;

#define FAST cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false)
#define endl "\n"
#define mp make_pair
#define pb push_back
#define F first
#define S second
#define int ll
typedef pair<int, int> pii;
typedef long long ll;

const long MAX_N = 100 * 1000 + 24, MAX_L = 20, INF = 1e9;

ll n, s;
pii points[MAX_N];

ll area (pii x, pii y, pii z) {
  return abs((x.F - y.F) * (z.S - y.S) - (z.F - y.F) * (x.S - y.S));
}

int32_t main() {
  FAST;
  cin>>n>>s;
  for (int i = 0; i < n; i++) {
    cin>>points[i].F>>points[i].S;
  }
  bool flag = true;
  int p1 = 0, p2 = 1, p3 = 2;
  while (flag) {
    flag = false;
    for (int i = 0; i < n; i++) {
      s = area(points[p1], points[p2], points[p3]);
      if (s < area(points[i], points[p2], points[p3])) {
        p1 = i;
        flag = true;
      }
      else if (s < area(points[p1], points[i], points[p3])) {
        p2 = i;
        flag = true;
      }
      else if (s < area(points[p1], points[p2], points[i])) {
        p3 = i;
        flag = true;
      }
    }
  }
  cout<<points[p1].F + points[p2].F - points[p3].F<<" "<<points[p1].S + points[p2].S - points[p3].S<<endl;
  cout<<points[p1].F - points[p2].F + points[p3].F<<" "<<points[p1].S - points[p2].S + points[p3].S<<endl;
  cout<<-points[p1].F + points[p2].F + points[p3].F<<" "<<-points[p1].S + points[p2].S + points[p3].S<<endl;

}


#include <bits/stdc++.h>
using namespace std;

#define FAST cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false)
#define endl "\n"
#define mp make_pair
#define pb push_back
#define F first
#define S second
typedef pair<int, int> pii;
typedef long long ll;

const long MAX_N = 100 * 1000 + 24, MAX_L = 20, INF = 1e9;

ll n, s;
pii points[MAX_N];

ll f (pii x, pii y, pii z) {
  return abs((x.F - y.F) * (z.S - y.S) - (z.F - y.F) * (x.S - y.S));
}

int32_t main() {
  FAST;
  cin>>n>>s;
  for (int i = 0; i < n; i++) {
    cin>>points[i].F>>points[i].S;
  }
  bool flag = true;
  int p1 = 0, p2 = 1, p3 = 2;
  while (flag) {
    flag = false;
    for (int i = 0; i < n; i++) {
      if (s < f(points[i], points[p2], points[p3])) {
        p1 = i;
        flag = true;
      }
      else if (s < f(points[p1], points[i], points[p3])) {
        p2 = i;
        flag = true;
      }
      else if (s < f(points[p1], points[p2], points[i])) {
        p3 = i;
        flag = true;
      }
    }
  }
  cout<<points[p1].F + points[p2].F - points[p3].F<<" "<<points[p1].S + points[p2].S - points[p3].S<<endl;
  cout<<points[p1].F - points[p2].F + points[p3].F<<" "<<points[p1].S - points[p2].S + points[p3].S<<endl;
  cout<<-points[p1].F + points[p2].F + points[p3].F<<" "<<-points[p1].S + points[p2].S + points[p3].S<<endl;

}


#include <bits/stdc++.h>
using namespace std;

#define FAST cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false)
#define endl "\n"
#define mp make_pair
#define pb push_back
#define F first
#define S second
typedef pair<int, int> pii;
typedef long long ll;

const long MAX_N = 100 * 1000 + 24, MAX_L = 20, INF = 1e9;

ll n, s;
pii points[MAX_N];

ll area (pii x, pii y, pii z) {
  return abs((x.F - y.F) * (z.S - y.S) - (z.F - y.F) * (x.S - y.S));
}

int32_t main() {
  FAST;
  cin>>n>>s;
  for (int i = 0; i < n; i++) {
    cin>>points[i].F>>points[i].S;
  }
  bool flag = true;
  int p1 = 0, p2 = 1, p3 = 2;
  while (flag) {
    flag = false;
    for (int i = 0; i < n; i++) {
      s = area(points[p1], points[p2], points[p3]);
      if (s < area(points[i], points[p2], points[p3])) {
        p1 = i;
        flag = true;
      }
      else if (s < area(points[p1], points[i], points[p3])) {
        p2 = i;
        flag = true;
      }
      else if (s < area(points[p1], points[p2], points[i])) {
        p3 = i;
        flag = true;
      }
    }
  }
  cout<<points[p1].F + points[p2].F - points[p3].F<<" "<<points[p1].S + points[p2].S - points[p3].S<<endl;
  cout<<points[p1].F - points[p2].F + points[p3].F<<" "<<points[p1].S - points[p2].S + points[p3].S<<endl;
  cout<<-points[p1].F + points[p2].F + points[p3].F<<" "<<-points[p1].S + points[p2].S + points[p3].S<<endl;

}


#include <bits/stdc++.h>
using namespace std;

#define FAST cin.tie(0), cout.tie(0), ios_base::sync_with_stdio(false)
#define endl "\n"
#define mp make_pair
#define pb push_back
#define F first
#define S second
typedef long long ll;
#define int ll
typedef pair<ll, ll> pii;

const long MAX_N = 100 * 1000 + 24, MAX_L = 20, INF = 1e9;

ll n, s;
pii points[MAX_N];

ll area (pii x, pii y, pii z) {
  return abs((x.F - y.F) * (z.S - y.S) - (z.F - y.F) * (x.S - y.S));
}

int32_t main() {
  FAST;
  cin>>n>>s;
  for (int i = 0; i < n; i++) {
    cin>>points[i].F>>points[i].S;
  }
  bool flag = true;
  int p1 = 0, p2 = 1, p3 = 2;
  while (flag) {
    flag = false;
    for (int i = 0; i < n; i++) {
      s = area(points[p1], points[p2], points[p3]);
      if (s < area(points[i], points[p2], points[p3])) {
        p1 = i;
        flag = true;
      }
      else if (s < area(points[p1], points[i], points[p3])) {
        p2 = i;
        flag = true;
      }
      else if (s < area(points[p1], points[p2], points[i])) {
        p3 = i;
        flag = true;
      }
    }
  }
  cout<<points[p1].F + points[p2].F - points[p3].F<<" "<<points[p1].S + points[p2].S - points[p3].S<<endl;
  cout<<points[p1].F - points[p2].F + points[p3].F<<" "<<points[p1].S - points[p2].S + points[p3].S<<endl;
  cout<<-points[p1].F + points[p2].F + points[p3].F<<" "<<-points[p1].S + points[p2].S + points[p3].S<<endl;

}