import java.io.*;
import java.util.*;

/**
 * Solution for NEERC'2013 Problem E: Easy Geometry.
 * This solution checks correctness of the input.
 *
 * @author Roman Elizarov
 */
public class easy_re {

    private static final int MAX_N = 100_000;
    private static final int MAX_XY_ABS = 1_000_000_000;

    private static final double PHI = (Math.sqrt(5) - 1) / 2;
    private static final double EPS = 1e-6;

    public static void main(String[] args) throws Exception {
        new easy_re().go();
    }

    void go() throws Exception {
        long time = System.currentTimeMillis();
        read();
        solve();
        write();
        System.out.printf("Done in %d ms%n", System.currentTimeMillis() - time);
    }

    static class Pt {
        final int x;
        final int y;

        Pt(int x, int y) {
            this.x = x;
            this.y = y;
        }

        @Override
        public String toString() {
            return String.format("(%d,%d)", x, y);
        }
    }

    int n;
    Pt[] pts;

    void read() throws Exception {
        Scanner in = new Scanner(new File("easy.in"));
        n = in.nextInt();
        in.nextLine();
        assert n >= 3 && n <= MAX_N;
        pts = new Pt[n];
        for (int i = 0; i < n; i++) {
            int x = in.nextInt();
            int y = in.nextInt();
            in.nextLine();
            assert Math.abs(x) <= MAX_XY_ABS;
            assert Math.abs(y) <= MAX_XY_ABS;
            pts[i] = new Pt(x, y);
        }
        in.close();
    }

    abstract static class Fun {
        double bestA;

        abstract double compute(double a);

        double optimize(double a0, double a3) {
            double a1 = a0 + (a3 - a0) * (1 - PHI);
            double a2 = a0 + (a3 - a0) * PHI;
            double v1 = compute(a1);
            double v2 = compute(a2);
            while (a3 - a0 > EPS) {
                if (v1 > v2) {
                    a3 = a2;
                    a2 = a1;
                    a1 = a0 + (a3 - a0) * (1 - PHI);
                    v2 = v1;
                    v1 = compute(a1);
                } else {
                    a0 = a1;
                    a1 = a2;
                    a2 = a0 + (a3 - a0) * PHI;
                    v1 = v2;
                    v2 = compute(a2);
                }
            }
            if (v1 > v2) {
                bestA = a1;
                return v1;
            } else {
                bestA = a2;
                return v2;
            }
        }
    }

    List<Pt> up = new ArrayList<>();
    List<Pt> dn = new ArrayList<>();
    int minX;
    int maxX;
    double maxW;

    private void cleanup(List<Pt> pts) {
        while (pts.size() > 1 && pts.get(0).x == pts.get(1).x)
            pts.remove(0);
        while (pts.size() > 1 && pts.get(pts.size() - 1).x == pts.get(pts.size() - 2).x)
            pts.remove(pts.size() - 1);
    }

    double findY(List<Pt> pts, double x) {
        int l = 0;
        int r = pts.size() - 1;
        while (l < r - 1) {
            int m = (l + r) / 2;
            int xm = pts.get(m).x;
            if (x < xm - EPS)
                r = m;
            else
                l = m;
        }
        assert l == r - 1;
        Pt p0 = pts.get(l);
        Pt p1 = pts.get(r);
        return p0.y + (p1.y - p0.y) * (x - p0.x) / (p1.x - p0.x);
    }

    class WFun extends Fun {
        @Override
        double compute(double w) {
            xf.w = w;
            return xf.optimize(minX, maxX -  w);
        }
    }

    class XFun extends Fun {
        double w;
        double y00;
        double y01;
        double y10;
        double y11;
        double minY;
        double maxY;

        @Override
        double compute(double x0) {
            double x1 = x0 + w;
            y00 = findY(dn, x0);
            y01 = findY(up, x0);
            y10 = findY(dn, x1);
            y11 = findY(up, x1);
            minY = Math.max(y00, y10);
            maxY = Math.min(y01, y11);
            return w * (maxY - minY);
        }
    }

    WFun wf = new WFun();
    XFun xf = new XFun();

    double x0;
    double x1;
    double y0;
    double y1;

    void solve() {
        // find left & right X
        int minIndex = -1;
        int maxIndex = -1;
        minX = Integer.MAX_VALUE;
        maxX = Integer.MIN_VALUE;
        for (int i = 0; i < n; i++) {
            if (pts[i].x < minX) {
                minX = pts[i].x;
                minIndex = i;
            }
            if (pts[i].x > maxX) {
                maxX = pts[i].x;
                maxIndex = i;
            }
        }
        // build upper & lower chain
        assert minX < maxX;
        int index = minIndex;
        while (true) {
            up.add(pts[index]);
            if (index == maxIndex)
                break;
            index = (index + 1) % n;
        }
        while (true) {
            dn.add(pts[index]);
            if (index == minIndex)
                break;
            index = (index + 1) % n;
        }
        Collections.reverse(dn);
        cleanup(up);
        cleanup(dn);

        // solve
        maxW = maxX - minX;
        wf.optimize(0, maxW);
        double w = wf.bestA;
        xf.w = w;
        xf.optimize(minX, maxX - w);
        x0 = xf.bestA;
        xf.compute(x0);
        x1 = x0 + w;
        y0 = xf.minY;
        y1 = xf.maxY;
    }

    void write() throws Exception {
        PrintWriter out = new PrintWriter("easy.out");
        out.printf(x0 + " " + y0 + " " + x1 + " " + y1);
        out.close();
    }

//----------------- just for validation ------------------

    /**
     * Strict scanner to verify 100% correspondence between input files and input file format specification.
     * It is a drop-in replacement for {@link java.util.Scanner} that could be added to a solution source
     * (cut-and-paste) without breaking its ability to work with {@link java.util.Scanner}.
     */
    public class Scanner {
        private final BufferedReader in;
        private String line = "";
        private int pos;
        private int lineNo;

        public Scanner(File source) throws FileNotFoundException {
            in = new BufferedReader(new FileReader(source));
            nextLine();
        }

        public void close() {
            assert line == null : "Extra data at the end of file";
            try {
                in.close();
            } catch (IOException e) {
                throw new AssertionError("Failed to close with " + e);
            }
        }

        public void nextLine() {
            assert line != null : "EOF";
            assert pos == line.length() : "Extra characters on line " + lineNo;
            try {
                line = in.readLine();
            } catch (IOException e) {
                throw new AssertionError("Failed to read line with " + e);
            }
            pos = 0;
            lineNo++;
        }

        public String next() {
            assert line != null : "EOF";
            assert line.length() > 0 : "Empty line " + lineNo;
            if (pos == 0)
                assert line.charAt(0) > ' ' : "Line " + lineNo + " starts with whitespace";
            else {
                assert pos < line.length() : "Line " + lineNo + " is over";
                assert line.charAt(pos) == ' ' : "Wrong whitespace on line " + lineNo;
                pos++;
                assert pos < line.length() : "Line " + lineNo + " is over";
                assert line.charAt(pos) > ' ' : "Line " + lineNo + " has double whitespace";
            }
            StringBuilder sb = new StringBuilder();
            while (pos < line.length() && line.charAt(pos) > ' ')
                sb.append(line.charAt(pos++));
            return sb.toString();
        }

        public int nextInt() {
            String s = next();
            assert s.length() == 1 || s.charAt(0) != '0' : "Extra leading zero in number " + s + " on line " + lineNo;
            assert s.charAt(0) != '+' : "Extra leading '+' in number " + s + " on line " + lineNo;
            try {
                return Integer.parseInt(s);
            } catch (NumberFormatException e) {
                throw new AssertionError("Malformed number " + s + " on line " + lineNo);
            }
        }
    }
}
