#include <cmath>
#include <iostream>
#include <ostream>

using namespace std;

#define double long double

double rand_double() {
    return (double)rand() / RAND_MAX;
}

struct Point {
    double x = 0, y = 0;

    double dist(const Point &other) const {
        return sqrt((x - other.x) * (x - other.x) + (y - other.y) * (y - other.y));
    }
};

struct Circle {
    Point center;
    double radius;
};

Circle read_circle() {
    Circle c;
    cin >> c.center.x >> c.center.y >> c.radius;
    return c;
}

struct Socket {
    Circle circles[3];
};

Socket read_socket() {
    Socket s;
    for (int i = 0; i < 3; i++) {
        s.circles[i] = read_circle();
    }
    return s;
}

struct Shift {
    double d_angle;
    Point d_coord;
};

Shift gen_random_shift(double max_delta) {
    Shift res = Shift{
        .d_angle = (rand_double() - 0.5) * max_delta,
        .d_coord = {
            (rand_double() - 0.5) * max_delta,
            (rand_double() - 0.5) * max_delta,
        },
    };
    if (rand() % 2) {
        res.d_angle = 0.0;
    }
    if (rand() % 2) {
        res.d_coord = {0.0, 0.0};
    }
    return res;
}

Socket apply_shift(Socket socket, Shift shift) {
    for (int i = 0; i < 3; i++) {
        socket.circles[i].center.x += shift.d_coord.x;
        socket.circles[i].center.y += shift.d_coord.y;
    }
    Point center = {
        (socket.circles[0].center.x + socket.circles[1].center.x + socket.circles[2].center.x) / 3,
        (socket.circles[0].center.y + socket.circles[1].center.y + socket.circles[2].center.y) / 3,
    };
    for (int i = 0; i < 3; i++) {
        double angle = atan2(socket.circles[i].center.y - center.y, socket.circles[i].center.x - center.x);
        double dist = socket.circles[i].center.dist(center);
        angle += shift.d_angle;
        socket.circles[i].center.x = center.x + cos(angle) * dist;
        socket.circles[i].center.y = center.y + sin(angle) * dist;
    }
    return socket;
}

const double PI = atan(1) * 4;

const double BAD_SCORE = 1e18;

const double EPS = 0.5e-6;

double calc_score(const Socket &external, const Socket &internal) {
    double score = BAD_SCORE;
    for (bool swap : {false, true}) {
        double cur_score = 0.0;
        Socket external_check = external;
        if (swap) {
            std::swap(external_check.circles[1], external_check.circles[2]);
        }
        for (int i = 0; i < 3; i++) {
            if (internal.circles[i].radius > external_check.circles[i].radius) {
                cur_score = BAD_SCORE;
            }
        }
        for (int i = 0; i < 3; i++) {
            double cur_dist = external_check.circles[i].center.dist(internal.circles[i].center) + internal.circles[i].radius - EPS - external_check.circles[i].radius;
            cur_score = max(cur_score, cur_dist);
        }
        score = min(cur_score, score);
    }
    return score;
}

int main() {
    Socket internal = read_socket();
    Socket external = read_socket();
    for (int it = 0; it < 100; it++) {
        Socket internal_check = internal;
        double score = calc_score(external, internal_check);
        for (double delta = 100.0; delta >= 1e-12; delta *= 0.7) {
            for (int not_changed = 0, at_most = 1000; not_changed < 50 && at_most > 0; not_changed++, at_most--) {
                Shift shift = gen_random_shift(delta);
                Socket next_internal = apply_shift(internal_check, shift);
                double next_score = calc_score(external, next_internal);
                if (next_score < score) {
                    score = next_score;
                    internal_check = next_internal;
                    not_changed = 0;
                }
            }
        }
        if (score == 0.0) {
            cout << "YES\n";
            cout.precision(20);
            for (int i = 0; i < 3; i++) {
                cout << internal_check.circles[i].center.x << " " << internal_check.circles[i].center.y << "\n";
            }
            return 0;
        }
    }

    cout << "NO\n";
}