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

// TODO: implement center distance minimisation instead as a WA solution

public class international_mb_angle_search {
    static final int N_PARTITIONS = 20;

    static class Circle {
        final double x, y, r;
        Circle(double x, double y, double r) {
            this.x = x;
            this.y = y;
            this.r = r;
        }
        Circle rotate(double cos, double sin) {
            return new Circle(x * cos - y * sin, x * sin + y * cos, r);
        }
        Circle stateSubtraction(Circle c) {
            return new Circle(x - c.x, y - c.y, r - c.r);
        }
    }

    static double match(Circle[] circles, double angle, double[] offset) {
        double cos = Math.cos(angle);
        double sin = Math.sin(angle);
        Circle p0 = circles[3].stateSubtraction(circles[0].rotate(cos, sin));
        Circle p1 = circles[4].stateSubtraction(circles[1].rotate(cos, sin));
        Circle p2 = circles[5].stateSubtraction(circles[2].rotate(cos, sin));

        // now we want to find a point with equal diff^2 - r^2 for all the circles
        double a00 = 2 * (p1.x - p0.x);
        double a01 = 2 * (p1.y - p0.y);
        double b0 = p0.r * p0.r - p1.r * p1.r + p1.x * p1.x - p0.x * p0.x + p1.y * p1.y - p0.y * p0.y;
        double a10 = 2 * (p2.x - p0.x);
        double a11 = 2 * (p2.y - p0.y);
        double b1 = p0.r * p0.r - p2.r * p2.r + p2.x * p2.x - p0.x * p0.x + p2.y * p2.y - p0.y * p0.y;
        double d = a00 * a11 - a01 * a10;
        double d0 = b0 * a11 - a01 * b1;
        double d1 = a00 * b1 - b0 * a10;
        double x = d0 / d;
        double y = d1 / d;

        double dc0 = (x - p0.x) * (x - p0.x) + (y - p0.y) * (y - p0.y) - p0.r * p0.r;
        //double dc1 = (x - p1.x) * (x - p1.x) + (y - p1.y) * (y - p1.y) - p1.r * p1.r;
        //double dc2 = (x - p2.x) * (x - p2.x) + (y - p2.y) * (y - p2.y) - p2.r * p2.r;

        offset[0] = x;
        offset[1] = y;

        return Math.max(dc0, 0);
    }

    static boolean match(Circle[] circles, double[] answer) {
        double sectorSize = Math.PI * 2 / N_PARTITIONS;
        for (int part = 0; part < N_PARTITIONS; ++part) {
            double l = sectorSize * part;
            double r = l + sectorSize;
            for (int iteration = 0; iteration < 100; ++iteration) {
                double ml = (2 * l + r) / 3;
                double mr = (l + 2 * r) / 3;
                double vl = match(circles, ml, answer);
                double vr = match(circles, mr, answer);
                if (vl < vr) {
                    r = mr;
                } else {
                    l = ml;
                }
            }
            double angle = (l + r) / 2;
            double match = match(circles, angle, answer);
            if (match < 1e-12) {
                answer[2] = angle;
                return true;
            }
        }
        return false;
    }

    public static void main(String[] args) throws IOException {
        try (Scanner in = new Scanner(System.in);
             PrintWriter out = new PrintWriter(System.out)) {
            Circle[] circles = new Circle[6];
            for (int i = 0; i < 6; ++i) {
                circles[i] = new Circle(in.nextInt(), in.nextInt(), in.nextInt());
            }
            // If there is no chance, just let it go
            if (circles[0].r > circles[3].r ||
                (circles[1].r > circles[4].r || circles[2].r > circles[5].r) &&
                (circles[1].r > circles[5].r || circles[2].r > circles[4].r)) {
                out.println("NO");
                return;
            }

            // Try both orderings until one succeeds
            double[] answer = new double[3];
            if (!match(circles, answer)) {
                Circle tmp = circles[1];
                circles[1] = circles[2];
                circles[2] = tmp;
                if (!match(circles, answer)) {
                    out.println("NO");
                    return;
                }
                tmp = circles[1];
                circles[1] = circles[2];
                circles[2] = tmp;
            }

            out.println("YES");
            double cos = Math.cos(answer[2]);
            double sin = Math.sin(answer[2]);
            for (int i = 0; i < 3; ++i) {
                double x = circles[i].x * cos - circles[i].y * sin + answer[0];
                double y = circles[i].y * cos + circles[i].x * sin + answer[1];
                out.println(x + " " + y);
            }
        }
    }
}