/*--------------------------------------------------------------*/
/* ACM ICPC 2009-2010, NEERC                                    */
/* Northern Subregional Contest                                 */
/* St Petersburg, October 17, 2009                              */
/*--------------------------------------------------------------*/
/* Problem F. Four Points                                       */
/*                                                              */
/* Original idea         Mikhail Dvorkin                        */
/* Problem statement     Yury Petrov                            */
/* Testset               Yury Petrov                            */
/*--------------------------------------------------------------*/
/* Solution                                                     */
/*                                                              */
/* Author                Georgiy Korneev                        */
/*--------------------------------------------------------------*/
 
import java.util.*;
import java.io.*;

public class four_gk implements Runnable {
    static final double EPS = 1e-6;
    static Scanner in;
    static PrintWriter out;

    class Point {
        final double x;
        final double y;

        Point(double x, double y) {
            this.x = x;
            this.y = y;
        }

        Point mid(Point that) {
            return new Point((this.x + that.x) / 2, (this.y + that.y) / 2);
        }

        Point plus(Point that) {
            return new Point(this.x + that.x, this.y + that.y);
        }

        Point minus(Point that) {
            return new Point(this.x - that.x, this.y - that.y);
        }

        double dist(Point that) {
            return Math.hypot(this.x - that.x, this.y - that.y);
        }

        Point rotate() {
            return new Point(y, -x);
        }

        Point scale(double s) {
            return new Point(x * s, y * s);
        }
        
        @Override
        public String toString() {
            return String.format("(%.3f, %.3f)", x, y);
        }
    }

    public class Line {
        final double a;
        final double b;
        final double c;

        Line(Point p1, Point p2) {
            double a = p1.y - p2.y;
            double b = p2.x - p1.x;
            double c = a * p1.x + b * p1.y;
            double d = Math.hypot(a, b);
            this.a = a / d;
            this.b = b / d;
            this.c = c / d;
        }

        Point[] intersectCircle(Point p, double r) {
            double d = dist(p);
            if (d * d > r * r) {
                d = d > 0 ? r : -r;
            }
            double z = Math.sqrt(r * r - d * d);
            return new Point[]{
                new Point(p.x - a * d + b * z, p.y - b * d - a * z),
                new Point(p.x - a * d - b * z, p.y - b * d + a * z)
            };
        }

        double dist(Point p) {
            return a * p.x + b * p.y - c;
        }
    }

    Point[] corners(Point p1, Point p2) {
        Point mid = p1.mid(p2);
        return new Point[]{
            mid.plus(p1.minus(mid).rotate()),
            mid.minus(p1.minus(mid).rotate())
        };
    }

    Point nearest(Point[] ps, Point p) {
        return (ps[0].dist(p) < ps[1].dist(p)) ? ps[0] : ps[1];
    }

    Point takeOther(Point[] ps, Point p) {
        return (ps[0].dist(p) < ps[1].dist(p)) ? ps[1] : ps[0];
    }

    boolean between(double x, double a, double b) {
    	if (Math.abs(a - b) < EPS) {
    		return Math.abs(a - x) < EPS;
    	}
        return (a < b) ? a + EPS < x && x < b - EPS : b + EPS < x && x < a - EPS;
    }

    boolean belongs(Point p, Point p1, Point p2) {
        return Math.abs(new Line(p1, p2).dist(p)) < EPS && between(p.x, p1.x, p2.x) && between(p.y, p1.y, p2.y);
    }

    public boolean solve(Point[] p) {
        Point center1 = p[0].mid(p[1]);
        Point center2 = p[2].mid(p[3]);

        Point[] sc1 = corners(p[0], p[1]);
        Point[] sc2 = corners(p[2], p[3]);
        Point mid1 = nearest(sc1, center2);
        Point mid2 = nearest(sc2, center1);

        Point[] ans;
        if (mid1.dist(mid2) > EPS) {
            Line line = new Line(mid1, mid2);

            Point[] i1 = line.intersectCircle(center1, p[0].dist(p[1]) / 2);
            Point[] i2 = line.intersectCircle(center2, p[2].dist(p[3]) / 2);
        
            Point a1 = takeOther(i1, mid1);
            Point a3 = takeOther(i2, mid2);
            Point[] corners = corners(a1, a3);
            ans = new Point[]{a1, corners[0], a3, corners[1]};
            
            for (int i = 0; i < 4; i++) {
                if (!belongs(p[i], ans[(i + 3) % 4], ans[i])) {
                    return false;
                }
            }
        } else {
            Point center = p[0].plus(p[1]).plus(p[2]).plus(p[3]).scale(0.25);
            ans = new Point[4];
            for (int i = 0; i < 4; i++) {
                ans[i] = p[(i + 2) % 4].plus(p[(i + 1) % 4]).minus(center);
            }
        }

        for (int i = 0; i < 4; i++) {
            out.println(ans[i].x + " " + ans[i].y);
        }
        return true;
    }

    public void run() {
        Point[] p = new Point[4];

        for (int i = 0; i < 4; i++) {
            p[i] = new Point(in.nextInt(), in.nextInt());
        }
        for (int i1 = 0; i1 < 4; i1++) {
            for (int i2 = 0; i2 < 4; i2++) {
                if (i1 == i2) continue;
                for (int i3 = 0; i3 < 4; i3++) {
                    if (i1 == i3 || i2 == i3) continue;
                    for (int i4 = 0; i4 < 4; i4++) {
                        if (i1 == i4 || i2 == i4 || i3 == i4) continue;
                        if (solve(new Point[]{p[i1], p[i2], p[i3], p[i4]})) {
                            return;
                        }
                    }
                }
            }
        }
        for (int i = 0; i < 4; i++) {
            out.println("0 0");
        }
    }

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

        new four_gk().run();

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