#include <cstdio>

 #include <cstring>

 #include <iostream>

 #include <algorithm>

 #include <vector>

 #include <cmath>

 using namespace std;

 struct Point {

     double x, y;

     Point() {}

     Point(double x, double y) : x(x), y(y) {}

 } ;

 template<class T> T sqr(T x) { return x * x;}

 typedef Point Vec;

 Vec operator + (Vec a, Vec b) { return Vec(a.x + b.x, a.y + b.y);}

 Vec operator - (Vec a, Vec b) { return Vec(a.x - b.x, a.y - b.y);}

 Vec operator * (Vec a, double p) { return Vec(a.x * p, a.y * p);}

 Vec operator / (Vec a, double p) { return Vec(a.x / p, a.y / p);}

 const double EPS = 1e-;

 const double PI = acos(-1.0);

 inline int sgn(double x) { return (x > EPS) - (x < -EPS);}

 bool operator < (Point a, Point b) { return sgn(a.x - b.x) <  || sgn(a.x - b.x) ==  && a.y < b.y;}

 bool operator == (Point a, Point b) { return sgn(a.x - b.x) ==  || sgn(a.y - b.y) == ;}

 inline double dotDet(Vec a, Vec b) { return a.x * b.x + a.y * b.y;}

 inline double crossDet(Vec a, Vec b) { return a.x * b.y - a.y * b.x;}

 inline double dotDet(Point o, Point a, Point b) { return dotDet(a - o, b - o);}

 inline double crossDet(Point o, Point a, Point b) { return crossDet(a - o, b - o);}

 inline double vecLen(Vec x) { return sqrt(dotDet(x, x));}

 inline double toRad(double deg) { return deg/ 180.0 * PI;}

 inline double angle(Vec v) { return atan2(v.y, v.x);}

 Vec normal(Vec x) {

     double len = vecLen(x);

     return Vec(-x.y, x.x) / len;

 }

 struct Poly {

     vector<Point> pt;

     Poly() { pt.clear();}

     ~Poly() {}

     Poly(vector<Point> &pt) : pt(pt) {}

     Point operator [] (int x) const { return pt[x];}

     int size() { return pt.size();}

     double area() {

         double ret = 0.0;

         int sz = pt.size();

         for (int i = ; i < sz; i++) {

             ret += crossDet(pt[i], pt[i - ]);

         }

         return fabs(ret / 2.0);

     }

 } ;

 struct DLine {

     Point p;

     Vec v;

     double ang;

     DLine() {}

     DLine(Point p, Vec v) : p(p), v(v) { ang = atan2(v.y, v.x);}

     bool operator < (const DLine &L) const { return ang < L.ang;}

     DLine move(double x) {

         Vec nor = normal(v);

         nor = nor * x;

         return DLine(p + nor, v);

     }

 } ;

 inline bool onLeft(DLine L, Point p) { return crossDet(L.v, p - L.p) > ;}

 Point dLineIntersect(DLine a, DLine b) {

     Vec u = a.p - b.p;

     double t = crossDet(b.v, u) / crossDet(a.v, b.v);

     return a.p + a.v * t;

 }

 Poly halfPlane(DLine *L, int n) {

     Poly ret = Poly();

     sort(L, L + n);

     int fi, la;

     Point *p = new Point[n];

     DLine *q = new DLine[n];

     q[fi = la = ] = L[];

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

         while (fi < la && !onLeft(L[i], p[la - ])) la--;

         while (fi < la && !onLeft(L[i], p[fi])) fi++;

         q[++la] = L[i];

         if (fabs(crossDet(q[la].v, q[la - ].v)) < EPS) {

             la--;

             if (onLeft(q[la], L[i].p)) q[la] = L[i];

         }

         if (fi < la) p[la - ] = dLineIntersect(q[la - ], q[la]);

     }

     while (fi < la && !onLeft(q[fi], p[la - ])) la--;

     if (la < fi) return ret;

     p[la] = dLineIntersect(q[la], q[fi]);

     for (int i = fi; i <= la; i++) ret.pt.push_back(p[i]);

     return ret;

 }

 const int N = ;

 Point pt[N];

 DLine dl[N];

 int main() {

 //    freopen("in", "r", stdin);

     int n;

     double r;

     while (cin >> n >> r) {

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

             cin >> pt[i].x >> pt[i].y;

             if (i) dl[i - ] = DLine(pt[i], pt[i - ] - pt[i]).move(r + EPS);

         }

         dl[n - ] = DLine(pt[], pt[n - ] - pt[]).move(r + EPS);

         Poly tmp = halfPlane(dl, n);

         if (tmp.size() <= ) {

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

                 if (i) dl[i - ] = DLine(pt[i], pt[i - ] - pt[i]).move(r - EPS);

             }

             dl[n - ] = DLine(pt[], pt[n - ] - pt[]).move(r - EPS);

             tmp = halfPlane(dl, n);

         }

         double dis = 0.0;

         int id[] = { , };

         n = tmp.size();

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

             for (int j = ; j < n; j++) {

                 if (dis < vecLen(tmp[i] - tmp[j])) {

                     dis = vecLen(tmp[i] - tmp[j]);

                     id[] = i;

                     id[] = j;

                 }

             }

         }

 //        cout << vecLen(tmp[id[0]] - tmp[id[1]]) << endl;

         cout.precision();

         cout << tmp[id[]].x << ' ' << tmp[id[]].y << ' ' << tmp[id[]].x << ' ' << tmp[id[]].y << endl;

     }

     return ;

 }