import java.io.*;
import java.util.*;
import static java.lang.Math.*;

public class geometry_as implements Runnable {
    final static double EPS = 1e-9;
    final static double ALLOWANCE = 1.5e-4;

    Scanner in;
    PrintWriter out;

    class Point {
        double x;
        double y;

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

        double dist(Point p) {
            return hypot(x - p.x, y - p.y);
        }

        public String toString() {
            return "(" + x + "," + y + ")";
        }

        public boolean equals(Object o) {
            Point p = (Point) o;
            return abs(x - p.x) < EPS && abs(y - p.y) < EPS;
        }
    }

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

        public Line(Point p1, Point p2) {
            a = p1.y - p2.y;
            b = p2.x - p1.x;
            c = a * p1.x + b * p1.y;

            norm();
        }

        void norm() {
            double d = hypot(a, b);
            a /= d;
            b /= d;
            c /= d;

            if (a < -EPS) {
                a = -a;
                b = -b;
                c = -c;
            } else if (abs(a) < EPS && b < -EPS) {
                a = -a;
                b = -b;
                c = -c;
            }
        }

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

        Point project(double x) {
            Point p = new Point(a * c, b * c);
            p.x += x * b;
            p.y -= x * a;
            assert abs(coord(p) - x) < EPS;
            return p;
        }

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

        int side(Point p) {
            double r = p.x * a + p.y * b - c;
            if (r < -EPS) {
                return -1;
            } else if (r > EPS) {
                return 1;
            } else {
                return 0;
            }
        }

        public boolean equals(Object o) {
            Line l = (Line) o;
            norm();
            l.norm();
            return abs(a - l.a) < EPS && abs(b - l.b) < EPS && abs(c - l.c) < EPS;
        }
    }

    public void solve() throws IOException {
        in = new Scanner(new File("geometry.in"));
        out = new PrintWriter(new File("geometry.out"));

        while (solveSingleTest()) ;

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

    public boolean solveSingleTest() throws IOException {
        Point p11 = new Point(in.nextInt(), in.nextInt());
        Point p12 = new Point(in.nextInt(), in.nextInt());
        Point p21 = new Point(in.nextInt(), in.nextInt());
        Point p22 = new Point(in.nextInt(), in.nextInt());

        if (p11.x == 0 && p11.y == 0 && p12.x == 0 && p12.y == 0 && p21.x == 0 && p21.y == 0 && p22.x == 0 && p22.y == 0) {
            return false;
        }

        Line l1 = new Line(p11, p12);
        Line l2 = new Line(p21, p22);

        if (l1.equals(l2)) {
            double t11 = l1.coord(p11);
            double t12 = l1.coord(p12);
            if (t11 > t12) {
                double tmp = t11; t11 = t12; t12 = tmp;
            }
            double t21 = l1.coord(p21);
            double t22 = l1.coord(p22);
            if (t21 > t22) {
                double tmp = t21; t21 = t22; t22 = tmp;
            }

            if (t22 < t11 + EPS || t12 < t21 + EPS) {
                double tc = (t11 + t12 + t21 + t22) / 4;
                double r = hypot((t11 + t12) / 2 - tc, 1);
                Point c = l1.project(tc);
                c.x += l1.a;
                c.y += l1.b;

                out.printf("%.10f %.10f %.10f\n", c.x, c.y, r);
            } else {
                double t1 = max(t11, t21);
                double t2 = min(t12, t22);

                double tc = (t1 + t2) / 2;

                double r = max(max(abs(t11 - tc), abs(t21 - tc)), max(abs(t12 - tc), abs(t22 - tc))) + 1;

                Point c = l1.project(tc + r);
                out.printf("%.10f %.10f %.10f\n", c.x, c.y, r);
            }
        } else {
            Line t = null;
            double bd = 0;
            search:
            for (int i = 1; i <= 3; i++) {
                for (int j = 1; j <= 3; j++) {
                    Point c1 = new Point((p11.x * i + p12.x * (4 - i)) / 4, (p11.y * i + p12.y * (4 - i)) / 4);
                    Point c2 = new Point((p21.x * j + p22.x * (4 - j)) / 4, (p21.y * j + p22.y * (4 - j)) / 4);

                    if (c1.equals(c2)) {
                        continue;
                    }
                    Line t1 = new Line(c1, c2);
                    if (t1.equals(l1)  || t1.equals(l2)) {
                        continue;
                    }

                    double d = min(min(t1.dist(p11), t1.dist(p12)), min(t1.dist(p21), t1.dist(p22)));
                    if (d > bd) {
                        t = t1;
                        bd = d;
                    }
                }
            }
            if (t == null) {
                System.out.println("");
            }
            assert t != null;

            Point p1 = t.side(p11) > 0 ? p11 : p12;
            Point p2 = t.side(p21) > 0 ? p21 : p22;

            double tc = (t.coord(p1) + t.coord(p2)) / 2;

            Point cp = t.project(tc);
            double r = 1;
            Point c;
            while (true) {
                c = new Point(cp.x + t.a * r, cp.y + t.b * r);
                if (c.dist(p1) < r - ALLOWANCE && c.dist(p2) < r - ALLOWANCE) {
                    break;
                }
                r *= 2;
            }
            out.printf("%.10f %.10f %.10f\n", c.x, c.y, r);
        }

        out.flush();
        return true;
    }

    public void run() {
        try {
            solve();
        } catch (IOException e) {
            System.exit(64);
        }
    }

    public static void main(String[] arg) throws IOException {
        Locale.setDefault(Locale.US);
        new Thread(new geometry_as()).start();
    }
}
