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

public class easy_mb {
    static class Point implements Comparable<Point> {
        final int x, y;
        Point(int x, int y) {
            this.x = x;
            this.y = y;
        }
        public int compareTo(Point that) {
            if (x != that.x) {
                return x - that.x;
            } else {
                return y - that.y;
            }
        }
        public String toString() {
            return "(" + x + "; " + y + ")";
        }
    }

    static Point[][] upperAndLower(Point[] polygon) {
        int n = polygon.length;
        int minIndex = 0, maxIndex = 0;
        for (int i = 1; i < n; ++i) {
            if (polygon[i].compareTo(polygon[minIndex]) < 0) {
                minIndex = i;
            }
            if (polygon[i].compareTo(polygon[maxIndex]) > 0) {
                maxIndex = i;
            }
        }
        List<Point> upper = new ArrayList<>();
        List<Point> lower = new ArrayList<>();
        for (int i = minIndex; i != maxIndex; i = (i + 1) % n) {
            upper.add(polygon[i]);
        }
        upper.add(polygon[maxIndex]);
        for (int i = minIndex; i != maxIndex; i = (i + n - 1) % n) {
            lower.add(polygon[i]);
        }
        lower.add(polygon[maxIndex]);
        return new Point[][] {
           upper.toArray(new Point[upper.size()]),
           lower.toArray(new Point[lower.size()])
        };
    }

    static class Event implements Comparable<Event> {
        final double leftBoundLocation;
        final int type;
        final int pointIndex;

        Event(double leftBoundLocation, int type, int pointIndex) {
            this.leftBoundLocation = leftBoundLocation;
            this.type = type;
            this.pointIndex = pointIndex;
        }
        public int compareTo(Event that) {
            return Double.compare(leftBoundLocation, that.leftBoundLocation);
        }
    }

    static final int L_L  = 0;
    static final int L_R = 1;
    static final int U_L  = 2;
    static final int U_R = 3;

    static double interpolate(Point left, Point right, double t, boolean fromUpper) {
        if (left.x > right.x) {
            throw new AssertionError();
        }
        if (left.x > t + 1e-7 || t - 1e-7 > right.x) {
            throw new AssertionError();
        }
        if (left.x == right.x) {
            return fromUpper ? Math.max(left.y, right.y) : Math.min(left.y, right.y);
        }
        return left.y + (t - left.x) / (right.x - left.x) * (right.y - left.y);
    }

    static void merge(Event[] src1, int from1, int until1, Event[] src2, int from2, int until2, Event[] trg, int from) {
        int f1 = from;
        while (from1 < until1 && from2 < until2) {
            if (src1[from1].compareTo(src2[from2]) <= 0) {
                trg[from++] = src1[from1++];
            } else {
                trg[from++] = src2[from2++];
            }
        }
        while (from1 < until1) {
            trg[from++] = src1[from1++];
        }
        while (from2 < until2) {
            trg[from++] = src2[from2++];
        }
        for (int i = f1 + 1; i < from; ++i) {
            if (trg[i - 1].compareTo(trg[i]) > 0) {
                throw new AssertionError("merge does not work");
            }
        }
    }

    static double computeMaxArea(Point[] upper, Point[] lower, double width, double[] bounds) {
        int upperCount = upper.length;
        int lowerCount = lower.length;
        Event[] eventArray1 = new Event[2 * (upperCount + lowerCount)];
        Event[] eventArray2 = new Event[2 * (upperCount + lowerCount)];
        int eventCount = 0;
        for (int i = 0; i < upperCount; ++i) {
            eventArray1[eventCount++] = new Event(upper[i].x, U_L, i);
        }
        for (int i = 0; i < upperCount; ++i) {
            eventArray1[eventCount++] = new Event(upper[i].x - width, U_R, i);
        }
        for (int i = 0; i < lowerCount; ++i) {
            eventArray1[eventCount++] = new Event(lower[i].x, L_L, i);
        }
        for (int i = 0; i < lowerCount; ++i) {
            eventArray1[eventCount++] = new Event(lower[i].x - width, L_R, i);
        }
        merge(
            eventArray1, 0, upperCount, 
            eventArray1, upperCount, 2 * upperCount, 
            eventArray2, 0
        );
        merge(
            eventArray1, 2 * upperCount, 2 * upperCount + lowerCount, 
            eventArray1, 2 * upperCount + lowerCount, 2 * upperCount + 2 * lowerCount, 
            eventArray2, 2 * upperCount
        );
        merge(
            eventArray2, 0, 2 * upperCount,
            eventArray2, 2 * upperCount, 2 * upperCount + 2 * lowerCount,
            eventArray1, 0
        );

        int[] pointers = new int[] {lowerCount, lowerCount, upperCount, upperCount};

        double previous = Double.NEGATIVE_INFINITY;

        double maxArea = 0;

        double[] positions = new double[4];

        for (Event e : eventArray1) {
            int pll = pointers[L_L];
            int plr = pointers[L_R];
            int pul = pointers[U_L];
            int pur = pointers[U_R];
            if (pll + 1 < lowerCount && plr + 1 < lowerCount &&
                pul + 1 < upperCount && pur + 1 < upperCount
            ) {
                int posCount = 0;
                positions[posCount++] = previous;
                positions[posCount++] = e.leftBoundLocation;
                if (pll != plr) {
                    double x0 = lower[pll].x;
                    double y0 = lower[pll].y;
                    double x1 = lower[pll + 1].x;
                    double y1 = lower[pll + 1].y;
                    double x2 = lower[plr].x;
                    double y2 = lower[plr].y;
                    double x3 = lower[plr + 1].x;
                    double y3 = lower[plr + 1].y;
                    if (Math.abs(x1 - x0) > 1e-9 && Math.abs(x3 - x2) > 1e-9) {
                        double a1 = (y1 - y0) / (x1 - x0);
                        double a2 = (y3 - y2) / (x3 - x2);
                        double t = (y2 - y0 + (width - x2) * a2 + x0 * a1) / (a1 - a2);
                        if (t > previous && t < e.leftBoundLocation) {
                            positions[posCount++] = t;
                        }
                    }
                }
                if (pul != pur) {
                    double x0 = upper[pul].x;
                    double y0 = upper[pul].y;
                    double x1 = upper[pul + 1].x;
                    double y1 = upper[pul + 1].y;
                    double x2 = upper[pur].x;
                    double y2 = upper[pur].y;
                    double x3 = upper[pur + 1].x;
                    double y3 = upper[pur + 1].y;
                    if (Math.abs(x1 - x0) > 1e-9 && Math.abs(x3 - x2) > 1e-9) {
                        double a1 = (y1 - y0) / (x1 - x0);
                        double a2 = (y3 - y2) / (x3 - x2);
                        double t = (y2 - y0 + (width - x2) * a2 + x0 * a1) / (a1 - a2);
                        if (t > previous && t < e.leftBoundLocation) {
                            positions[posCount++] = t;
                        }
                    }
                }
                for (int pos = 0; pos < posCount; ++pos) {
                    double t = positions[pos];
                    double ul = interpolate(upper[pul], upper[pul + 1], t, true);
                    double ll = interpolate(lower[pll], lower[pll + 1], t, false);
                    double ur = interpolate(upper[pur], upper[pur + 1], t + width, true);
                    double lr = interpolate(lower[plr], lower[plr + 1], t + width, false);
                    double area = width * (Math.min(ul, ur) - Math.max(ll, lr));
                    if (area > maxArea) {
                        maxArea = area;
                        if (bounds != null) {
                            bounds[0] = t;
                            bounds[1] = Math.max(ll, lr);
                            bounds[2] = t + width;
                            bounds[3] = Math.min(ul, ur);
                        }
                    }
                }
            }
            previous = e.leftBoundLocation;
            pointers[e.type] = e.pointIndex;
        }
        return maxArea;
    }

    public static double[] solve(int n, int[] x, int[] y) {
        Point[] pts = new Point[n];
        for (int i = 0; i < n; ++i) {
            pts[i] = new Point(x[i], y[i]);
        }
        return solve(pts);
    }

    static double[] solve(Point[] polygon) {
        Point[] upper, lower; {
            Point[][] upperLower = upperAndLower(polygon);
            upper = upperLower[0];
            lower = upperLower[1];
        }
        double lWidth = 0, rWidth = upper[upper.length - 1].x - upper[0].x;
        double[] bounds = new double[4];
        double[] answer = new double[4];
        double maxFound = 0;
        for (int iteration = 0; iteration < 50; ++iteration) {
            double lMid = (lWidth * 2 + rWidth) / 3;
            double rMid = (lWidth + 2 * rWidth) / 3;
            double lValue = computeMaxArea(upper, lower, lMid, bounds);
            if (lValue > maxFound) {
                maxFound = lValue;
                System.arraycopy(bounds, 0, answer, 0, 4);
            }
            double rValue = computeMaxArea(upper, lower, rMid, bounds);
            if (rValue > maxFound) {
                maxFound = rValue;
                System.arraycopy(bounds, 0, answer, 0, 4);
            }
            if (lValue >= rValue) {
                rWidth = rMid;
            } else {
                lWidth = lMid;
            }
        }
        return answer;
    }

    public static void main(String[] args) throws IOException {
        try (BufferedReader in = new BufferedReader(new FileReader("easy.in"));
             PrintWriter out = new PrintWriter("easy.out")) {
            int n = Integer.parseInt(in.readLine());
            Point[] pts = new Point[n];
            for (int i = 0; i < n; ++i) {
                String line = in.readLine();
                int wsi = line.indexOf(' ');
                pts[i] = new Point(
                    Integer.parseInt(line.substring(0, wsi)),
                    Integer.parseInt(line.substring(wsi + 1))
                );
            }
            double[] rv = solve(pts);
            out.println(rv[0] + " " + rv[1]);
            out.println(rv[2] + " " + rv[3]);
        }
    }
}
