import java.io.File;
import java.io.PrintWriter;
import java.util.*;

public class easy_gk_wa_elongated {
    private static final double EPS = 1e-10;
    static Scanner in;
    static PrintWriter out;

    int[] compress(List<Segment> xs) {
        NavigableSet<Integer> set = new TreeSet<>();
        for (Segment x : xs) {
            set.add((int) x.minx);
            set.add((int) x.maxx);
        }
        int[] result = new int[set.size()];
        int i = 0;
        for (int x : set) {
            result[i++] = x;
        }
        return result;
    }

    class Segment {
        final double minx, maxx, miny, maxy;
        final double a, b;

        Segment(double x1, double y1, double x2, double y2) {
            if (x1 < x2) {
                minx = x1;
                miny = y1;
                maxx = x2;
                maxy = y2;
            } else {
                minx = x2;
                miny = y2;
                maxx = x1;
                maxy = y1;
            }
            a = (maxy - miny) * 1.0 / (maxx - minx);
            b = -minx * a + miny;
        }

        double y(double x) {
            return a * x + b;
        }

        public double x(double y) {
            return (y - b) / a;
        }

        public Segment horz(double y) {
            return new Segment(minx, y, maxx, y);
        }

        @Override
        public String toString() {
            return "(" + minx + " " + miny + " " + maxx + " " + maxy + ", " + a + " " + b + ")";
        }

        public Segment rotate() {
            return new Segment(-miny, minx, -maxy, maxx);
        }

        public boolean isHorz() {
            return miny == maxy;
        }

        public Segment cut(int x1, int x2) {
            return new Segment(x1, y(x1), x2, y(x2));
        }
    }

    Result bestResult = new Result(0, 0, 0, 0);

    void run() {
        int n = in.nextInt();

        int[] x = new int[n];
        int[] y = new int[n];
        for (int i = 0; i < n; i++) {
            x[i] = in.nextInt();
            y[i] = in.nextInt();
        }

        Result result = solve(n, x, y);
        out.println(result.minx + " " + result.miny);
        out.println(result.maxx + " " + result.maxy);
    }

    public Result solve(int n, int[] x, int[] y) {
        List<Segment> segments = new ArrayList<>();
        for (int i = 0; i < n; i++) {
            segments.add(new Segment(x[i], y[i], x[(i + 1) % n], y[(i + 1) % n]));
        }

        for (int k = 0; k < 4; k++) {
            int[] cx = compress(segments);
            List<List<Segment>> slices = new ArrayList<>();
            for (int i = 0; i < cx.length - 1; i++) {
                slices.add(new ArrayList<Segment>());
            }

            for (Segment segment : segments) {
                int minj = Arrays.binarySearch(cx, (int) segment.minx);
                int maxj = Arrays.binarySearch(cx, (int) segment.maxx);
                for (int j = minj; j < maxj; j++) {
                    slices.get(j).add(segment);
                }
            }

//            System.out.println("k = " + k);
            for (int i = 0; i < cx.length - 1; i++) {
                List<Segment> slice = slices.get(i);
                assert slice.size() == 2;
                double mx = (cx[i + 1] + cx[i]) / 2.0;
                if (slice.get(0).y(mx) > slice.get(1).y(mx)) {
                    Collections.swap(slice, 0, 1);
                }
            }

            for (int i = 0; i < cx.length - 1; i++) {
                Segment bl = slices.get(i).get(0).cut(cx[i], cx[i + 1]);
                Segment tl = slices.get(i).get(1).cut(cx[i], cx[i + 1]);
                for (int j = i; j < cx.length - 1; j++) {
//                    System.out.println(i + " " + j);
                    Segment br = slices.get(j).get(0).cut(cx[j], cx[j + 1]);
                    Segment tr = slices.get(j).get(1).cut(cx[j], cx[j + 1]);
                    check(bl, tl, tr, br, k);
//
//                    Segment[] segs = new Segment[]{bl, tl, tr, br};
//                    for (int k = 0; k < 4; k++) {
//                        check(segs[0], segs[1], segs[2], segs[3], k);
//                        Segment s = segs[0];
//                        for (int z = 0; z < 3; z++) {
//                            segs[z] = segs[z + 1].rotate();
//                        }
//                        segs[3] = s.rotate();
//                    }
                }
            }

            for (int i = 0; i < segments.size(); i++) {
                segments.set(i, segments.get(i).rotate());
            }
        }
        return bestResult;
    }

    class Result {
        double area, minx, miny, maxx, maxy;

        Result(double minx, double miny, double maxx, double maxy) {
            this.minx = minx;
            this.miny = miny;
            this.maxx = maxx;
            this.maxy = maxy;
            area = (maxx - minx) * (maxy - miny);
        }
    }

    Result result(double minx, double miny, double maxx, double maxy, int k) {
        if (k == 0) {
            return new Result(minx, miny, maxx, maxy);
        } else {
            return result(miny, -maxx, maxy, -minx, k - 1);
        }
    }

    private void check(Segment bl, Segment tl, Segment tr, Segment br, int k) {
//        if (tl.maxy < tl.miny) {
//            tl = tl.horz(tl.miny);
//        }
//        if (bl.maxy > bl.miny) {
//            bl = bl.horz(bl.maxy);
//        }
//        if (tr.miny < tr.maxy) {
//            tr = tr.horz(tr.maxy);
//        }
//        if (br.miny > br.maxy) {
//            br = br.horz(br.maxy);
//        }
//        System.out.println("    " + k + " " + bl +  " " + tl + " " + tr + " " + br);
        if (tl.maxy < tl.miny) {
            tl = tl.horz(tl.maxy);
        }
        if (bl.maxy > bl.miny) {
            bl = bl.horz(bl.maxy);
        }
        if (tr.miny < tr.maxy) {
            tr = tr.horz(tr.miny);
        }
        if (br.miny > br.maxy) {
            br = br.horz(br.miny);
        }
//        System.out.println("    " + k + " " + bl +  " " + tl + " " + tr + " " + br);
        if (tl.isHorz() && tr.isHorz() && bl.isHorz() && br.isHorz()) {
            double minx = Math.max(bl.minx, tl.minx);
            double maxx = Math.min(br.maxx, tr.maxx);
            double miny = Math.max(bl.miny, br.miny);
            double maxy = Math.min(tl.maxy, tr.maxy);
            if (minx < maxx && miny < maxy) {
                Result result = result(minx, miny, maxx, maxy, k);
                if (bestResult.area < result.area) {
                    bestResult = result;
                }
            }
        }

        if (Math.abs(bl.a - br.a) >= EPS && Math.abs(bl.a - tl.a) >= EPS) {
            double xl = (bl.b * (br.a + tl.a) - br.a * tl.b - br.b * tl.a + bl.a * (br.b + tl.b - 2 * bl.b)) /
                    (2 * (bl.a - br.a) * (bl.a - tl.a));
            check(xl, bl, tl, br, tr, k);
        }

        if (Math.abs(bl.a * tr.a - br.a * tl.a) > EPS) {
            double xl = ((-bl.b + br.b) * tr.a + br.a * (tl.b - tr.b)) / (bl.a * tr.a - br.a * tl.a);
            check(xl, bl, tl, br, tr, k);
        }
        check(bl.minx, bl, tl, br, tr, k);
        check(bl.maxx, bl, tl, br, tr, k);
        check(bl.x(br.y(br.minx)), bl, tl, br, tr, k);
        check(bl.x(br.y(br.maxx)), bl, tl, br, tr, k);
    }

    private void check(double xl, Segment bl, Segment tl, Segment br, Segment tr, int k) {
        double yb = bl.y(xl);
        double yt = tl.y(xl);
        double xr = br.x(yb);
        if (
                bl.minx - EPS <= xl && xl <= bl.maxx + EPS &&
                br.minx - EPS <= xr && xr <= br.maxx + EPS &&
                yt <= tr.y(xr) + EPS && xl <= xr + EPS && yb <= yt + EPS
        ) {
            Result result = result(xl, yb, xr, yt, k);
            if (bestResult.area < result.area) {
                bestResult = result;
            }
        }
    }

    public static void main(String[] args) throws Exception {
        in = new Scanner(new File("easy.in"));
        out = new PrintWriter("easy.out");

        new easy_gk_wa_elongated().run();

        in.close();
        out.close();
    }
}
