#pragma GCC target("arch=corei7-avx")
#include <bits/stdc++.h>
#define err(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
//#pragma GCC optimize "-O3"

using namespace std;

typedef long long ll;

const int dd = static_cast<int>(2e3) + 7;

int x[dd], y[dd];

int main() {
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	int n; ll ans;
	cin >> n >> ans;
	ans *= 2;
	for (int i = 0; i < n; i++) cin >> x[i] >> y[i];

	for (int i = 0; i < n; i++) {

		for (int j = 0; j < i; j++) x[j] -= x[i], y[j] -= y[i];

		for (int j = 0; j < i; j++) {
			for (int *a = x, *b = y; a != x + j; ++a, ++b) {
				ll cur = 1ll * x[j] * *b - 1ll * y[j] * *a;
				if (ans == cur || ans == -cur) {
					cout << "Yes\n";
					int k = a - x;
					cout << x[i] << " " << y[i] << "\n";
					cout << x[j] + x[i] << " " << y[j] + y[i] << "\n";
					cout << x[k] + x[i] << " " << y[k] + y[i] << "\n";
					return 0;
				}
			}
		}

		for (int j = 0; j < i; j++) x[j] += x[i], y[j] += y[i];
	}
	cout << "No\n";
	return 0;
}


#include <bits/stdc++.h>
#ifdef SIR
#define err(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#else
#define err(...) 42
#endif

typedef long long ll;

using namespace std;

const int dd = 2007;
int X[dd], Y[dd];

void solve() {
    int n;
    ll s;
    cin >> n >> s;
    s *= 2;
    for (int i = 0; i < n; i++) cin >> X[i] >> Y[i];
    for (int i = 0; i < n; i++) {
        int tx = X[i];
        int ty = Y[i];
        for (int j = 0; j < i; j++) {
            X[j] -= tx;
            Y[j] -= ty;
        }
        for (int j = 0; j < i; j++) {
            for (int k = 0; k < j; k++) {
                ll t = 1ll * X[j] * Y[k] - 1ll * X[k] * Y[j];
                if (t == s || t == -s) {
                    cout << "Yes\n";
                    cout << tx << ' ' << ty << '\n';
                    cout << X[j] + tx << ' ' << Y[j] + ty << '\n';
                    cout << X[k] + tx << ' ' << Y[k] + ty;
                    return;
                }
            }
        }
        for (int j = 0; j < i; j++) {
            X[j] += tx;
            Y[j] += ty;
        }
    }
    cout << "No";
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#ifdef SIR
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
   // stress();
    solve();
}


#include <bits/stdc++.h>
#define err(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#pragma GCC optimize "-O3"

using namespace std;

typedef long long ll;

const int dd = static_cast<int>(2e3) + 7;

int x[dd], y[dd];

int main() {
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	ll anss;
	int n;
	cin >> n >> anss;
	//ans *= 2;
	int ans = 2 * anss;
	for (int i = 0; i < n; i++) cin >> x[i] >> y[i];

	for (int i = 0; i < n; i++) {

		for (int j = 0; j < i; j++) x[j] -= x[i], y[j] -= y[i];

		for (int j = 0; j < i; j++) {
			for (int k = 0; k < j; k++) {
				int cur = x[j] * y[k] - y[j] * x[k];
				if (ans == cur || ans == -cur) {
					cout << "Yes\n";
					cout << x[i] << " " << y[i] << "\n";
					cout << x[j] + x[i] << " " << y[j] + y[i] << "\n";
					cout << x[k] + x[i] << " " << y[k] + y[i] << "\n";
					return 0;
				}
			}
		}

		for (int j = 0; j < i; j++) x[j] += x[i], y[j] += y[i];
	}
	cout << "No\n";
	return 0;
}


#include <bits/stdc++.h>
#define err(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#pragma GCC optimize "-O3"

using namespace std;

typedef long long ll;

const int dd = (1 << 12);

int x[dd], y[dd];

int main() {
	ios_base::sync_with_stdio(0);
	cin.tie(0);
	ll ans;
	int n; cin >> n >> ans;
	ans *= 2;
	for (int i = 0; i < n; i++) cin >> x[i] >> y[i];

	for (int i = 0; i < n; i++) {

		for (int j = 0; j < i; j++) x[j] -= x[i], y[j] -= y[i];

		for (int j = 0; j < i; j++) {
			for (int k = 0; k < j; k++) {

				{
					ll cur = 1ll * x[j] * y[k] - 1ll * y[j] * x[k];
					if (ans == cur || ans == -cur) {
						cout << "Yes\n";
						cout << x[i] << " " << y[i] << "\n";
						cout << x[j] + x[i] << " " << y[j] + y[i] << "\n";
						cout << x[k] + x[i] << " " << y[k] + y[i] << "\n";
						return 0;
					}
				}

			}
		}

		for (int j = 0; j < i; j++) x[j] += x[i], y[j] += y[i];
	}
	cout << "No\n";
	return 0;
}


#include <bits/stdc++.h>
#ifdef SIR
#define err(...) fprintf(stderr, __VA_ARGS__), fflush(stderr)
#else
#define err(...) 42
#endif

typedef long long ll;

using namespace std;

const int dd = 2007;
int X[dd], Y[dd];

void solve() {
    int n;
    ll s;
    cin >> n >> s;
    s *= 2;
    for (int i = 0; i < n; i++) cin >> X[i] >> Y[i];
    for (int i = 0; i < n; i++) {
        int tx = X[i];
        int ty = Y[i];
        for (int j = 0; j < i; j++) {
            X[j] -= tx;
            Y[j] -= ty;
        }
        for (int j = 0; j < i; j++) {
            for (int k = 0; k < j; k++) {
                ll t = 1ll * X[j] * Y[k] - 1ll * X[k] * Y[j];
                if (t == s || t == -s) {
                    cout << "Yes\n";
                    cout << tx << ' ' << ty << '\n';
                    cout << X[j] + tx << ' ' << Y[j] + ty << '\n';
                    cout << X[k] + tx << ' ' << Y[k] + ty;
                    return;
                }
            }
        }
        for (int j = 0; j < i; j++) {
            X[j] += tx;
            Y[j] += ty;
        }
    }
    cout << "No";
}

int main() {
    ios_base::sync_with_stdio(false);
    cin.tie(nullptr);
#ifdef SIR
    freopen("input.txt", "r", stdin);
    freopen("output.txt", "w", stdout);
#endif
   // stress();
    solve() ;
}


#include <cmath>
#include <cstdio>
using namespace std;

long long c[2050][2050];

int main ()
{
	int n, x[2050], y[2050];

	register long long s;
	scanf ("%d%lld", &n, &s);
	s <<= 1;
	for (register int i = 1; i <= n; ++i)
		scanf ("%d%d", &x[i], &y[i]);
	for (int i = 1; i <= n; ++i)
		for (int j = i + 1; j <= n; ++j)
			c[i][j] = 1ll * x[i] * y[j] - 1ll * y[i] * x[j];
	for (int i = 1; i <= n; ++i)
		for (int j = i + 1; j <= n; ++j)
			for (register int k = j + 1; k <= n; ++k)
			{
				long long sum = c[i][j] + c[j][k] - c[i][k];
				if (sum == s || -sum == s)
				{
					puts("Yes");
					printf ("%d %d\n", x[i], y[i]);
					printf ("%d %d\n", x[j], y[j]);
					printf ("%d %d\n", x[k], y[k]);
					return 0;
				}
			}
	puts("No");
	return 0;
}


#pragma GCC optimize ("Ofast")
#pragma GCC target ("avx")
#include <cmath>
#include <cstdio>
using namespace std;

long long c[2050][2050];

int main ()
{
	int n, x[2050], y[2050];

	register long long s;
	scanf ("%d%lld", &n, &s);
	s <<= 1;
	for (register int i = 1; i <= n; ++i)
		scanf ("%d%d", &x[i], &y[i]);
	for (int i = 1; i <= n; ++i)
		for (int j = i + 1; j <= n; ++j)
			c[i][j] = 1ll * x[i] * y[j] - 1ll * y[i] * x[j];
	for (int i = 1; i <= n; ++i)
		for (int j = i + 1; j <= n; ++j)
			for (register int k = j + 1; k <= n; ++k)
			{
				long long sum = c[i][j] + c[j][k] - c[i][k];
				if (sum == s || -sum == s)
				{
					puts("Yes");
					printf ("%d %d\n", x[i], y[i]);
					printf ("%d %d\n", x[j], y[j]);
					printf ("%d %d\n", x[k], y[k]);
					return 0;
				}
			}
	puts("No");
	return 0;
}


#include <cmath>
#include <cstdio>
using namespace std;

int main ()
{
	int n, x[2050], y[2050];
	register long long s;
	scanf ("%d%lld", &n, &s);
	s <<= 1;
	for (register int i = 1; i <= n; ++i)
		scanf ("%d%d", &x[i], &y[i]);
	for (int i = 1; i <= n; ++i)
		for (int j = i + 1; j <= n; ++j)
			for (register int k = j + 1; k <= n; ++k)
			{
				long long sum = ((1ll * x[i] * y[j] - 1ll * y[i] * x[j]) + (1ll * x[j] * y[k] - 1ll * y[j] * x[k]) + (1ll * x[k] * y[i] - 1ll * y[k] * x[i]));
				if (sum == s || -sum == s)
				{
					puts("Yes");
					printf ("%d %d\n", x[i], y[i]);
					printf ("%d %d\n", x[j], y[j]);
					printf ("%d %d\n", x[k], y[k]);
					return 0;
				}
			}
	puts("No");
	return 0;
}


#include <cmath>
#include <cstdio>
using namespace std;

int main ()
{
	int n, x[2050], y[2050];
	register long long s;
	scanf ("%d%lld", &n, &s);
	s <<= 1;
	for (register int i = 1; i <= n; ++i)
		scanf ("%d%d", &x[i], &y[i]);
	for (register int i = 1; i <= n; ++i)
		for (register int j = i + 1; j <= n; ++j)
			for (register int k = j + 1; k <= n; ++k)
			{
				long long sum = ((1ll * x[i] * y[j] - 1ll * y[i] * x[j]) + (1ll * x[j] * y[k] - 1ll * y[j] * x[k]) + (1ll * x[k] * y[i] - 1ll * y[k] * x[i]));
				if (sum == s || -sum == s)
				{
					puts("Yes");
					printf ("%d %d\n", x[i], y[i]);
					printf ("%d %d\n", x[j], y[j]);
					printf ("%d %d\n", x[k], y[k]);
					return 0;
				}
			}
	puts("No");
	return 0;
}


#pragma GCC optimize ("Ofast")
#pragma GCC target ("avx")
#include <cmath>
#include <cstdio>
using namespace std;

int main ()
{
	int n, x[2050], y[2050];
	register long long s;
	scanf ("%d%lld", &n, &s);
	s <<= 1;
	for (register int i = 1; i <= n; ++i)
		scanf ("%d%d", &x[i], &y[i]);
	for (int i = 1; i <= n; ++i)
		for (int j = i + 1; j <= n; ++j)
			for (register int k = j + 1; k <= n; ++k)
			{
				long long sum = ((1ll * x[i] * y[j] - 1ll * y[i] * x[j]) + (1ll * x[j] * y[k] - 1ll * y[j] * x[k]) + (1ll * x[k] * y[i] - 1ll * y[k] * x[i]));
				if (sum == s || -sum == s)
				{
					puts("Yes");
					printf ("%d %d\n", x[i], y[i]);
					printf ("%d %d\n", x[j], y[j]);
					printf ("%d %d\n", x[k], y[k]);
					return 0;
				}
			}
	puts("No");
	return 0;
}


#include <cstdio>
#include <algorithm>
#include <immintrin.h>
using namespace std;

typedef long long ll;
int x[2008],y[2008],n,lo1,lo2;
ll S;

inline int naive(int x1,int y1,int x2,int y2,int offset){

    return -1;
}

int main(){
    scanf("%d%lld",&n,&S);
    S*=2;
    lo1=S;
    lo2=-S;
    for(int i=0;i<n;i++)
        scanf("%d%d",&x[i],&y[i]);
    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++){
            x[j]-=x[i];
            y[j]-=y[i];
        }
        for(int j=i+1;j<n;j++)
            for(int k=j+1;k<n;k++){
                int a32=x[j]*y[k]-x[k]*y[j];
                if(a32==lo1||a32==lo2){
                    ll area=abs(ll(x[j])*ll(y[k])-ll(x[k])*ll(y[j]));
                    if(area==S){
                        printf("Yes\n");
                        printf("%d %d\n",x[i],y[i]);
                        printf("%d %d\n",x[j],y[j]);
                        printf("%d %d\n",x[k],y[k]);
                        return 0;
                    }
                }
            }
    }
    printf("No\n");
}


#include <cstdio>
#include <algorithm>
#include <immintrin.h>
using namespace std;

typedef long long ll;
int x[2008],y[2008],n,lo1,lo2;
ll S;

inline int naive(int x1,int y1,int x2,int y2,int offset){

    return -1;
}

int main(){
    scanf("%d%lld",&n,&S);
    S*=2;
    lo1=S;
    lo2=-S;
    for(int i=0;i<n;i++)
        scanf("%d%d",&x[i],&y[i]);
    for(int i=0;i<n;i++)
        for(int j=i+1;j<n;j++)
            for(int k=j+1;k<n;k++){
                int ux=x[k]-x[i],uy=y[k]-y[i],vx=x[k]-x[j],vy=y[k]-y[j],a32=ux*vy-vx*uy;
                if(a32==lo1||a32==lo2){
                    ll area=abs(ll(ux)*ll(vy)-ll(vx)*ll(uy));
                    if(area==S){
                        printf("Yes\n");
                        printf("%d %d\n",x[i],y[i]);
                        printf("%d %d\n",x[j],y[j]);
                        printf("%d %d\n",x[k],y[k]);
                        return 0;
                    }
                }
            }
    printf("No\n");
}


#include <cstdio>
#include <algorithm>
using namespace std;

typedef long long ll;
int n,x[2000],y[2000];
ll S;

int main(){
    scanf("%d%lld",&n,&S);
    S*=2;
    for(int i=0;i<n;i++)
        scanf("%d%d",&x[i],&y[i]);
    for(int i=0;i<n;i++)
        for(int j=i+1;j<n;j++)
            for(int k=j+1;k<n;k++){
                int ux=x[k]-x[i],uy=y[k]-y[i],vx=x[k]-x[j],vy=y[k]-y[j];
                ll area=abs(ll(ux)*ll(vy)-ll(vx)*ll(uy));
                if(area==S){
                    printf("Yes\n");
                    printf("%d %d\n",x[i],y[i]);
                    printf("%d %d\n",x[j],y[j]);
                    printf("%d %d\n",x[k],y[k]);
                    return 0;
                }
            }
    printf("No\n");
}


#include <cstdio>
#include <algorithm>
#include <immintrin.h>
using namespace std;

typedef long long ll;
int x[2008],y[2008],n,lo1,lo2;
ll S;
/*
inline bool simd(int x1,int y1,int x2,int y2,int offset){
    unsigned lo1=(S*2)&0xFFFFFFFFLL,lo2=(-S*2)&0xFFFFFFFFLL;
    __m256i x1m=_mm256_set1_epi32(x1),
            y1m=_mm256_set1_epi32(y1),
            x2m=_mm256_set1_epi32(x2),
            y2m=_mm256_set1_epi32(y2),
            l1m=_mm256_set1_epi32(lo1),
            l2m=_mm256_set1_epi32(lo2);
    for(int k=offset;k<n;k+=8){
        __m256i xs=_mm256_loadu_si256((__m256i_u *)(x+k)),
                ys=_mm256_loadu_si256((__m256i_u *)(y+k)),
                ux=_mm256_sub_epi32(xs,x1m),
                uy=_mm256_sub_epi32(ys,y1m),
                vx=_mm256_sub_epi32(xs,x2m),
                vy=_mm256_sub_epi32(ys,y2m),
                t1=_mm256_mullo_epi32(ux,vy),
                t2=_mm256_mullo_epi32(vx,uy),
                a32=_mm256_sub_epi32(t1,t2);
        __mmask8 r1=_mm256_cmpeq_epi32_mask(a32,l1m),
                 r2=_mm256_cmpeq_epi32_mask(a32,l2m),
                 r=r1|r2;
        if(r)
            for(int l=0;l<8;l++)
                if((r&(1<<l))&&(k+l<n))return true;
    }
    return false;
}
*/
inline int naive(int x1,int y1,int x2,int y2,int offset){
    for(int k=offset;k<n;k++){
        int ux=x[k]-x1,uy=y[k]-y1,vx=x[k]-x2,vy=y[k]-y2,a32=ux*vy-vx*uy;
        if(a32==lo1||a32==lo2){
            ll area=abs(ll(ux)*ll(vy)-ll(vx)*ll(uy));
            if(area==S)return k;
        }
    }
    return -1;
}

int main(){
    scanf("%d%lld",&n,&S);
    S*=2;
    lo1=S;
    lo2=-S;
    for(int i=0;i<n;i++)
        scanf("%d%d",&x[i],&y[i]);
    for(int i=0;i<n;i++)
        for(int j=i+1;j<n;j++){
            int k=naive(x[i],y[i],x[j],y[j],j+1);
            if(k>=0){
                printf("Yes\n");
                printf("%d %d\n",x[i],y[i]);
                printf("%d %d\n",x[j],y[j]);
                printf("%d %d\n",x[k],y[k]);
                return 0;
            }
        }
    printf("No\n");
}


#include <cstdio>
#include <algorithm>
#include <immintrin.h>
using namespace std;

typedef long long ll;
int x[2008],y[2008],n,lo1,lo2;
ll S;
/*
inline bool simd(int x1,int y1,int x2,int y2,int offset){
    unsigned lo1=(S*2)&0xFFFFFFFFLL,lo2=(-S*2)&0xFFFFFFFFLL;
    __m256i x1m=_mm256_set1_epi32(x1),
            y1m=_mm256_set1_epi32(y1),
            x2m=_mm256_set1_epi32(x2),
            y2m=_mm256_set1_epi32(y2),
            l1m=_mm256_set1_epi32(lo1),
            l2m=_mm256_set1_epi32(lo2);
    for(int k=offset;k<n;k+=8){
        __m256i xs=_mm256_loadu_si256((__m256i_u *)(x+k)),
                ys=_mm256_loadu_si256((__m256i_u *)(y+k)),
                ux=_mm256_sub_epi32(xs,x1m),
                uy=_mm256_sub_epi32(ys,y1m),
                vx=_mm256_sub_epi32(xs,x2m),
                vy=_mm256_sub_epi32(ys,y2m),
                t1=_mm256_mullo_epi32(ux,vy),
                t2=_mm256_mullo_epi32(vx,uy),
                a32=_mm256_sub_epi32(t1,t2);
        __mmask8 r1=_mm256_cmpeq_epi32_mask(a32,l1m),
                 r2=_mm256_cmpeq_epi32_mask(a32,l2m),
                 r=r1|r2;
        if(r)
            for(int l=0;l<8;l++)
                if((r&(1<<l))&&(k+l<n))return true;
    }
    return false;
}
*/
inline int naive(int x1,int y1,int x2,int y2,int offset){
    for(int k=offset;k<n;k++){
        int ux=x[k]-x1,uy=y[k]-y1,vx=x[k]-x2,vy=y[k]-y2,a32=ux*vy-vx*uy;
        if(a32==lo1||a32==lo2){
            ll area=abs(ll(ux)*ll(vy)-ll(vx)*ll(uy));
            if(area==S)return true;
        }
    }
    return -1;
}

int main(){
    scanf("%d%lld",&n,&S);
    S*=2;
    lo1=S;
    lo2=-S;
    for(int i=0;i<n;i++)
        scanf("%d%d",&x[i],&y[i]);
    for(int i=0;i<n;i++)
        for(int j=i+1;j<n;j++){
            int k=naive(x[i],y[i],x[j],y[j],j+1);
            if(k>=0){
                printf("Yes\n");
                printf("%d %d\n",x[i],y[i]);
                printf("%d %d\n",x[j],y[j]);
                printf("%d %d\n",x[k],y[k]);
                return 0;
            }
        }
    printf("No\n");
}


#include <cstdio>
#include <algorithm>
using namespace std;

typedef long long ll;
int n,x[2000],y[2000];
ll S;

int main(){
    scanf("%d%lld",&n,&S);
    S*=2;
    for(int i=0;i<n;i++)
        scanf("%d%d",&x[i],&y[i]);
    for(int i=0;i<n;i++)
        for(int j=i+1;j<n;j++)
            for(int k=j+1;k<n;k++){
                int ux=x[k]-x[i],uy=y[k]-y[i],vx=x[k]-x[j],vy=y[k]-y[j];
                ll area=abs(ll(ux)*ll(vy)-ll(vx)*ll(uy));
                if(area==S){
                    printf("Yes\n");
                    printf("&d &d\n",x[i],y[i]);
                    printf("&d &d\n",x[j],y[j]);
                    printf("&d &d\n",x[k],y[k]);
                    return 0;
                }
            }
    printf("No\n");
}


#include <cstdio>
#include <algorithm>
#include <immintrin.h>
using namespace std;

typedef long long ll;
int x0[2000],y0[2000],x[2000],y[2000],n,lo1,lo2;
ll S;

inline int naive(int x1,int y1,int x2,int y2,int offset){

    return -1;
}

int main(){
    scanf("%d%lld",&n,&S);
    S*=2;
    lo1=S;
    lo2=-S;
    for(int i=0;i<n;i++){
        scanf("%d%d",&x[i],&y[i]);
        x0[i]=x[i];
        y0[i]=y[i];
    }
    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++){
            x[j]-=x[i];
            y[j]-=y[i];
        }
        for(int j=i+1;j<n;j++)
            for(int k=j+1;k<n;k++){
                int a32=x[j]*y[k]-x[k]*y[j];
                if(a32==lo1||a32==lo2){
                    ll area=abs(ll(x[j])*ll(y[k])-ll(x[k])*ll(y[j]));
                    if(area==S){
                        printf("Yes\n");
                        printf("%d %d\n",x[i],y[i]);
                        printf("%d %d\n",x[j],y[j]);
                        printf("%d %d\n",x[k],y[k]);
                        return 0;
                    }
                }
            }
    }
    printf("No\n");
}


#include <cstdio>
#include <algorithm>
#include <immintrin.h>
using namespace std;

typedef long long ll;
int x0[2000],y0[2000],x[2000],y[2000],n,lo1,lo2;
ll S;

inline int naive(int x1,int y1,int x2,int y2,int offset){

    return -1;
}

int main(){
    scanf("%d%lld",&n,&S);
    S*=2;
    lo1=S;
    lo2=-S;
    for(int i=0;i<n;i++){
        scanf("%d%d",&x[i],&y[i]);
        x0[i]=x[i];
        y0[i]=y[i];
    }
    for(int i=0;i<n;i++){
        for(int j=i+1;j<n;j++){
            x[j]-=x[i];
            y[j]-=y[i];
        }
        for(int j=i+1;j<n;j++)
            for(int k=j+1;k<n;k++){
                int a32=x[j]*y[k]-x[k]*y[j];
                if(a32==lo1||a32==lo2){
                    ll area=abs(ll(x[j])*ll(y[k])-ll(x[k])*ll(y[j]));
                    if(area==S){
                        printf("Yes\n");
                        printf("%d %d\n",x0[i],y0[i]);
                        printf("%d %d\n",x0[j],y0[j]);
                        printf("%d %d\n",x0[k],y0[k]);
                        return 0;
                    }
                }
            }
    }
    printf("No\n");
}


#include <bits/stdc++.h>

#define F0R(i, a) for(int i = 0; i < (a); i++)
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define R0F(i, a) for(int i = (a) - 1; i >= 0; i--)
#define ROF(i, a, b) for(int i = (b) - 1; i >= (a); i--)

#define ran() (rand() & 0x7FFF)
#define rand31() ((ran() << 16) | (ran() << 1) | (ran() & 1))
#define rand32() ((ran() << 17) | (ran() << 2) | (ran() & 3))
#define rand63() (((ll)ran() << 48) | ((ll)ran() << 33) | ((ll)ran() << 18) | ((ll)ran() << 3) | ((ll)ran() & 7))
#define rand64() (((ll)ran() << 49) | ((ll)ran() << 34) | ((ll)ran() << 19) | ((ll)ran() << 4) | ((ll)ran() & 15))

#define F first
#define S second
#define PB push_back
#define MP make_pair
#define MT make_tuple
#define UB upper_bound
#define LB lower_bound
#define X real()
#define Y imag()

#define PI acos(-1)

#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define SQ(x) ((x) * (x))

using namespace std;

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpii;
typedef vector<ll> vll;
typedef vector<ull> vul;
typedef complex<ld> point;
typedef complex<ld> cld;
typedef vector<cld> vcld;

#define MAXN 2000

int n, pos[MAXN];
ld area;
vector<point> points;
vector<pair<ld, pii>> v;

ld getangle(int i, int j) {
	ld ang = arg(points[pos[j]] - points[pos[i]]);
	if(ang > PI) ang -= PI;
	return ang;
}

int find(ld v, ld slope) {
	int lo = 0, hi = n;
	while(lo <= hi) {
		int mid = (lo + hi) >> 1;
		ld inter = points[mid].X - points[mid].Y / slope;
		if(abs(inter - v) < 0.000001) return mid;
		else if(inter < v) hi = mid - 1;
		else lo = mid + 1;
	}
	return -1;
}

bool compFunc(point p1, point p2) {
	if(p1.Y != p2.Y) return p1.Y < p2.Y;
	return p1.X < p2.X;
}

int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cin >> n >> area;
	F0R(i, n) {
		ld x, y;
		cin >> x >> y;
		points.PB(point(x, y));
		pos[i] = i;
	}

	sort(all(points), compFunc);

	F0R(i, n) FOR(j, i + 1, n) v.PB(MP(getangle(i, j), MP(i, j)));
	sort(all(v));

	for(const pair<ld, pii> p : v) {
		swap(pos[p.S.F], pos[p.S.S]);
		swap(points[pos[p.S.F]], points[pos[p.S.S]]);
		if(p.F == 0 || abs(p.F - PI / 2) < 0.000001) continue;

		point p1 = points[pos[p.S.F]], p2 = points[pos[p.S.S]];
		ld slope = (p1.Y - p2.Y) / (p1.X - p2.X);

		ld base = sqrt(SQ(p2.X - p1.X) + SQ(p2.Y - p1.Y));
		ld disneed = 2 * area / base;
		ld offset = sqrt(SQ(slope) + 1) * disneed / slope;
		ld inter = p1.X - p1.Y / slope;
		int i = find(inter - offset, slope);
		if(i != -1) {
			cout << "Yes" << endl;
			cout << p1.X << " " << p1.Y << endl;
			cout << p2.X << " " << p2.Y << endl;
			cout << points[i].X << " " << points[i].Y << endl;
			return 0;
		}
		i = find(inter + offset, slope);
		if(i != -1) {
			cout << "Yes" << endl;
			cout << p1.X << " " << p1.Y << endl;
			cout << p2.X << " " << p2.Y << endl;
			cout << points[i].X << " " << points[i].Y << endl;
			return 0;
		}
	}
	cout << "No" << endl;
}


#include <bits/stdc++.h>

#define F0R(i, a) for(int i = 0; i < (a); i++)
#define FOR(i, a, b) for(int i = (a); i < (b); i++)
#define R0F(i, a) for(int i = (a) - 1; i >= 0; i--)
#define ROF(i, a, b) for(int i = (b) - 1; i >= (a); i--)

#define ran() (rand() & 0x7FFF)
#define rand31() ((ran() << 16) | (ran() << 1) | (ran() & 1))
#define rand32() ((ran() << 17) | (ran() << 2) | (ran() & 3))
#define rand63() (((ll)ran() << 48) | ((ll)ran() << 33) | ((ll)ran() << 18) | ((ll)ran() << 3) | ((ll)ran() & 7))
#define rand64() (((ll)ran() << 49) | ((ll)ran() << 34) | ((ll)ran() << 19) | ((ll)ran() << 4) | ((ll)ran() & 15))

#define F first
#define S second
#define PB push_back
#define MP make_pair
#define MT make_tuple
#define UB upper_bound
#define LB lower_bound
#define X real()
#define Y imag()

#define PI acos(-1)

#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define SQ(x) ((x) * (x))

using namespace std;

typedef long long ll;
typedef long double ld;
typedef unsigned long long ull;
typedef pair<int, int> pii;
typedef vector<int> vi;
typedef vector<pii> vpii;
typedef vector<ll> vll;
typedef vector<ull> vul;
typedef complex<ld> point;
typedef complex<ld> cld;
typedef vector<cld> vcld;

#define MAXN 2000

int n, pos[MAXN];
ld area;
vector<point> points;
vector<pair<ld, pii>> v;

ld getangle(int i, int j) {
	ld ang = arg(points[pos[j]] - points[pos[i]]);
	if(ang > PI) ang -= PI;
	return ang;
}

int find(ld v, ld slope) {
	int lo = 0, hi = n;
	while(lo <= hi) {
		int mid = (lo + hi) >> 1;
		ld inter = points[mid].X - points[mid].Y / slope;
		if(abs(inter - v) < 0.000001) return mid;
		else if(inter < v) hi = mid - 1;
		else lo = mid + 1;
	}
	return -1;
}

bool compFunc(point p1, point p2) {
	if(p1.Y != p2.Y) return p1.Y < p2.Y;
	return p1.X < p2.X;
}

int main() {
	ios::sync_with_stdio(0);
	cin.tie(0);
	cin >> n >> area;
	F0R(i, n) {
		ld x, y;
		cin >> x >> y;
		points.PB(point(x, y));
		pos[i] = i;
	}

	sort(all(points), compFunc);

	F0R(i, n) FOR(j, i + 1, n) v.PB(MP(getangle(i, j), MP(i, j)));
	sort(all(v));

	cout << fixed << " " << setprecision(0) << endl;
	for(const pair<ld, pii> p : v) {
		swap(pos[p.S.F], pos[p.S.S]);
		swap(points[pos[p.S.F]], points[pos[p.S.S]]);
		if(p.F == 0 || abs(p.F - PI / 2) < 0.000001) continue;

		point p1 = points[pos[p.S.F]], p2 = points[pos[p.S.S]];
		ld slope = (p1.Y - p2.Y) / (p1.X - p2.X);

		ld base = sqrt(SQ(p2.X - p1.X) + SQ(p2.Y - p1.Y));
		ld disneed = 2 * area / base;
		ld offset = sqrt(SQ(slope) + 1) * disneed / slope;
		ld inter = p1.X - p1.Y / slope;
		int i = find(inter - offset, slope);
		if(i != -1) {
			cout << "Yes" << endl;
			cout << p1.X << " " << p1.Y << endl;
			cout << p2.X << " " << p2.Y << endl;
			cout << points[i].X << " " << points[i].Y << endl;
			return 0;
		}
		i = find(inter + offset, slope);
		if(i != -1) {
			cout << "Yes" << endl;
			cout << p1.X << " " << p1.Y << endl;
			cout << p2.X << " " << p2.Y << endl;
			cout << points[i].X << " " << points[i].Y << endl;
			return 0;
		}
	}
	cout << "No" << endl;
}


#ifdef LOCAL
#  define _GLIBCXX_DEBUG
#  define _GLIBCXX_DEBUG_PEDANTIC
#endif

#include "bits/stdc++.h"
#define ff first
#define ss second
#define szof(_x) ((int) (_x).size())
#define TASK_NAME ""

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int INF = 1e9 + 7;
const ll INFL = 1e18 + 123;
const double PI = atan2(0, -1);
mt19937 tw(960172);
ll rnd(ll x, ll y) { static uniform_int_distribution<ll> d; return d(tw) % (y - x + 1) + x; }

struct point {
	int x, y;
	point() : x(0), y(0) {}
	point(int _x, int _y) : x(_x), y(_y) {}

	point operator+(point const& other) const {
		return point(x + other.x, y + other.y);
	}

	point operator-(point const& other) const {
		return point(x - other.x, y - other.y);
	}
};

ostream& operator<<(ostream& o, point const& p) {
	o << p.x << " " << p.y;
	return o;
}

ll cross(point const& p1, point const& p2) {
	return p1.x * p2.y - p1.y * p2.x;
}

void solve() {
	int n;
	ll s;
	cin >> n >> s;
	vector<point> inp;
	for (int i = 0; i < n; ++i) {
		int x, y;
		cin >> x >> y;
		inp.push_back(point(x, y));
	}

	vector<pair<point, pii>> all;
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			if (i == j) {
				continue;
			}
			point p = inp[j] - inp[i];
			if (p.y > 0 || (p.y == 0 && p.x > 0)) {
				all.push_back({p, {i, j}});
			}
		}
	}

	//cerr << "before sort " << clock() * 1000 / CLOCKS_PER_SEC << endl;

	sort(all.begin(), all.end(), [](pair<point, pii> const& p1, pair<point, pii> const& p2) {
		//return cross(p1.ff, p2.ff) > 0;
		return (ll) p1.ff.x * p2.ff.y > (ll) p1.ff.y * p2.ff.x;
	});

	//cerr << "after sort " << clock() * 1000 / CLOCKS_PER_SEC << endl;

	vector<int> order(n);
	iota(order.begin(), order.end(), 0);

	sort(order.begin(), order.end(), [&](int p1, int p2) {
		return cross(all[0].ff, inp[p1] - inp[all[0].ss.ff]) < cross(all[0].ff, inp[p2] - inp[all[0].ss.ff]);
	});

	vector<int> where(n);
	for (int i = 0; i < n; ++i) {
		where[order[i]] = i;
	}

	for (auto& p : all) {
		int l = 0, r = n;
		while (r - l > 1) {
			int mid = (l + r) / 2;
			ll tmp = cross(p.ff, inp[order[mid]] - inp[p.ss.ff]);
			if (tmp <= s * 2) {
				l = mid;
			} else {
				r = mid;
			}
		}

		if (cross(p.ff, inp[order[l]] - inp[p.ss.ff]) == s * 2) {
			cout << "Yes\n";
			cout << inp[p.ss.ff] << "\n" << inp[p.ss.ss] << "\n" << inp[order[l]] << "\n";
			return;
		}

		l = -1;
		while (r - l > 1) {
			int mid = (l + r) / 2;
			ll tmp = cross(p.ff, inp[order[mid]] - inp[p.ss.ff]);
			if (tmp < -s * 2) {
				l = mid;
			} else {
				r = mid;
			}
		}

		if (cross(p.ff, inp[order[r]] - inp[p.ss.ff]) == -s * 2) {
			cout << "Yes\n";
			cout << inp[p.ss.ff] << "\n" << inp[p.ss.ss] << "\n" << inp[order[r]] << "\n";
			return;
		}

		int& pos1 = where[p.ss.ff];
		int& pos2 = where[p.ss.ss];
		swap(order[pos1], order[pos2]);
		swap(pos1, pos2);
	}

	cout << "No\n";
}

int main() {
	//freopen(TASK_NAME ".in", "r", stdin);
	//freopen(TASK_NAME ".out", "w", stdout);
	cerr << fixed << setprecision(15);
	cout << fixed << setprecision(15);
	ios::sync_with_stdio(false);

	int tests = 1;
	// cin >> tests;
	for (int it = 1; it <= tests; ++it) {
		solve();
	}

	#ifdef LOCAL
		cerr << "time: " << clock() << " ms\n";
	#endif
	return 0;
}


#ifdef LOCAL
#  define _GLIBCXX_DEBUG
#  define _GLIBCXX_DEBUG_PEDANTIC
#endif

#include "bits/stdc++.h"
#define ff first
#define ss second
#define szof(_x) ((int) (_x).size())
#define TASK_NAME ""

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int INF = 1e9 + 7;
const ll INFL = 1e18 + 123;
const double PI = atan2(0, -1);
mt19937 tw(960172);
ll rnd(ll x, ll y) { static uniform_int_distribution<ll> d; return d(tw) % (y - x + 1) + x; }

struct point {
	int x, y;
	point() : x(0), y(0) {}
	point(int _x, int _y) : x(_x), y(_y) {}

	point operator+(point const& other) const {
		return point(x + other.x, y + other.y);
	}

	point operator-(point const& other) const {
		return point(x - other.x, y - other.y);
	}
};

ostream& operator<<(ostream& o, point const& p) {
	o << p.x << " " << p.y;
	return o;
}

ll cross(point const& p1, point const& p2) {
	return p1.x * p2.y - p1.y * p2.x;
}

void solve() {
	int n;
	ll s;
	cin >> n >> s;
	vector<point> inp;
	for (int i = 0; i < n; ++i) {
		int x, y;
		cin >> x >> y;
		inp.push_back(point(x, y));
	}

	vector<pair<point, pii>> all;
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			if (i == j) {
				continue;
			}
			point p = inp[j] - inp[i];
			if (p.y > 0 || (p.y == 0 && p.x > 0)) {
				all.push_back({p, {i, j}});
			}
		}
	}

	//cerr << "before sort " << clock() * 1000 / CLOCKS_PER_SEC << endl;

	sort(all.begin(), all.end(), [](pair<point, pii> const& p1, pair<point, pii> const& p2) {
		//return cross(p1.ff, p2.ff) > 0;
		return p1.ff.x * p2.ff.y > p1.ff.y * p2.ff.x;
	});

	//cerr << "after sort " << clock() * 1000 / CLOCKS_PER_SEC << endl;

	vector<int> order(n);
	iota(order.begin(), order.end(), 0);

	sort(order.begin(), order.end(), [&](int p1, int p2) {
		return cross(all[0].ff, inp[p1] - inp[all[0].ss.ff]) < cross(all[0].ff, inp[p2] - inp[all[0].ss.ff]);
	});

	vector<int> where(n);
	for (int i = 0; i < n; ++i) {
		where[order[i]] = i;
	}

	for (auto& p : all) {
		int l = 0, r = n;
		while (r - l > 1) {
			int mid = (l + r) / 2;
			ll tmp = cross(p.ff, inp[order[mid]] - inp[p.ss.ff]);
			if (tmp <= s * 2) {
				l = mid;
			} else {
				r = mid;
			}
		}

		if (cross(p.ff, inp[order[l]] - inp[p.ss.ff]) == s * 2) {
			cout << "Yes\n";
			cout << inp[p.ss.ff] << "\n" << inp[p.ss.ss] << "\n" << inp[order[l]] << "\n";
			return;
		}

		l = -1;
		while (r - l > 1) {
			int mid = (l + r) / 2;
			ll tmp = cross(p.ff, inp[order[mid]] - inp[p.ss.ff]);
			if (tmp < -s * 2) {
				l = mid;
			} else {
				r = mid;
			}
		}

		if (cross(p.ff, inp[order[r]] - inp[p.ss.ff]) == -s * 2) {
			cout << "Yes\n";
			cout << inp[p.ss.ff] << "\n" << inp[p.ss.ss] << "\n" << inp[order[r]] << "\n";
			return;
		}

		int& pos1 = where[p.ss.ff];
		int& pos2 = where[p.ss.ss];
		swap(order[pos1], order[pos2]);
		swap(pos1, pos2);
	}

	cout << "No\n";
}

int main() {
	//freopen(TASK_NAME ".in", "r", stdin);
	//freopen(TASK_NAME ".out", "w", stdout);
	cerr << fixed << setprecision(15);
	cout << fixed << setprecision(15);
	ios::sync_with_stdio(false);

	int tests = 1;
	// cin >> tests;
	for (int it = 1; it <= tests; ++it) {
		solve();
	}

	#ifdef LOCAL
		cerr << "time: " << clock() << " ms\n";
	#endif
	return 0;
}


#ifdef LOCAL
#  define _GLIBCXX_DEBUG
#  define _GLIBCXX_DEBUG_PEDANTIC
#endif

#include "bits/stdc++.h"
#define ff first
#define ss second
#define szof(_x) ((int) (_x).size())
#define TASK_NAME ""

using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int INF = 1e9 + 7;
const ll INFL = 1e18 + 123;
const double PI = atan2(0, -1);
mt19937 tw(960172);
ll rnd(ll x, ll y) { static uniform_int_distribution<ll> d; return d(tw) % (y - x + 1) + x; }

struct point {
	int x, y;
	point() : x(0), y(0) {}
	point(int _x, int _y) : x(_x), y(_y) {}

	point operator+(point const& other) const {
		return point(x + other.x, y + other.y);
	}

	point operator-(point const& other) const {
		return point(x - other.x, y - other.y);
	}
};

ostream& operator<<(ostream& o, point const& p) {
	o << p.x << " " << p.y;
	return o;
}

ll cross(point const& p1, point const& p2) {
	return (ll) p1.x * p2.y - (ll) p1.y * p2.x;
}

void solve() {
	int n;
	ll s;
	cin >> n >> s;
	vector<point> inp;
	for (int i = 0; i < n; ++i) {
		int x, y;
		cin >> x >> y;
		inp.push_back(point(x, y));
	}

	vector<pair<point, pii>> all;
	for (int i = 0; i < n; ++i) {
		for (int j = 0; j < n; ++j) {
			if (i == j) {
				continue;
			}
			point p = inp[j] - inp[i];
			if (p.y > 0 || (p.y == 0 && p.x > 0)) {
				all.push_back({p, {i, j}});
			}
		}
	}

	//cerr << "before sort " << clock() * 1000 / CLOCKS_PER_SEC << endl;

	sort(all.begin(), all.end(), [](pair<point, pii> const& p1, pair<point, pii> const& p2) {
		//return cross(p1.ff, p2.ff) > 0;
		return (ll) p1.ff.x * p2.ff.y > (ll) p1.ff.y * p2.ff.x;
	});

	//cerr << "after sort " << clock() * 1000 / CLOCKS_PER_SEC << endl;

	vector<int> order(n);
	iota(order.begin(), order.end(), 0);

	sort(order.begin(), order.end(), [&](int p1, int p2) {
		return cross(all[0].ff, inp[p1] - inp[all[0].ss.ff]) < cross(all[0].ff, inp[p2] - inp[all[0].ss.ff]);
	});

	vector<int> where(n);
	for (int i = 0; i < n; ++i) {
		where[order[i]] = i;
	}

	for (auto& p : all) {
		int l = 0, r = n;
		while (r - l > 1) {
			int mid = (l + r) / 2;
			ll tmp = cross(p.ff, inp[order[mid]] - inp[p.ss.ff]);
			if (tmp <= s * 2) {
				l = mid;
			} else {
				r = mid;
			}
		}

		if (cross(p.ff, inp[order[l]] - inp[p.ss.ff]) == s * 2) {
			cout << "Yes\n";
			cout << inp[p.ss.ff] << "\n" << inp[p.ss.ss] << "\n" << inp[order[l]] << "\n";
			return;
		}

		l = -1;
		while (r - l > 1) {
			int mid = (l + r) / 2;
			ll tmp = cross(p.ff, inp[order[mid]] - inp[p.ss.ff]);
			if (tmp < -s * 2) {
				l = mid;
			} else {
				r = mid;
			}
		}

		if (cross(p.ff, inp[order[r]] - inp[p.ss.ff]) == -s * 2) {
			cout << "Yes\n";
			cout << inp[p.ss.ff] << "\n" << inp[p.ss.ss] << "\n" << inp[order[r]] << "\n";
			return;
		}

		int& pos1 = where[p.ss.ff];
		int& pos2 = where[p.ss.ss];
		swap(order[pos1], order[pos2]);
		swap(pos1, pos2);
	}

	cout << "No\n";
}

int main() {
	//freopen(TASK_NAME ".in", "r", stdin);
	//freopen(TASK_NAME ".out", "w", stdout);
	cerr << fixed << setprecision(15);
	cout << fixed << setprecision(15);
	ios::sync_with_stdio(false);

	int tests = 1;
	// cin >> tests;
	for (int it = 1; it <= tests; ++it) {
		solve();
	}

	#ifdef LOCAL
		cerr << "time: " << clock() << " ms\n";
	#endif
	return 0;
}


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

int n, x[2020], y[2020];
ll S, G[2020][2020];

int main(){
  cin>>n>>S; S<<=1;
  for (int i=1;i<=n;++i) cin>>x[i]>>y[i];
  for (int i=1;i<n;++i)
    for (int j=i+1;j<=n;++j)
      G[i][j]= (ll)x[i]*y[j]-(ll)x[j]*y[i];
  for (int i=1;i<n;++i)
    for (int j=i+1;j<n;++j){
      ll aim1=S-G[i][j], aim2=-S-G[i][j];
      for (register int k=j+1;k<=n;++k){
        ll t=-G[i][k]+G[j][k];
        if (t==aim1||t==aim2){
          printf("Yes\n%d %d\n%d %d\n%d %d\n",x[i],y[i],x[j],y[j],x[k],y[k]);
          return 0;
        }
      }
    }
  puts("No");
}


#pragma GCC target("arch=corei7-avx")
#include<bits/stdc++.h>
#define ll long long
using namespace std;

int n, x[2020], y[2020];
ll S, G[2020][2020];

int main(){
  cin>>n>>S; S<<=1;
  for (int i=1;i<=n;++i) cin>>x[i]>>y[i];
  for (int i=1;i<n;++i)
    for (int j=i+1;j<=n;++j)
      G[i][j]= (ll)x[i]*y[j]-(ll)x[j]*y[i];
  for (int i=1;i<n;++i)
    for (int j=i+1;j<n;++j){
      ll aim1=S-G[i][j], aim2=-S-G[i][j];
      for (register int k=j+1;k<=n;++k){
        ll t=-G[i][k]+G[j][k];
        if (t==aim1||t==aim2){
          printf("Yes\n%d %d\n%d %d\n%d %d\n",x[i],y[i],x[j],y[j],x[k],y[k]);
          return 0;
        }
      }
    }
  puts("No");
}


#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
template<class L, class R> istream &operator>>(istream &in, pair<L, R> &p){ return in >> p.first >> p.second; }
template<class Tuple, size_t ...Is> void read_tuple(istream &in, Tuple &t, index_sequence<Is...>){ ((in >> get<Is>(t)), ...); }
template<class ...Args> istream &operator>>(istream &in, tuple<Args...> &t){ read_tuple(in, t, index_sequence_for<Args...>{}); return in; }
template<class ...Args, template<class...> class T> istream &operator>>(enable_if_t<!is_same_v<T<Args...>, string>, istream> &in, T<Args...> &arr){ for(auto &x: arr) in >> x; return in; }
//template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << "(" << p.first << ", " << p.second << ")"; }
template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << p.first << " " << p.second << "\n"; }
template<class Tuple, size_t ...Is> void print_tuple(ostream &out, const Tuple &t, index_sequence<Is...>){ ((out << (Is ? " " : "") << get<Is>(t)), ...); }
template<class ...Args> ostream &operator<<(ostream &out, const tuple<Args...> &t){ print_tuple(out, t, index_sequence_for<Args...>{}); return out << "\n"; }
template<class ...Args, template<class...> class T> ostream &operator<<(enable_if_t<!is_same_v<T<Args...>, string>, ostream> &out, const T<Args...> &arr){ for(auto &x: arr) out << x << " "; return out << "\n"; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rngll(chrono::steady_clock::now().time_since_epoch().count());
#define all(a) a.begin(), a.end()
#define sz(a) (int)a.size()
typedef long long ll;
typedef vector<int> vi; typedef vector<ll> vl; typedef vector<double> vd; typedef vector<string> vs;
typedef pair<int, int> pii; typedef pair<ll, ll> pll; typedef pair<int, ll> pil; typedef pair<ll, int> pli;
typedef vector<pii> vpii; typedef vector<pil> vpil; typedef vector<pli> vpli; typedef vector<pll> vpll;
template<class T> T ctmax(T &x, const T &y){ return x = max(x, y); }
template<class T> T ctmin(T &x, const T &y){ return x = min(x, y); }
template<class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef tuple<int, int, int> tpl; typedef vector<tpl> vtpl;

template<class T = ll> struct point{
	T x, y;
	int from, to;
	template<class U> point(const point<U> &otr): x(otr.x), y(otr.y){ }
	template<class U, class V> point(const pair<U, V> &p): x(p.first), y(p.second){ }
	template<class U = T, class V = T> point(U x = 0, V y = 0): x(x), y(y){ }
	template<class U> explicit operator point<U>() const{ return point<U>(static_cast<U>(x), static_cast<U>(y)); }
	T operator*(const point &otr) const{ return x * otr.x + y * otr.y; }
	T operator^(const point &otr) const{ return x * otr.y - y * otr.x; }
	point operator+(const point &otr) const{ return point(x + otr.x, y + otr.y); }
	point &operator+=(const point &otr){ return *this = *this + otr; }
	point operator-(const point &otr) const{ return point(x - otr.x, y - otr.y); }
	point &operator-=(const point &otr){ return *this = *this - otr; }
	point operator*(const T &c) const{ return point(x * c, y * c); }
	point &operator*=(const T &c) { return *this = *this * c; }
	point operator/(const T &c) const{ return point(x / c, y / c); }
	point &operator/=(const T &c) { return *this = *this / c; }
	point operator-() const{ return point(-x, -y); }
	bool operator<(const point &otr) const{ return x == otr.x ? y > otr.y : x < otr.x; }
	bool operator>(const point &otr) const{ return tie(x, y) > tie(otr.x, otr.y); }
	bool operator<=(const point &otr) const{ return tie(x, y) <= tie(otr.x, otr.y); }
	bool operator>=(const point &otr) const{ return tie(x, y) >= tie(otr.x, otr.y); }
	bool operator==(const point &otr) const{ return tie(x, y) == tie(otr.x, otr.y); }
	bool operator!=(const point &otr) const{ return tie(x, y) != tie(otr.x, otr.y); }
	double norm() const{ return sqrt(x * x + y * y); }
	T sqnorm() const{ return x * x + y * y; }
	double arg() const{ return atan2(y, x); } // [-pi, pi]
	point<double> unit() const{ return point<double>(x, y) / norm(); }
	point perp() const{ return point(-y, x); }
	point<double> normal() const{ return perp().unit(); }
	point<double> rotate(const double &theta) const{ return point<double>(x * cos(theta) - y * sin(theta), x * sin(theta) + y * cos(theta)); }
	point reflect_x() const{ return point(x, -y); }
	point reflect_y() const{ return point(-x, y); }
};
template<class T> point<T> operator*(const T &c, const point<T> &p){ return point<T>(c * p.x, c * p.y); }
template<class T> istream &operator>>(istream &in, point<T> &p){ return in >> p.x >> p.y; }
template<class T> ostream &operator<<(ostream &out, const point<T> &p){ return out << pair<T, T>(p.x, p.y); }
template<class T> double distance(const point<T> &p, const point<T> &q){ return (p - q).norm(); }
template<class T> T squared_distance(const point<T> &p, const point<T> &q){ return (p - q).sqnorm(); }
template<class T, class U, class V> T ori(const point<T> &p, const point<U> &q, const point<V> &r){ return (q - p) ^ (r - p); }
template<class T> T doubled_signed_area(const vector<point<T>> &arr){
	T s = arr.back() ^ arr.front();
	for(int i = 1; i < sz(arr); ++ i) s += arr[i - 1] ^ arr[i];
	return s;
}
template<class T = ll> struct line{
	point<T> p, d; // p + d*t
	template<class U = T, class V = T> line(point<U> p = {0, 0}, point<V> q = {0, 0}, bool Two_Points = true): p(p), d(Two_Points ? q - p : q){ }
	template<class U> line(point<U> d): p(), d(static_cast<point<T>>(d)){ }
	line(T a, T b, T c): p(a ? -c / a : 0, !a && b ? -c / b : 0), d(-b, a){ }
	template<class U> explicit operator line<U>() const{ return line<U>(point<U>(p), point<U>(d), false); }
	point<T> q() const{ return p + d; }
	bool degen() const{ return d == point<T>(); }
	tuple<T, T, T> coef(){ return {d.y, -d.x, d.perp() * p}; } // d.y (X - p.x) - d.x (Y - p.y) = 0
};
template<class T> bool parallel(const line<T> &L, const line<T> &M){ return !(L.d ^ M.d); }
template<class T> bool on_line(const point<T> &p, const line<T> &L){
	if(L.degen()) return p == L.p;
	return (p - L.p) ^ L.d == 0;
}
template<class T> bool on_ray(const point<T> &p, const line<T> &L){
	if(L.degen()) return p == L.p;
	auto a = L.p - p, b = L.q() - p;
	return !(a ^ b) && a * L.d <= 0;
}
template<class T> bool on_segment(const point<T> &p, const line<T> &L){
	if(L.degen()) return p == L.p;
	auto a = L.p - p, b = L.q() - p;
	return !(a ^ b) && a * b <= 0;
}
template<class T> double distance_to_line(const point<T> &p, const line<T> &L){
	if(L.degen()) return distance(p, L.p);
	return abs((p - L.p) ^ L.d) / L.d.norm();
}
template<class T> double distance_to_ray(const point<T> &p, const line<T> &L){
	if((p - L.p) * L.d <= 0) return distance(p, L.p);
	return distance_to_line(p, L);
}
template<class T> double distance_to_segment(const point<T> &p, const line<T> &L){
	if((p - L.p) * L.d <= 0) return distance(p, L.p);
	if((p - L.q()) * L.d >= 0) return distance(p, L.q());
	return distance_to_line(p, L);
}
template<class T> point<double> projection(const point<T> &p, const line<T> &L){ return static_cast<point<double>>(L.p) + (L.degen() ? point<double>() : (p - L.p) * L.d / L.d.norm() * static_cast<point<double>>(L.d)); }
template<class T> point<double> reflection(const point<T> &p, const line<T> &L){ return 2.0 * projection(p, L) - static_cast<point<double>>(p); }
template<class T> point<double> closest_point_on_segment(const point<T> &p, const line<T> &L){ return (p - L.p) * L.d <= 0 ? static_cast<point<double>>(L.p) : ((p - L.q()) * L.d >= 0 ? static_cast<point<double>>(L.q()) : projection(p, L)); }
template<int TYPE> struct EndpointChecker{ };
// For rays
template<> struct EndpointChecker<0>{ template<class T> bool operator()(const T& a, const T& b) const{ return true; } }; // For ray
// For closed end
template<> struct EndpointChecker<1>{ template<class T> bool operator()(const T& a, const T& b) const{ return a <= b; } }; // For closed end
// For open end
template<> struct EndpointChecker<2>{ template<class T> bool operator()(const T& a, const T& b) const{ return a < b; } }; // For open end
// Assumes parallel lines do not intersect
template<int LA, int LB, int RA, int RB, class T> pair<bool, point<double>> intersect_no_parallel_overlap(const line<T> &L, const line<T> &M){
	auto s = L.d ^ M.d;
	if(!s) return {false, point<double>()};
	auto ls = (M.p - L.p) ^ M.d, rs = (M.p - L.p) ^ L.d;
	if(s < 0) s = -s, ls = -ls, rs = -rs;
	bool intersect = EndpointChecker<LA>()(decltype(ls)(0), ls) && EndpointChecker<LB>()(ls, s) && EndpointChecker<RA>()(decltype(rs)(0), rs) && EndpointChecker<RB>()(rs, s);
	return {intersect, static_cast<point<double>>(L.p) + 1.0 * ls / s * static_cast<point<double>>(L.d)};
}
// Assumes parallel lines do not intersect
template<class T> pair<bool, point<double>> intersect_closed_segments_no_parallel_overlap(const line<T> &L, const line<T> &M) {
	return intersect_no_parallel_overlap<1, 1, 1, 1>(L, M);
}
// Assumes nothing
template<class T> pair<bool, line<double>> intersect_closed_segments(const line<T> &L, const line<T> &M){
	auto s = L.d ^ M.d, ls = (M.p - L.p) ^ M.d;
	if(!s){
		if(ls) return {false, line<double>()};
		auto Lp = L.p, Lq = L.q(), Mp = M.p, Mq = M.q();
		if(Lp > Lq) swap(Lp, Lq);
		if(Mp > Mq) swap(Mp, Mq);
		line<double> res(max(Lp, Mp), min(Lq, Mq));
		return {res.d >= point<double>(), res};
	}
	auto rs = (M.p - L.p) ^ L.d;
	if(s < 0) s = -s, ls = -ls, rs = -rs;
	bool intersect = 0 <= ls && ls <= s && 0 <= rs && rs <= s;
	return {intersect, line<double>(static_cast<point<double>>(L.p) + 1.0 * ls / s * static_cast<point<double>>(L.d), point<double>())};
}
template<class T> double distance_between_rays(const line<T> &L, const line<T> &M){
	if(parallel(L, M)){
		if(L.d * M.d >= 0 || (M.p - L.p) * M.d <= 0) return distance_to_line(L.p, M);
		else return distance(L.p, M.p);
	}
	else{
		if(intersect_no_parallel_overlap<1, 0, 1, 0, ll>(L, M).first) return 0;
		else return min(distance_to_ray(L.p, M), distance_to_ray(M.p, L));
	}
}
template<class T> double distance_between_segments(const line<T> &L, const line<T> &M){
	if(intersect_closed_segments(L, M).first) return 0;
	return min({distance_to_segment(L.p, M), distance_to_segment(L.q(), M), distance_to_segment(M.p, L), distance_to_segment(M.q(), L)});
}
template<class P> struct compare_by_angle{
	const P origin;
	compare_by_angle(const P &origin = P()): origin(origin){ }
	bool operator()(const P &p, const P &q) const{ return ori(origin, p, q) > 0; }
};
template<class It, class P> void sort_by_angle(It first, It last, const P &origin){
	first = partition(first, last, [&origin](const decltype(*first) &point){ return point == origin; });
	auto pivot = partition(first, last, [&origin](const decltype(*first) &point) { return point > origin; });
	compare_by_angle<P> cmp(origin);
	sort(first, pivot, cmp), sort(pivot, last, cmp);
}

int main(){
	cin.tie(0)->sync_with_stdio(0);
	int n;
	ll S;
	cin >> n >> S, S <<= 1;
	vector<point<ll>> a(n);
	for(auto &x: a){
		static int i = 0;
		cin >> x;
		x.from = i ++;
	}
	vector<point<ll>> t;
	t.reserve(n * n);
	for(int i = 0; i < n; ++ i){
		for(int j = i + 1; j < n; ++ j){
			t.push_back(a[i] - a[j]);
			t.back().from = j, t.back().to = i;
			t.push_back(a[j] - a[i]);
			t.back().from = i, t.back().to = j;
		}
	}
	sort_by_angle(all(t), point<ll>{0, 0});
	sort(all(a));
	vi pos(n);
	for(int i = 0; i < n; ++ i){
		pos[a[i].from] = i;
	}
	auto kill = [](tuple<point<ll>, point<ll>, point<ll>> x){
	    cout << "Yes\n" << x;
	    exit(0);
	};
	for(auto p: t){
		int i = lower_bound(all(a), point<ll>(), [&](const point<ll> &q, const point<ll> &r){
			return ori(a[pos[p.from]], a[pos[p.to]], q) < S;
		}) - a.begin();
		if(i < n && S == ori(a[pos[p.from]], a[pos[p.to]], a[i])){
			kill({a[pos[p.from]], a[pos[p.to]], a[i]});
		}
		swap(a[pos[p.from]], a[pos[p.to]]);
		swap(pos[p.from], pos[p.to]);
	}
	cout << "No";
	return 0;
}

/*

*/

////////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//                                   Coded by Aeren                                   //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////////


#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
template<class L, class R> istream &operator>>(istream &in, pair<L, R> &p){ return in >> p.first >> p.second; }
template<class Tuple, size_t ...Is> void read_tuple(istream &in, Tuple &t, index_sequence<Is...>){ ((in >> get<Is>(t)), ...); }
template<class ...Args> istream &operator>>(istream &in, tuple<Args...> &t){ read_tuple(in, t, index_sequence_for<Args...>{}); return in; }
template<class ...Args, template<class...> class T> istream &operator>>(enable_if_t<!is_same_v<T<Args...>, string>, istream> &in, T<Args...> &arr){ for(auto &x: arr) in >> x; return in; }
//template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << "(" << p.first << ", " << p.second << ")"; }
template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << p.first << " " << p.second << "\n"; }
template<class Tuple, size_t ...Is> void print_tuple(ostream &out, const Tuple &t, index_sequence<Is...>){ ((out << (Is ? " " : "") << get<Is>(t)), ...); }
template<class ...Args> ostream &operator<<(ostream &out, const tuple<Args...> &t){ print_tuple(out, t, index_sequence_for<Args...>{}); return out << "\n"; }
template<class ...Args, template<class...> class T> ostream &operator<<(enable_if_t<!is_same_v<T<Args...>, string>, ostream> &out, const T<Args...> &arr){ for(auto &x: arr) out << x << " "; return out << "\n"; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rngll(chrono::steady_clock::now().time_since_epoch().count());
#define all(a) a.begin(), a.end()
#define sz(a) (int)a.size()
typedef long long ll;
typedef vector<int> vi; typedef vector<ll> vl; typedef vector<double> vd; typedef vector<string> vs;
typedef pair<int, int> pii; typedef pair<ll, ll> pll; typedef pair<int, ll> pil; typedef pair<ll, int> pli;
typedef vector<pii> vpii; typedef vector<pil> vpil; typedef vector<pli> vpli; typedef vector<pll> vpll;
template<class T> T ctmax(T &x, const T &y){ return x = max(x, y); }
template<class T> T ctmin(T &x, const T &y){ return x = min(x, y); }
template<class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef tuple<int, int, int> tpl; typedef vector<tpl> vtpl;

template<class T = ll> struct point{
	T x, y;
	int from, to;
	template<class U> point(const point<U> &otr): x(otr.x), y(otr.y){ }
	template<class U, class V> point(const pair<U, V> &p): x(p.first), y(p.second){ }
	template<class U = T, class V = T> point(U x = 0, V y = 0): x(x), y(y){ }
	template<class U> explicit operator point<U>() const{ return point<U>(static_cast<U>(x), static_cast<U>(y)); }
	T operator*(const point &otr) const{ return x * otr.x + y * otr.y; }
	T operator^(const point &otr) const{ return x * otr.y - y * otr.x; }
	point operator+(const point &otr) const{ return point(x + otr.x, y + otr.y); }
	point &operator+=(const point &otr){ return *this = *this + otr; }
	point operator-(const point &otr) const{ return point(x - otr.x, y - otr.y); }
	point &operator-=(const point &otr){ return *this = *this - otr; }
	point operator*(const T &c) const{ return point(x * c, y * c); }
	point &operator*=(const T &c) { return *this = *this * c; }
	point operator/(const T &c) const{ return point(x / c, y / c); }
	point &operator/=(const T &c) { return *this = *this / c; }
	point operator-() const{ return point(-x, -y); }
	bool operator<(const point &otr) const{ return x == otr.x ? y > otr.y : x < otr.x; }
	bool operator>(const point &otr) const{ return tie(x, y) > tie(otr.x, otr.y); }
	bool operator<=(const point &otr) const{ return tie(x, y) <= tie(otr.x, otr.y); }
	bool operator>=(const point &otr) const{ return tie(x, y) >= tie(otr.x, otr.y); }
	bool operator==(const point &otr) const{ return tie(x, y) == tie(otr.x, otr.y); }
	bool operator!=(const point &otr) const{ return tie(x, y) != tie(otr.x, otr.y); }
	double norm() const{ return sqrt(x * x + y * y); }
	T sqnorm() const{ return x * x + y * y; }
	double arg() const{ return atan2(y, x); } // [-pi, pi]
	point<double> unit() const{ return point<double>(x, y) / norm(); }
	point perp() const{ return point(-y, x); }
	point<double> normal() const{ return perp().unit(); }
	point<double> rotate(const double &theta) const{ return point<double>(x * cos(theta) - y * sin(theta), x * sin(theta) + y * cos(theta)); }
	point reflect_x() const{ return point(x, -y); }
	point reflect_y() const{ return point(-x, y); }
};
template<class T> point<T> operator*(const T &c, const point<T> &p){ return point<T>(c * p.x, c * p.y); }
template<class T> istream &operator>>(istream &in, point<T> &p){ return in >> p.x >> p.y; }
template<class T> ostream &operator<<(ostream &out, const point<T> &p){ return out << pair<T, T>(p.x, p.y); }
template<class T> double distance(const point<T> &p, const point<T> &q){ return (p - q).norm(); }
template<class T> T squared_distance(const point<T> &p, const point<T> &q){ return (p - q).sqnorm(); }
template<class T, class U, class V> T ori(const point<T> &p, const point<U> &q, const point<V> &r){ return (q - p) ^ (r - p); }
template<class T> T doubled_signed_area(const vector<point<T>> &arr){
	T s = arr.back() ^ arr.front();
	for(int i = 1; i < sz(arr); ++ i) s += arr[i - 1] ^ arr[i];
	return s;
}
template<class T = ll> struct line{
	point<T> p, d; // p + d*t
	template<class U = T, class V = T> line(point<U> p = {0, 0}, point<V> q = {0, 0}, bool Two_Points = true): p(p), d(Two_Points ? q - p : q){ }
	template<class U> line(point<U> d): p(), d(static_cast<point<T>>(d)){ }
	line(T a, T b, T c): p(a ? -c / a : 0, !a && b ? -c / b : 0), d(-b, a){ }
	template<class U> explicit operator line<U>() const{ return line<U>(point<U>(p), point<U>(d), false); }
	point<T> q() const{ return p + d; }
	bool degen() const{ return d == point<T>(); }
	tuple<T, T, T> coef(){ return {d.y, -d.x, d.perp() * p}; } // d.y (X - p.x) - d.x (Y - p.y) = 0
};
template<class T> bool parallel(const line<T> &L, const line<T> &M){ return !(L.d ^ M.d); }
template<class T> bool on_line(const point<T> &p, const line<T> &L){
	if(L.degen()) return p == L.p;
	return (p - L.p) ^ L.d == 0;
}
template<class T> bool on_ray(const point<T> &p, const line<T> &L){
	if(L.degen()) return p == L.p;
	auto a = L.p - p, b = L.q() - p;
	return !(a ^ b) && a * L.d <= 0;
}
template<class T> bool on_segment(const point<T> &p, const line<T> &L){
	if(L.degen()) return p == L.p;
	auto a = L.p - p, b = L.q() - p;
	return !(a ^ b) && a * b <= 0;
}
template<class T> double distance_to_line(const point<T> &p, const line<T> &L){
	if(L.degen()) return distance(p, L.p);
	return abs((p - L.p) ^ L.d) / L.d.norm();
}
template<class T> double distance_to_ray(const point<T> &p, const line<T> &L){
	if((p - L.p) * L.d <= 0) return distance(p, L.p);
	return distance_to_line(p, L);
}
template<class T> double distance_to_segment(const point<T> &p, const line<T> &L){
	if((p - L.p) * L.d <= 0) return distance(p, L.p);
	if((p - L.q()) * L.d >= 0) return distance(p, L.q());
	return distance_to_line(p, L);
}
template<class T> point<double> projection(const point<T> &p, const line<T> &L){ return static_cast<point<double>>(L.p) + (L.degen() ? point<double>() : (p - L.p) * L.d / L.d.norm() * static_cast<point<double>>(L.d)); }
template<class T> point<double> reflection(const point<T> &p, const line<T> &L){ return 2.0 * projection(p, L) - static_cast<point<double>>(p); }
template<class T> point<double> closest_point_on_segment(const point<T> &p, const line<T> &L){ return (p - L.p) * L.d <= 0 ? static_cast<point<double>>(L.p) : ((p - L.q()) * L.d >= 0 ? static_cast<point<double>>(L.q()) : projection(p, L)); }
template<int TYPE> struct EndpointChecker{ };
// For rays
template<> struct EndpointChecker<0>{ template<class T> bool operator()(const T& a, const T& b) const{ return true; } }; // For ray
// For closed end
template<> struct EndpointChecker<1>{ template<class T> bool operator()(const T& a, const T& b) const{ return a <= b; } }; // For closed end
// For open end
template<> struct EndpointChecker<2>{ template<class T> bool operator()(const T& a, const T& b) const{ return a < b; } }; // For open end
// Assumes parallel lines do not intersect
template<int LA, int LB, int RA, int RB, class T> pair<bool, point<double>> intersect_no_parallel_overlap(const line<T> &L, const line<T> &M){
	auto s = L.d ^ M.d;
	if(!s) return {false, point<double>()};
	auto ls = (M.p - L.p) ^ M.d, rs = (M.p - L.p) ^ L.d;
	if(s < 0) s = -s, ls = -ls, rs = -rs;
	bool intersect = EndpointChecker<LA>()(decltype(ls)(0), ls) && EndpointChecker<LB>()(ls, s) && EndpointChecker<RA>()(decltype(rs)(0), rs) && EndpointChecker<RB>()(rs, s);
	return {intersect, static_cast<point<double>>(L.p) + 1.0 * ls / s * static_cast<point<double>>(L.d)};
}
// Assumes parallel lines do not intersect
template<class T> pair<bool, point<double>> intersect_closed_segments_no_parallel_overlap(const line<T> &L, const line<T> &M) {
	return intersect_no_parallel_overlap<1, 1, 1, 1>(L, M);
}
// Assumes nothing
template<class T> pair<bool, line<double>> intersect_closed_segments(const line<T> &L, const line<T> &M){
	auto s = L.d ^ M.d, ls = (M.p - L.p) ^ M.d;
	if(!s){
		if(ls) return {false, line<double>()};
		auto Lp = L.p, Lq = L.q(), Mp = M.p, Mq = M.q();
		if(Lp > Lq) swap(Lp, Lq);
		if(Mp > Mq) swap(Mp, Mq);
		line<double> res(max(Lp, Mp), min(Lq, Mq));
		return {res.d >= point<double>(), res};
	}
	auto rs = (M.p - L.p) ^ L.d;
	if(s < 0) s = -s, ls = -ls, rs = -rs;
	bool intersect = 0 <= ls && ls <= s && 0 <= rs && rs <= s;
	return {intersect, line<double>(static_cast<point<double>>(L.p) + 1.0 * ls / s * static_cast<point<double>>(L.d), point<double>())};
}
template<class T> double distance_between_rays(const line<T> &L, const line<T> &M){
	if(parallel(L, M)){
		if(L.d * M.d >= 0 || (M.p - L.p) * M.d <= 0) return distance_to_line(L.p, M);
		else return distance(L.p, M.p);
	}
	else{
		if(intersect_no_parallel_overlap<1, 0, 1, 0, ll>(L, M).first) return 0;
		else return min(distance_to_ray(L.p, M), distance_to_ray(M.p, L));
	}
}
template<class T> double distance_between_segments(const line<T> &L, const line<T> &M){
	if(intersect_closed_segments(L, M).first) return 0;
	return min({distance_to_segment(L.p, M), distance_to_segment(L.q(), M), distance_to_segment(M.p, L), distance_to_segment(M.q(), L)});
}
template<class P> struct compare_by_angle{
	const P origin;
	compare_by_angle(const P &origin = P()): origin(origin){ }
	bool operator()(const P &p, const P &q) const{ return ori(origin, p, q) > 0; }
};
template<class It, class P> void sort_by_angle(It first, It last, const P &origin){
	first = partition(first, last, [&origin](const decltype(*first) &point){ return point == origin; });
	auto pivot = partition(first, last, [&origin](const decltype(*first) &point) { return point > origin; });
	compare_by_angle<P> cmp(origin);
	sort(first, pivot, cmp), sort(pivot, last, cmp);
}

int main(){
	cin.tie(0)->sync_with_stdio(0);
	int n;
	ll S;
	cin >> n >> S, S <<= 1;
	vector<point<ll>> a(n);
	for(auto &x: a){
		static int i = 0;
		cin >> x;
		x.from = i ++;
	}
	vector<point<ll>> t;
	t.reserve(n * n);
	for(int i = 0; i < n; ++ i){
		for(int j = i + 1; j < n; ++ j){
			t.push_back(a[i] - a[j]);
			t.back().from = j, t.back().to = i;
			t.push_back(a[j] - a[i]);
			t.back().from = i, t.back().to = j;
		}
	}
	sort_by_angle(all(t), point<ll>{0, 0});
	sort(all(a));
	vi pos(n);
	for(int i = 0; i < n; ++ i){
		pos[a[i].from] = i;
	}
	auto kill = [](tuple<point<ll>, point<ll>, point<ll>> x){
	    cout << "Yes\n" << x;
	    exit(0);
	};
	for(auto p: t){
		int i = lower_bound(all(a), point<ll>(), [&](const point<ll> &q, const point<ll> &r){
			return doubled_signed_area(vector<point<ll>>{a[pos[p.from]], a[pos[p.to]], q}) < S;
		}) - a.begin();
		if(i < n && S == doubled_signed_area(vector<point<ll>>{a[pos[p.from]], a[pos[p.to]], a[i]})){
			kill({a[pos[p.from]], a[pos[p.to]], a[i]});
		}
		swap(a[pos[p.from]], a[pos[p.to]]);
		swap(pos[p.from], pos[p.to]);
	}
	cout << "No";
	return 0;
}

/*

*/

////////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//                                   Coded by Aeren                                   //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////////


#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>
#include<ext/rope>
using namespace std;
using namespace __gnu_pbds;
using namespace __gnu_cxx;
template<class L, class R> istream &operator>>(istream &in, pair<L, R> &p){ return in >> p.first >> p.second; }
template<class Tuple, size_t ...Is> void read_tuple(istream &in, Tuple &t, index_sequence<Is...>){ ((in >> get<Is>(t)), ...); }
template<class ...Args> istream &operator>>(istream &in, tuple<Args...> &t){ read_tuple(in, t, index_sequence_for<Args...>{}); return in; }
template<class ...Args, template<class...> class T> istream &operator>>(enable_if_t<!is_same_v<T<Args...>, string>, istream> &in, T<Args...> &arr){ for(auto &x: arr) in >> x; return in; }
//template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << "(" << p.first << ", " << p.second << ")"; }
template<class L, class R> ostream &operator<<(ostream &out, const pair<L, R> &p){ return out << p.first << " " << p.second << "\n"; }
template<class Tuple, size_t ...Is> void print_tuple(ostream &out, const Tuple &t, index_sequence<Is...>){ ((out << (Is ? " " : "") << get<Is>(t)), ...); }
template<class ...Args> ostream &operator<<(ostream &out, const tuple<Args...> &t){ print_tuple(out, t, index_sequence_for<Args...>{}); return out << "\n"; }
template<class ...Args, template<class...> class T> ostream &operator<<(enable_if_t<!is_same_v<T<Args...>, string>, ostream> &out, const T<Args...> &arr){ for(auto &x: arr) out << x << " "; return out << "\n"; }
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
mt19937_64 rngll(chrono::steady_clock::now().time_since_epoch().count());
#define all(a) a.begin(), a.end()
#define sz(a) (int)a.size()
typedef long long ll;
typedef vector<int> vi; typedef vector<ll> vl; typedef vector<double> vd; typedef vector<string> vs;
typedef pair<int, int> pii; typedef pair<ll, ll> pll; typedef pair<int, ll> pil; typedef pair<ll, int> pli;
typedef vector<pii> vpii; typedef vector<pil> vpil; typedef vector<pli> vpli; typedef vector<pll> vpll;
template<class T> T ctmax(T &x, const T &y){ return x = max(x, y); }
template<class T> T ctmin(T &x, const T &y){ return x = min(x, y); }
template<class T> using Tree = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;
typedef tuple<int, int, int> tpl; typedef vector<tpl> vtpl;

template<class T = ll> struct point{
	T x, y;
	int from, to;
	template<class U> point(const point<U> &otr): x(otr.x), y(otr.y){ }
	template<class U, class V> point(const pair<U, V> &p): x(p.first), y(p.second){ }
	template<class U = T, class V = T> point(U x = 0, V y = 0): x(x), y(y){ }
	template<class U> explicit operator point<U>() const{ return point<U>(static_cast<U>(x), static_cast<U>(y)); }
	T operator*(const point &otr) const{ return x * otr.x + y * otr.y; }
	T operator^(const point &otr) const{ return x * otr.y - y * otr.x; }
	point operator+(const point &otr) const{ return point(x + otr.x, y + otr.y); }
	point &operator+=(const point &otr){ return *this = *this + otr; }
	point operator-(const point &otr) const{ return point(x - otr.x, y - otr.y); }
	point &operator-=(const point &otr){ return *this = *this - otr; }
	point operator*(const T &c) const{ return point(x * c, y * c); }
	point &operator*=(const T &c) { return *this = *this * c; }
	point operator/(const T &c) const{ return point(x / c, y / c); }
	point &operator/=(const T &c) { return *this = *this / c; }
	point operator-() const{ return point(-x, -y); }
	bool operator<(const point &otr) const{ return tie(x, y) < tie(otr.x, otr.y); }
	bool operator>(const point &otr) const{ return tie(x, y) > tie(otr.x, otr.y); }
	bool operator<=(const point &otr) const{ return tie(x, y) <= tie(otr.x, otr.y); }
	bool operator>=(const point &otr) const{ return tie(x, y) >= tie(otr.x, otr.y); }
	bool operator==(const point &otr) const{ return tie(x, y) == tie(otr.x, otr.y); }
	bool operator!=(const point &otr) const{ return tie(x, y) != tie(otr.x, otr.y); }
	double norm() const{ return sqrt(x * x + y * y); }
	T sqnorm() const{ return x * x + y * y; }
	double arg() const{ return atan2(y, x); } // [-pi, pi]
	point<double> unit() const{ return point<double>(x, y) / norm(); }
	point perp() const{ return point(-y, x); }
	point<double> normal() const{ return perp().unit(); }
	point<double> rotate(const double &theta) const{ return point<double>(x * cos(theta) - y * sin(theta), x * sin(theta) + y * cos(theta)); }
	point reflect_x() const{ return point(x, -y); }
	point reflect_y() const{ return point(-x, y); }
};
template<class T> point<T> operator*(const T &c, const point<T> &p){ return point<T>(c * p.x, c * p.y); }
template<class T> istream &operator>>(istream &in, point<T> &p){ return in >> p.x >> p.y; }
template<class T> ostream &operator<<(ostream &out, const point<T> &p){ return out << pair<T, T>(p.x, p.y); }
template<class T> double distance(const point<T> &p, const point<T> &q){ return (p - q).norm(); }
template<class T> T squared_distance(const point<T> &p, const point<T> &q){ return (p - q).sqnorm(); }
template<class T, class U, class V> T ori(const point<T> &p, const point<U> &q, const point<V> &r){ return (q - p) ^ (r - p); }
template<class T> T doubled_signed_area(const vector<point<T>> &arr){
	T s = arr.back() ^ arr.front();
	for(int i = 1; i < sz(arr); ++ i) s += arr[i - 1] ^ arr[i];
	return s;
}
template<class T = ll> struct line{
	point<T> p, d; // p + d*t
	template<class U = T, class V = T> line(point<U> p = {0, 0}, point<V> q = {0, 0}, bool Two_Points = true): p(p), d(Two_Points ? q - p : q){ }
	template<class U> line(point<U> d): p(), d(static_cast<point<T>>(d)){ }
	line(T a, T b, T c): p(a ? -c / a : 0, !a && b ? -c / b : 0), d(-b, a){ }
	template<class U> explicit operator line<U>() const{ return line<U>(point<U>(p), point<U>(d), false); }
	point<T> q() const{ return p + d; }
	bool degen() const{ return d == point<T>(); }
	tuple<T, T, T> coef(){ return {d.y, -d.x, d.perp() * p}; } // d.y (X - p.x) - d.x (Y - p.y) = 0
};
template<class T> bool parallel(const line<T> &L, const line<T> &M){ return !(L.d ^ M.d); }
template<class T> bool on_line(const point<T> &p, const line<T> &L){
	if(L.degen()) return p == L.p;
	return (p - L.p) ^ L.d == 0;
}
template<class T> bool on_ray(const point<T> &p, const line<T> &L){
	if(L.degen()) return p == L.p;
	auto a = L.p - p, b = L.q() - p;
	return !(a ^ b) && a * L.d <= 0;
}
template<class T> bool on_segment(const point<T> &p, const line<T> &L){
	if(L.degen()) return p == L.p;
	auto a = L.p - p, b = L.q() - p;
	return !(a ^ b) && a * b <= 0;
}
template<class T> double distance_to_line(const point<T> &p, const line<T> &L){
	if(L.degen()) return distance(p, L.p);
	return abs((p - L.p) ^ L.d) / L.d.norm();
}
template<class T> double distance_to_ray(const point<T> &p, const line<T> &L){
	if((p - L.p) * L.d <= 0) return distance(p, L.p);
	return distance_to_line(p, L);
}
template<class T> double distance_to_segment(const point<T> &p, const line<T> &L){
	if((p - L.p) * L.d <= 0) return distance(p, L.p);
	if((p - L.q()) * L.d >= 0) return distance(p, L.q());
	return distance_to_line(p, L);
}
template<class T> point<double> projection(const point<T> &p, const line<T> &L){ return static_cast<point<double>>(L.p) + (L.degen() ? point<double>() : (p - L.p) * L.d / L.d.norm() * static_cast<point<double>>(L.d)); }
template<class T> point<double> reflection(const point<T> &p, const line<T> &L){ return 2.0 * projection(p, L) - static_cast<point<double>>(p); }
template<class T> point<double> closest_point_on_segment(const point<T> &p, const line<T> &L){ return (p - L.p) * L.d <= 0 ? static_cast<point<double>>(L.p) : ((p - L.q()) * L.d >= 0 ? static_cast<point<double>>(L.q()) : projection(p, L)); }
template<int TYPE> struct EndpointChecker{ };
// For rays
template<> struct EndpointChecker<0>{ template<class T> bool operator()(const T& a, const T& b) const{ return true; } }; // For ray
// For closed end
template<> struct EndpointChecker<1>{ template<class T> bool operator()(const T& a, const T& b) const{ return a <= b; } }; // For closed end
// For open end
template<> struct EndpointChecker<2>{ template<class T> bool operator()(const T& a, const T& b) const{ return a < b; } }; // For open end
// Assumes parallel lines do not intersect
template<int LA, int LB, int RA, int RB, class T> pair<bool, point<double>> intersect_no_parallel_overlap(const line<T> &L, const line<T> &M){
	auto s = L.d ^ M.d;
	if(!s) return {false, point<double>()};
	auto ls = (M.p - L.p) ^ M.d, rs = (M.p - L.p) ^ L.d;
	if(s < 0) s = -s, ls = -ls, rs = -rs;
	bool intersect = EndpointChecker<LA>()(decltype(ls)(0), ls) && EndpointChecker<LB>()(ls, s) && EndpointChecker<RA>()(decltype(rs)(0), rs) && EndpointChecker<RB>()(rs, s);
	return {intersect, static_cast<point<double>>(L.p) + 1.0 * ls / s * static_cast<point<double>>(L.d)};
}
// Assumes parallel lines do not intersect
template<class T> pair<bool, point<double>> intersect_closed_segments_no_parallel_overlap(const line<T> &L, const line<T> &M) {
	return intersect_no_parallel_overlap<1, 1, 1, 1>(L, M);
}
// Assumes nothing
template<class T> pair<bool, line<double>> intersect_closed_segments(const line<T> &L, const line<T> &M){
	auto s = L.d ^ M.d, ls = (M.p - L.p) ^ M.d;
	if(!s){
		if(ls) return {false, line<double>()};
		auto Lp = L.p, Lq = L.q(), Mp = M.p, Mq = M.q();
		if(Lp > Lq) swap(Lp, Lq);
		if(Mp > Mq) swap(Mp, Mq);
		line<double> res(max(Lp, Mp), min(Lq, Mq));
		return {res.d >= point<double>(), res};
	}
	auto rs = (M.p - L.p) ^ L.d;
	if(s < 0) s = -s, ls = -ls, rs = -rs;
	bool intersect = 0 <= ls && ls <= s && 0 <= rs && rs <= s;
	return {intersect, line<double>(static_cast<point<double>>(L.p) + 1.0 * ls / s * static_cast<point<double>>(L.d), point<double>())};
}
template<class T> double distance_between_rays(const line<T> &L, const line<T> &M){
	if(parallel(L, M)){
		if(L.d * M.d >= 0 || (M.p - L.p) * M.d <= 0) return distance_to_line(L.p, M);
		else return distance(L.p, M.p);
	}
	else{
		if(intersect_no_parallel_overlap<1, 0, 1, 0, ll>(L, M).first) return 0;
		else return min(distance_to_ray(L.p, M), distance_to_ray(M.p, L));
	}
}
template<class T> double distance_between_segments(const line<T> &L, const line<T> &M){
	if(intersect_closed_segments(L, M).first) return 0;
	return min({distance_to_segment(L.p, M), distance_to_segment(L.q(), M), distance_to_segment(M.p, L), distance_to_segment(M.q(), L)});
}
template<class P> struct compare_by_angle{
	const P origin;
	compare_by_angle(const P &origin = P()): origin(origin){ }
	bool operator()(const P &p, const P &q) const{ return ori(origin, p, q) > 0; }
};
template<class It, class P> void sort_by_angle(It first, It last, const P &origin){
	first = partition(first, last, [&origin](const decltype(*first) &point){ return point == origin; });
	auto pivot = partition(first, last, [&origin](const decltype(*first) &point) { return point > origin; });
	compare_by_angle<P> cmp(origin);
	sort(first, pivot, cmp), sort(pivot, last, cmp);
}

int main(){
	cin.tie(0)->sync_with_stdio(0);
	int n;
	ll S;
	cin >> n >> S, S <<= 1;
	vector<point<ll>> a(n);
	for(auto &x: a){
		static int i = 0;
		cin >> x;
		x.from = i ++;
	}
	vector<point<ll>> t;
	t.reserve(n * n);
	for(int i = 0; i < n; ++ i){
		for(int j = i + 1; j < n; ++ j){
			t.push_back(a[i] - a[j]);
			t.back().from = j, t.back().to = i;
			t.push_back(a[j] - a[i]);
			t.back().from = i, t.back().to = j;
		}
	}
	sort_by_angle(all(t), point<ll>{0, 0});
	sort(all(a));
	vi pos(n);
	for(int i = 0; i < n; ++ i){
		pos[a[i].from] = i;
	}
	auto kill = [](tuple<point<ll>, point<ll>, point<ll>> x){
	    cout << "Yes\n" << x;
	    exit(0);
	};
	for(auto p: t){
		int i = lower_bound(all(a), point<ll>(), [&](const point<ll> &q, const point<ll> &r){
			return ori(a[pos[p.from]], a[pos[p.to]], q) < S;
		}) - a.begin();
		if(i < n && S == ori(a[pos[p.from]], a[pos[p.to]], a[i])){
			kill({a[pos[p.from]], a[pos[p.to]], a[i]});
		}
		if(p.x || p.y > 0){
			swap(a[pos[p.from]], a[pos[p.to]]);
			swap(pos[p.from], pos[p.to]);
		}
	}
	cout << "No";
	return 0;
}

/*

*/

////////////////////////////////////////////////////////////////////////////////////////
//                                                                                //
//                                   Coded by Aeren                                   //
//                                                                                //
////////////////////////////////////////////////////////////////////////////////////////


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef double db;
typedef std::string str;
#define sei set<int>
#define sell set<ll>
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define vld vector<ld>
#define vstr vector<str>
#define vpii vector<pii>
#define vpll vector<pll>
#define all(v) v.begin(),v.end()
#define foa(i,v) for(auto i : v)
#define fo(i,a,b) for(int i=a;i<b;i++)
#define fo_(i,a,b) for(int i=a;i>b;i--)
#define M(a) memset(a,0,sizeof a)
#define M_(a) memset(a ,-1,sizeof a)
#define deb(x)  cerr << #x << " = " << x << endl
#define pb push_back
#define pob pop_back
#define F first
#define S second
#define OK order_of_key
#define FO find_by_order
#define nmax 1000100
const ld PI = 3.141592653589793238462643383279;
const ll inf = std::numeric_limits<ll>::max();
const int infint = std::numeric_limits<int>::max();
const ll mod = 1e9+7;
using namespace __gnu_pbds;
using namespace std;
#pragma GCC optimize("Ofast")
#pragma GCC optimize("O3")
#pragma GCC target("arch=corei7-avx")
#pragma GCC target("avx,avx2,fma")
#pragma GCC optimization ("unroll-loops")
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

int n;
vi g[2][nmax];
bool picked[nmax];
int del[nmax];

int cur = 0;
void go(){
	while (cur < n && del[cur]) cur++;
	if (cur == n) return;

	int v = cur++;
	del[v]++;
	picked[v] = true;

	for (int u:g[0][v])
		del[u]++;

	go();
	bool mark = 0;
	for (int u:g[1][v])
		if (picked[u])
			mark = true;
	if (mark)
		picked[v] = false;
}

int main(){
	ios::sync_with_stdio(false);
	cin.tie(0);
	int m;
	cin >> n >> m;
	while (m--){
		int a, b; cin >> a >> b, a--, b--;
		g[0][a].pb(b);
		g[1][b].pb(a);
	}
	go();

	int c = 0;
	fo(i,0,n)
		if (picked[i]) c++;
	cout << c << "\n";
	fo(i,0,n)
		if(picked[i])
			cout << i+1 << " ";
	cout << "\n";
	return 0;
}


#pragma GCC optimize("O3")
#pragma GCC target("arch=corei7-avx")
//#pragma GCC target("arch=native,tune=native")
#include <bits/stdc++.h>
#ifndef ONLINE_JUDGE
# include <sys/time.h>
# include <sys/resource.h>
#endif
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef double db;
typedef std::string str;
#define sei set<int>
#define sell set<ll>
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define vld vector<ld>
#define vstr vector<str>
#define vpii vector<pii>
#define vpll vector<pll>
#define all(v) v.begin(),v.end()
#define foa(i,v) for(auto i : v)
#define fo(i,a,b) for(int i=a;i<b;i++)
#define fo_(i,a,b) for(int i=a;i>b;i--)
#define M(a) memset(a,0,sizeof a)
#define M_(a) memset(a ,-1,sizeof a)
#define deb(x)  cerr << #x << " = " << x << endl
#define pb push_back
#define pob pop_back
#define F first
#define S second
#define OK order_of_key
#define FO find_by_order
#define nmax 2010
const ld PI = 3.141592653589793238462643383279;
const ll inf = std::numeric_limits<ll>::max();
const int infint = std::numeric_limits<int>::max();
const ll mod = 1e9+7;
using namespace __gnu_pbds;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

//making code fast
template<class T>
void splitstr(const string &s, vector<T> &out)
{
    istringstream in(s);
    out.clear();
    copy(istream_iterator<T>(in), istream_iterator<T>(), back_inserter(out));
}

template<class T> T gcd(T a, T b) { return b ? gcd(b, a % b) : a; }

static void redirect(int argc, const char **argv)
{
#ifndef ONLINE_JUDGE
    struct rlimit rlim;
    getrlimit(RLIMIT_STACK, &rlim);
    rlim.rlim_cur = 256 * 1024 * 1024;
    setrlimit(RLIMIT_STACK, &rlim);
#ifndef __SANITIZE_ADDRESS__
    getrlimit(RLIMIT_DATA, &rlim);
    rlim.rlim_cur = 256 * 1024 * 1024;
    setrlimit(RLIMIT_DATA, &rlim);
#endif
#endif

    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    if (argc > 1)
    {
        static filebuf f;
        f.open(argv[1], ios::in);
        cin.rdbuf(&f);
        if (!cin)
        {
            cerr << "Failed to open '" << argv[1] << "'" << endl;
            exit(1);
        }
    }

    if (argc > 2)
    {
        static filebuf f;
        f.open(argv[2], ios::out | ios::trunc);
        cout.rdbuf(&f);
        if (!cout)
        {
            cerr << "Failed to open '" << argv[2] << "'" << endl;
        }
    }
}
// make fast

ll cross(const pii &a, const pii &b)
{
    return ll(a.first) * b.second - ll(a.second) * b.first;
}

void dump(const pii &a)
{
    cout << a.first << ' ' << a.second << '\n';
}

pii coords[nmax];
ll areas[nmax][nmax];

int main(int argc, const char **argv)
{
    redirect(argc, argv);
    int N;
    ll S;
    cin >> N >> S;
    S *= 2;
    for (int i = 0; i < N; i++)
    {
        int x, y;
        cin >> x >> y;
        coords[i] = pii(x, y);
    }

    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            areas[i][j] = cross(coords[i], coords[j]);

    for (int i = 0; i < N; i++)
        for (int j = i + 1; j < N; j++)
        {
            ll trg1 = S - areas[i][j];
            ll trg2 = -S - areas[i][j];
            for (int k = j + 1; k < N; k++)
            {
                ll sum = areas[j][k] - areas[i][k];
                if (sum == trg1 || sum == trg2)
                {
                    cout << "Yes\n";
                    dump(coords[i]);
                    dump(coords[j]);
                    dump(coords[k]);
                    return 0;
                }
            }
        }

    cout << "No\n";
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef double db;
typedef std::string str;
#define sei set<int>
#define sell set<ll>
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define vld vector<ld>
#define vstr vector<str>
#define vpii vector<pii>
#define vpll vector<pll>
#define all(v) v.begin(),v.end()
#define foa(i,v) for(auto i : v)
#define fo(i,a,b) for(int i=a;i<b;i++)
#define fo_(i,a,b) for(int i=a;i>b;i--)
#define M(a) memset(a,0,sizeof a)
#define M_(a) memset(a ,-1,sizeof a)
#define deb(x)  cerr << #x << " = " << x << endl
#define pb push_back
#define pob pop_back
#define F first
#define S second
#define OK order_of_key
#define FO find_by_order
#define nmax 1000100
const ld PI = 3.141592653589793238462643383279;
const ll inf = std::numeric_limits<ll>::max();
const int infint = std::numeric_limits<int>::max();
const ll mod = 1e9+7;
using namespace __gnu_pbds;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

void fastscan(int &number)
{
    //variable to indicate sign of input number
    register int c;

    number = 0;

    // extract current character from buffer
    c = getchar();

    // Keep on extracting characters if they are integers
    // i.e ASCII Value lies from '0'(48) to '9' (57)
    for (; (c>47 && c<58); c=getchar())
        number = number *10 + c - 48;
}
void fastscan(ll &number)
{
    //variable to indicate sign of input number
    register int c;

    number = 0;

    // extract current character from buffer
    c = getchar();

    // Keep on extracting characters if they are integers
    // i.e ASCII Value lies from '0'(48) to '9' (57)
    for (; (c>47 && c<58); c=getchar())
        number = number *10 + c - 48;
}

ll cross(const pii &a, const pii &b)
{
    return ll(a.first) * b.second - ll(a.second) * b.first;
}

void dump(const pii &a)
{
    cout << a.first << ' ' << a.second << '\n';
}

int main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int N;
    ll S;
    fastscan(N);
    fastscan(S);
    S *= 2;
    vector<pii> coords(N);
    for (int i = 0; i < N; i++)
    {
        int x, y;
        fastscan(x),fastscan(y);
        coords[i] = pii(x, y);
    }

    vector<vector<ll>> areas(N, vll(N));
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            areas[i][j] = cross(coords[i], coords[j]);

    for (int i = 0; i < N; i++)
        for (int j = i + 1; j < N; j++)
        {
            ll trg1 = S - areas[i][j];
            ll trg2 = -S - areas[i][j];
            for (int k = j + 1; k < N; k++)
            {
                ll sum = areas[j][k] - areas[i][k];
                if (sum == trg1 || sum == trg2)
                {
                    cout << "Yes\n";
                    dump(coords[i]);
                    dump(coords[j]);
                    dump(coords[k]);
                    return 0;
                }
            }
        }

    cout << "No\n";
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef double db;
typedef std::string str;
#define sei set<int>
#define sell set<ll>
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define vld vector<ld>
#define vstr vector<str>
#define vpii vector<pii>
#define vpll vector<pll>
#define all(v) v.begin(),v.end()
#define foa(i,v) for(auto i : v)
#define fo(i,a,b) for(int i=a;i<b;i++)
#define fo_(i,a,b) for(int i=a;i>b;i--)
#define M(a) memset(a,0,sizeof a)
#define M_(a) memset(a ,-1,sizeof a)
#define deb(x)  cerr << #x << " = " << x << endl
#define pb push_back
#define pob pop_back
#define F first
#define S second
#define OK order_of_key
#define FO find_by_order
#define nmax 1000100
const ld PI = 3.141592653589793238462643383279;
const ll inf = std::numeric_limits<ll>::max();
const int infint = std::numeric_limits<int>::max();
const ll mod = 1e9+7;
using namespace __gnu_pbds;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

ll cross(const pii &a, const pii &b)
{
    return ll(a.first) * b.second - ll(a.second) * b.first;
}

void dump(const pii &a)
{
    cout << a.first << ' ' << a.second << '\n';
}

int main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int N;
    ll S;
    cin >> N >> S;
    S *= 2;
    vector<pii> coords(N);
    for (int i = 0; i < N; i++)
    {
        int x, y;
        cin >> x >> y;
        coords[i] = pii(x, y);
    }

    vector<vector<ll>> areas(N, vll(N));
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            areas[i][j] = cross(coords[i], coords[j]);

    for (int i = 0; i < N; i++)
        for (int j = i + 1; j < N; j++)
        {
            ll trg1 = S - areas[i][j];
            ll trg2 = -S - areas[i][j];
            for (int k = j + 1; k < N; k++)
            {
                ll sum = areas[j][k] - areas[i][k];
                if (sum == trg1 || sum == trg2)
                {
                    cout << "Yes\n";
                    dump(coords[i]);
                    dump(coords[j]);
                    dump(coords[k]);
                    return 0;
                }
            }
        }

    cout << "No\n";
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef double db;
typedef std::string str;
#define sei set<int>
#define sell set<ll>
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define vld vector<ld>
#define vstr vector<str>
#define vpii vector<pii>
#define vpll vector<pll>
#define all(v) v.begin(),v.end()
#define foa(i,v) for(auto i : v)
#define fo(i,a,b) for(int i=a;i<b;i++)
#define fo_(i,a,b) for(int i=a;i>b;i--)
#define M(a) memset(a,0,sizeof a)
#define M_(a) memset(a ,-1,sizeof a)
#define deb(x)  cerr << #x << " = " << x << endl
#define pb push_back
#define pob pop_back
#define F first
#define S second
#define OK order_of_key
#define FO find_by_order
#define nmax 1000100
const ld PI = 3.141592653589793238462643383279;
const ll inf = std::numeric_limits<ll>::max();
const int infint = std::numeric_limits<int>::max();
const ll mod = 1e9+7;
using namespace __gnu_pbds;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

ll cross(const pii &a, const pii &b)
{
    return ll(a.first) * b.second - ll(a.second) * b.first;
}

void dump(const pii &a)
{
    cout << a.first << ' ' << a.second << '\n';
}

int main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int N;
    ll S;
    scanf("%d%ull",&N,&S);
    S *= 2;
    vector<pii> coords(N);
    for (int i = 0; i < N; i++)
    {
        int x, y;
        scanf("%d%d",&x,&y);
        coords[i] = pii(x, y);
    }

    vector<vector<ll>> areas(N, vll(N));
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            areas[i][j] = cross(coords[i], coords[j]);

    for (int i = 0; i < N; i++)
        for (int j = i + 1; j < N; j++)
        {
            ll trg1 = S - areas[i][j];
            ll trg2 = -S - areas[i][j];
            for (int k = j + 1; k < N; k++)
            {
                ll sum = areas[j][k] - areas[i][k];
                if (sum == trg1 || sum == trg2)
                {
                    cout << "Yes\n";
                    dump(coords[i]);
                    dump(coords[j]);
                    dump(coords[k]);
                    return 0;
                }
            }
        }

    cout << "No\n";
    return 0;
}


#include <bits/stdc++.h>
#include <ext/pb_ds/assoc_container.hpp>
#include <ext/pb_ds/tree_policy.hpp>
typedef long long ll;
typedef unsigned long long ull;
typedef long double ld;
typedef double db;
typedef std::string str;
#define sei set<int>
#define sell set<ll>
#define pii pair<int,int>
#define pll pair<ll,ll>
#define vi vector<int>
#define vll vector<ll>
#define vvi vector<vi>
#define vvll vector<vll>
#define vld vector<ld>
#define vstr vector<str>
#define vpii vector<pii>
#define vpll vector<pll>
#define all(v) v.begin(),v.end()
#define foa(i,v) for(auto i : v)
#define fo(i,a,b) for(int i=a;i<b;i++)
#define fo_(i,a,b) for(int i=a;i>b;i--)
#define M(a) memset(a,0,sizeof a)
#define M_(a) memset(a ,-1,sizeof a)
#define deb(x)  cerr << #x << " = " << x << endl
#define pb push_back
#define pob pop_back
#define F first
#define S second
#define OK order_of_key
#define FO find_by_order
#define nmax 1000100
const ld PI = 3.141592653589793238462643383279;
const ll inf = std::numeric_limits<ll>::max();
const int infint = std::numeric_limits<int>::max();
const ll mod = 1e9+7;
using namespace __gnu_pbds;
using namespace std;
mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
template <typename T>
using ordered_set = tree<T, null_type, less<T>, rb_tree_tag, tree_order_statistics_node_update>;

ll cross(const pii &a, const pii &b)
{
    return ll(a.first) * b.second - ll(a.second) * b.first;
}

void dump(const pii &a)
{
    cout << a.first << ' ' << a.second << '\n';
}

int main(){
    ios::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    int N;
    ll S;
    scanf("%d%d",&N,&S);
    S *= 2;
    vector<pii> coords(N);
    for (int i = 0; i < N; i++)
    {
        int x, y;
        scanf("%d%d",&x,&y);
        coords[i] = pii(x, y);
    }

    vector<vector<ll>> areas(N, vll(N));
    for (int i = 0; i < N; i++)
        for (int j = 0; j < N; j++)
            areas[i][j] = cross(coords[i], coords[j]);

    for (int i = 0; i < N; i++)
        for (int j = i + 1; j < N; j++)
        {
            ll trg1 = S - areas[i][j];
            ll trg2 = -S - areas[i][j];
            for (int k = j + 1; k < N; k++)
            {
                ll sum = areas[j][k] - areas[i][k];
                if (sum == trg1 || sum == trg2)
                {
                    cout << "Yes\n";
                    dump(coords[i]);
                    dump(coords[j]);
                    dump(coords[k]);
                    return 0;
                }
            }
        }

    cout << "No\n";
    return 0;
}


#include<stdio.h>
#include<string.h>
int s[100][1000];
int num[100];
int flag=1;
int n,k;
int a[100000];
int b[100000];
int main()
{
	scanf("%d %d",&n,&k);
	k--;
	int d;
	memset(s,0,sizeof(s));
	memset(num,0,sizeof(num));
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&d);
		s[d][num[d]++]=i;
	}
	if(num[0]!=1)
	{
		flag=0;
		printf("-1\n");
		return 0;
	}
	int tot=0;
	while(num[tot]!=0)tot++;
	for(int i=0;i<tot-1;i++)
	{
		if(num[i]*k<num[i+1])flag=0;
	}
	int ge=0;
	for(int i=1;i<tot;i++)
	{
		for(int j=0;j<num[i];j++)
		{
			ge++;
			a[ge]=s[i][j];
			b[ge]=s[i-1][j/k];
		}
	}
	if(flag==0)printf("-1");
	else
	{
	printf("%d\n",ge);
		for(int j=1;j<=ge;j++)
		{
			printf("%d %d\n",b[j],a[j]);
		}
    }
	return 0;
}


#include<stdio.h>
#include<string.h>
int s[1000][1000];
int num[10000];
int flag=1;
int n,k;
int a[1000000];
int b[1000000];
int main()
{
	scanf("%d %d",&n,&k);
	int d;
	memset(s,0,sizeof(s));
	memset(num,0,sizeof(num));
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&d);
		s[d][num[d]++]=i;
	}
	if(num[0]!=1)
	{
		flag=0;
		printf("-1\n");
		return 0;
	}
	int tot=0;
	while(num[tot]!=0)tot++;
	for(int i=1;i<tot-1;i++)
	{
		if(num[i]*k<num[i+1])flag=0;
	}
	int ge=0;
	for(int i=1;i<tot;i++)
	{
		for(int j=0;j<num[i];j++)
		{
			ge++;
			a[ge]=s[i][j];
			b[ge]=s[i-1][j/k];
		}
		if (i==1)k--;
	}
	if(flag==0)printf("-1");
	else
	{
	printf("%d\n",ge);
		for(int j=1;j<=ge;j++)
		{
			printf("%d %d\n",b[j],a[j]);
		}
    }
	return 0;
}


#include<stdio.h>
#include<string.h>
int s[100][100000];
int num[10000];
int flag=1;
int n,k;
int a[100000];
int b[100000];
int main()
{
	scanf("%d %d",&n,&k);
	int d;
	memset(s,0,sizeof(s));
	memset(num,0,sizeof(num));
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&d);
		s[d][num[d]++]=i;
	}
	if(num[0]!=1)
	{
		flag=0;
		printf("-1\n");
		return 0;
	}
	int tot=0;
	while(num[tot]!=0)tot++;
	for(int i=1;i<tot-1;i++)
	{
		if(num[i]*k<num[i+1])flag=0;
	}
	int ge=0;
	for(int i=1;i<tot;i++)
	{
		for(int j=0;j<num[i];j++)
		{
			ge++;
			a[ge]=s[i][j];
			b[ge]=s[i-1][j/k];
		}
		if (i==1)k--;
	}
	if(flag==0)printf("-1");
	else
	{
	printf("%d\n",ge);
		for(int j=1;j<=ge;j++)
		{
			printf("%d %d\n",b[j],a[j]);
		}
    }
	return 0;
}


#include<stdio.h>
#include<string.h>
int s[100][100000];
int num[10000];
int flag=1;
int n,k;
int a[100000];
int b[100000];
int main()
{
	scanf("%d %d",&n,&k);
	int d;
	memset(s,0,sizeof(s));
	memset(num,0,sizeof(num));
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&d);
		s[d][num[d]++]=i;
	}
	if(num[0]!=1)
	{
		flag=0;
		printf("-1\n");
		return 0;
	}
	int tot=0;
	while(num[tot]!=0)tot++;
	for(int i=1;i<tot-1;i++)
	{
		if(num[i]*k<num[i+1])flag=0;
	}
	int ge=0;
	for(int i=1;i<tot;i++)
	{
		for(int j=0;j<num[i];j++)
		{

			ge++;
			a[ge]=s[i][j];
			b[ge]=s[i-1][j/k];
		}
		if (i==1)k--;
		{
			if (k==0)
			{
				flag=0;
				break;
			}
		}
	}
	if(flag==0)printf("-1");
	else
	{
	printf("%d\n",ge);
		for(int j=1;j<=ge;j++)
		{
			printf("%d %d\n",b[j],a[j]);
		}
    }
	return 0;
}


#include<stdio.h>
#include<string.h>
int s[100][1000];
int num[100];
int flag=1;
int n,k;
int a[100000];
int b[100000];
int main()
{
	scanf("%d %d",&n,&k);
	int d;
	memset(s,0,sizeof(s));
	memset(num,0,sizeof(num));
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&d);
		s[d][num[d]++]=i;
	}
	if(num[0]!=1)
	{
		flag=0;
		printf("-1\n");
		return 0;
	}
	int tot=0;
	while(num[tot]!=0)tot++;
	for(int i=0;i<tot-1;i++)
	{
		if(num[i]*k<num[i+1])flag=0;
	}
	int ge=0;
	for(int i=1;i<tot;i++)
	{
		for(int j=0;j<num[i];j++)
		{
			ge++;
			a[ge]=s[i][j];
			b[ge]=s[i-1][j/k];
		}
	}
	if(flag==0)printf("-1");
	else
	{
	printf("%d\n",ge);
		for(int j=1;j<=ge;j++)
		{
			printf("%d %d\n",b[j],a[j]);
		}
    }
	return 0;
}


#pragma comment(linker, "/STACK:102400000,102400000")
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <string>
#include <time.h>
#include <math.h>
#include <queue>
#include <stack>
#include <set>
#include <map>
using namespace std;
#define INF 0x3f3f3f3f
#define eps 1e-8
#define pi acos(-1.0)
typedef long long ll;
const int maxn=1008100;
vector<int> a[1000005];
vector<pair<int, int> > b;
int main()
{
     //freopen("data.in","r",stdin);
     //freopen("data.out","w",stdout);
     ll n,m,k;
     cin>>n>>k;
         for(int i=0;i<=n;i++)a[i].clear();
         b.clear();
      for(int i=0; i < n; ++i){
        int d;
        scanf("%d", &d);
        a[d].push_back(i);
      }
    if(a[0].size() != 1){
        printf("-1\n");
        return 0;
    }
         int flag=0;
         for(int i=1; i < n; ++i){
             if(a[i].size() > a[i-1].size()*k){
                flag=1;break;
             }
             for(int j=0; j < a[i].size(); ++j)
                 b.push_back(make_pair(a[i][j], a[i-1][j/k]));
               if(i == 1)--k;
         }
         if(flag)puts("-1");
         else{
             cout<<b.size()<<endl;
             for(int i=0;i<b.size();i++)
             	printf("%d %d\n",b[i].first+1,b[i].second+1);
         }
     return 0;
}


#include<stdio.h>
#include<string.h>
int s[100][1000];
int num[100];
int flag=1;
int n,k;
int main()
{
	scanf("%d %d",&n,&k);
	int d;
	memset(s,0,sizeof(s));
	memset(num,0,sizeof(num));
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&d);
		s[d][num[d]++]=i;
	}
	if(num[0]!=1)
	{
		flag=0;
		printf("-1\n");
		return 0;
	}
	int tot=0;
	while(num[tot]!=0)tot++;
	for(int i=0;i<tot-1;i++)
	{
		if(num[i]*k<num[i+1])flag=0;
	}
	for(int i=1;i<tot;i++)
	{
		for(int j=0;j<num[i];j++)
		{
			printf("%d %d\n",s[i][j],s[i-1][j/k]);
		}
	}
	if(flag==0)printf("-1");
	return 0;
}


#include<stdio.h>
#include<string.h>
const int maxn=100000;
int map[maxn][maxn];
int s[100][1000];
int num[100];
int flag=1;
int n,k;
int main()
{
	scanf("%d %d",&n,&k);
	int d;
	memset(s,0,sizeof(s));
	memset(num,0,sizeof(num));
	memset(map,0,sizeof(map));
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&d);
		s[d][num[d]++]=i;
	}
	if(num[0]!=1)
	{
		flag=0;
		printf("-1\n");
		return 0;
	}
	int tot=0;
	while(num[tot]!=0)tot++;
	for(int i=0;i<tot-1;i++)
	{
		if(num[i]*k<num[i+1])flag=0;
		printf("%d ",num[i]);
	}
	printf("\n");
	for(int i=1;i<tot;i++)
	{
		for(int j=0;j<num[i];j++)
		{
			map[s[i][j]][s[i-1][j/k]]=1;map[s[i-1][j/k]][s[i][j]]=1;
		}
	}
	if(flag==0)printf("-1\n");
	else
	for(int i=1;i<=n;i++)
	{
		for(int j=i+1;j<=n;j++)
		{
			if(map[i][j])printf("%d %d\n",i,j);
		}
	}
	return 0;
}


#pragma comment(linker, "/STACK:102400000,102400000")
#include <stdio.h>
#include <iostream>
#include <algorithm>
#include <sstream>
#include <stdlib.h>
#include <string.h>
#include <limits.h>
#include <string>
#include <time.h>
#include <math.h>
#include <queue>
#include <stack>
#include <set>
#include <map>
using namespace std;
#define INF 0x3f3f3f3f
#define eps 1e-8
#define pi acos(-1.0)
typedef long long ll;
const int maxn=1008100;
vector<int> a[1000005];
vector<pair<int, int> > b;
int main()
{
     //freopen("data.in","r",stdin);
     //freopen("data.out","w",stdout);
     ll n,m,k;
     cin>>n>>k;
         for(int i=0;i<=n;i++)a[i].clear();
         b.clear();
      for(int i=0; i < n; ++i){
        int d;
        scanf("%d", &d);
        a[d].push_back(i);
      }
    if(a[0].size() != 1){
        printf("-1\n");
        return 0;
    }
         int flag=0;
         for(int i=1; i < n; ++i){
             if(a[i].size() > a[i-1].size()*k){
                flag=1;break;
             }
             for(int j=0; j < a[i].size(); ++j)
                 b.push_back(make_pair(a[i][j], a[i-1][j/k]));
               if(i == 1)--k;
         }
         if(flag)puts("-1");
         else{
             cout<<b.size()<<endl;
             for(int i=0;i<b.size();i++)
                 cout<<b[i].first+1<<" "<<b[i].second+1<<endl;
         }
     return 0;
}


#include<stdio.h>
#include<string.h>
int s[100][1000];
int num[100];
int flag=1;
int n,k;
int a[100000];
int b[100000];
int main()
{
	scanf("%d %d",&n,&k);
	int d;
	memset(s,0,sizeof(s));
	memset(num,0,sizeof(num));
	for(int i=1;i<=n;i++)
	{
		scanf("%d",&d);
		s[d][num[d]++]=i;
	}
	if(num[0]!=1)
	{
		flag=0;
		printf("-1\n");
		return 0;
	}
	int tot=0;
	while(num[tot]!=0)tot++;
	for(int i=1;i<tot-1;i++)
	{
		if(num[i]*k<num[i+1])flag=0;
	}
	int ge=0;
	for(int i=1;i<tot;i++)
	{
		for(int j=0;j<num[i];j++)
		{
			ge++;
			a[ge]=s[i][j];
			b[ge]=s[i-1][j/k];
		}
		if (i==1)k--;
	}
	if(flag==0)printf("-1");
	else
	{
	printf("%d\n",ge);
		for(int j=1;j<=ge;j++)
		{
			printf("%d %d\n",b[j],a[j]);
		}
    }
	return 0;
}