#include <bits/stdc++.h>

#define all(a) (a).begin(), (a).end()
#define sz(a) (int)(a).size()
#define pb push_back

using namespace std;

#define int int64_t

typedef long long ll;
typedef long double ld;
typedef pair<ld, ld> pld;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

mt19937 rr(998244353);

void rs(vector<int>& v) {
    for (int i = 1; i < sz(v); ++i) {
        int j = rr() % (i + 1);
        swap(v[i], v[j]);
    }
}

struct pt {
    ll x, y;
    int id;
    pt() {}
    pt(ll x, ll y, int id = -1) : x(x), y(y), id(id) {}
    bool operator<(const pt& other) const {
        if (x != other.x) {
            return x < other.x;
        }
        return y < other.y;
    }
    pt operator-(const pt& other) const {
        return {x - other.x, y - other.y};
    }
};

ll cross(const pt& p, const pt& q) {
    return p.x * q.y - p.y * q.x;
}

ll dot(const pt& p, const pt& q) {
    return p.x * q.x + p.y * q.y;
}

struct triangle {
    int e[3];
    triangle(int a, int b, int c) {
        e[0] = a, e[1] = b, e[2] = c;
    }
    triangle() {}
};

const int nmax = 2e6;
const int emax = nmax * 3;

pii edges[emax];
int g[emax];
triangle triangles[nmax];
vector<pt> p;
int ptre = 0;
int ptr = 0;

int getOther(int v, int a, int b) {
    triangle& t = triangles[v];
    for (int i = 0; i < 3; ++i) {
        int j = t.e[i];
        int u = edges[j].first, v = edges[j].second;
        if (u != a && u != b) {
            return u;
        }
        if (v != a && v != b) {
            return v;
        }
    }
    assert(false);
}

int getId(int v, int a, int b) {
    triangle& t = triangles[v];
    for (int i = 0; i < 2; ++i) {
        int j = t.e[i];
        if (edges[j].first + edges[j].second == a + b) {
            return j;
        }
    }
    return t.e[2];
}

int getSide(int a, int u, int v) {
    assert(a != u && a != v && a >= 0);
    if (u >= 0 && v >= 0) {
        ll val = cross(p[a] - p[u], p[v] - p[u]);
        return (val > 0 ? 1 : (val == 0 ? 0 : -1));
    }
    if (u == -1 && v == -2) {
        return -1;
    }
    if (u == -2 && v == -1) {
        return 1;
    }
    int ans = (p[a] < p[max(u, v)] ? 1 : -1);
    if (u == - 1 || v == -2) {
        ans *= (-1);
    }
    return ans;
}

bool inside(int i, int a, int b = -3, int c = -1) {
    if (i < 0) {
        return false;
    }
    if (b == -3) {
        int t = a;
        int j = triangles[t].e[0];
        a = edges[j].first, b = edges[j].second;
        c = getOther(t, a, b);
    }
    int cnt = 0;
    if (a < 0) {
        ++cnt;
    }
    if (b < 0) {
        ++cnt;
    }
    if (c < 0) {
        ++cnt;
    }
    int arr[3];
    if (cnt >= 2) {
        arr[0] = -1, arr[1] = a + b + c + 3, arr[2] = -2;
    } else if (cnt == 0) {
        arr[0] = a;
        if (cross(p[b] - p[a], p[c] - p[a]) < 0) {
            arr[1] = b, arr[2] = c;
        } else {
            arr[1] = c, arr[2] = b;
        }
    } else if (cnt == 1) {
        if (b < 0) {
            swap(a, b);
        } else if (c < 0) {
            swap(a, c);
        }
        arr[0] = a;
        if (a == -1) {
            if (p[c] < p[b]) {
                arr[1] = b, arr[2] = c;
            } else {
                arr[1] = c, arr[2] = b;
            }
        } else {
            if (p[b] < p[c]) {
                arr[1] = b, arr[2] = c;
            } else {
                arr[1] = c, arr[2] = b;
            }
        }
    }
    
    for (int j = 0; j < 3; ++j) {
        int u = arr[j], v = arr[(j + 1) % 3];
        if (u < 0 && v < 0) {
            continue;
        }
        if (u >= 0 && v >= 0) {
            if (cross(p[i] - p[u], p[v] - p[u]) < 0) {
                return false;
            }
        } else if (u == -1) {
            if (p[v] < p[i]) {
                return false;
            }
        } else if (v == -1) {
            if (p[i] < p[u]) {
                return false;
            }
        } else if (u == -2) {
            if (p[i] < p[v]) {
                return false;
            }
        } else if (v == -2) {
            if (p[u] < p[i]) {
                return false;
            }
        }
    }
    
    return true;
}

bool onSegment(int i, int a, int b) {
    pt u = p[a] - p[i], v = p[b] - p[i];
    return cross(u, v) == 0 && dot(u, v) <= 0;
}

bool onEdge(int i, int id) {
    int u = edges[id].first, v = edges[id].second;
    if (u >= 0 && v >= 0) {
        return onSegment(i, u, v);
    }
    return false;
}

struct edgeInfo {
    int t[2];
    int pos[2];
    edgeInfo() {
        t[0] = t[1] = pos[0] = pos[1] = -1;
    }
    edgeInfo(int x, int y) {
        t[0] = x, pos[0] = y;
        t[1] = pos[1] = -1;
    }
};

edgeInfo info[emax];

void change(int e, int tOld, int t, int pos) {
    if (info[e].t[0] == tOld) {
        info[e].t[0] = t;
        info[e].pos[0] = pos;
    } else {
        info[e].t[1] = t;
        info[e].pos[1] = pos;
    }
}

bool inside(const pt& a, const pt& b, const pt& c, const pt& d) {
    pt u1 = a - c, v1 = b - c;
    pt u2 = a - d, v2 = b - d;
    return ld(abs(cross(u1, v1))) * dot(u2, v2) + ld(abs(cross(u2, v2))) * dot(u1, v1) < 0;
}

queue<int> qu;

int common;

void legalize() {
    while (!qu.empty()) {
        int id = qu.front();
        qu.pop();
        if (info[id].t[1] == -1) {
            continue;
        }
        int i, j, k, l;
        i = edges[id].first, j = edges[id].second;
        int t1 = info[id].t[0], t2 = info[id].t[1];
        k = getOther(t1, i, j), l = getOther(t2, i, j);
        int a = getId(t1, i, k);
        int b = getId(t1, j, k);
        int c = getId(t2, i, l);
        int d = getId(t2, j, l);
        bool flip = false;
        if (i < 0 || j < 0) {
            if (inside(i, j, k, l) || inside(j, i, k, l)) {
                continue;
            }
        } else {
            int sgn1 = getSide(i, k, l), sgn2 = getSide(j, k, l);
            if (sgn1 == 0 || sgn2 == 0 || sgn1 == sgn2) {
                continue;
            }
        }
        if (i < 0 || j < 0 || k < 0 || l < 0) {
            if (min(i, j) < min(k, l)) {
                flip = true;
            }
        } else {
            if (inside(p[i], p[j], p[k], p[l])) {
                flip = true;
            }
        }
        if (flip) {
            edges[ptre++] = {k, l};
            triangles[ptr++] = {ptre - 1, a, c};
            change(a, t1, ptr - 1, 1);
            change(c, t2, ptr - 1, 2);
            change(ptre - 1, -1, ptr - 1, 0);
            triangles[ptr++] = {ptre - 1, b, d};
            change(b, t1, ptr - 1, 1);
            change(d, t2 , ptr - 1, 2);
            change(ptre - 1, -1, ptr - 1, 0);
            g[t1 * 3] = ptr - 2;
            g[t1 * 3 + 1] = ptr - 1;
            g[t2 * 3] = ptr - 2;
            g[t2 * 3 + 1] = ptr - 1;
            
            if (common == k) {
                qu.push(c);
                qu.push(d);
            } else {
                qu.push(a);
                qu.push(b);
            }
        }
    }
}

ll dist2(const pt& a, const pt& b) {
    return (a.x - b.x) * (a.x - b.x) + (a.y - b.y) * (a.y - b.y);
}

struct edge {
    int u, v;
    ll cost;
    bool operator<(const edge& other) const {
        return cost < other.cost;
    }
};

vector<int> parent;
vector<int> ssize;
vector<vector<int> > subtree;

vector<vector<int> > w;
vector<pii> zapr;

vector<array<int, 2>> solve(vector<array<int, 2>> pt_) {
    int n = pt_.size();
    
    memset(g, -1, sizeof(g));
    ptr = 0;
    ptre = 0;
    p.resize(n);
    
    vector<int> newId(n);
    for (int i = 0; i < n; ++i) {
        p[i].x = pt_[i][0];
        p[i].y = pt_[i][1];
        p[i].id = i;
    }
    
    sort(all(p));
    reverse(all(p));
    for (int i = 0; i < n; ++i) {
        newId[p[i].id] = i;
    }
    
    edges[ptre++] = {-1, 0};
    edges[ptre++] = {0, -2};
    edges[ptre++] = {-2, -1};
    triangles[ptr++] = {0, 1, 2};
    info[0] = {0, 0};
    info[1] = {0, 1};
    info[2] = {0, 2};
    
    vector<int> perm;
    for (int i = 1; i < n; ++i) {
        perm.pb(i);
    }
    rs(perm);
    
    for (int i = 0; i < sz(perm); ++i) {
        int v = 0;
        while (g[v * 3] != -1) {
            if (g[v * 3 + 2] == -1) {
                int id = g[v * 3];
                int j = triangles[id].e[0];
                int a = edges[j].first, b = edges[j].second;
                int c = getOther(id, a, b);
                int sgn1 = getSide(perm[i], a, b);
                int sgn2 = getSide(c, a, b);
                if (sgn1 == 0 || sgn1 == sgn2) {
                    v = id;
                } else {
                    v = g[v * 3 + 1];
                }
            } else {
                bool done = false;
                for (int z = 0; z + 1 < 3; ++z) {
                    int to = g[v * 3 + z];
                    if (inside(perm[i], to)) {
                        done = true;
                        v = to;
                        break;
                    }
                }
                if (!done) {
                    v = g[v * 3 + 2];
                }
            }
        }
        
        int on = -1;
        for (int z = 0; z < 3; ++z) {
            int j = triangles[v].e[z];
            if (onEdge(perm[i], j)) {
                on = j;
                break;
            }
        }
        
        if (on == -1) {
            int j = triangles[v].e[0];
            int a, b, c;
            a = edges[j].first, b = edges[j].second;
            c = getOther(v, a, b);
            
            edges[ptre++] = {perm[i], a};
            edges[ptre++] = {perm[i], b};
            edges[ptre++] = {perm[i], c};
            int k = ptre;
            
            triangles[ptr++] = {triangles[v].e[0], k - 2, k - 3};
            change(k - 2, -1, ptr - 1, 1);
            change(k - 3, -1, ptr - 1, 2);
            change(triangles[v].e[0], v, ptr - 1, 0);
            
            triangles[ptr++] = {getId(v, b, c), k - 1, k - 2};
            change(k - 1, -1, ptr - 1, 1);
            change(k - 2, -1, ptr - 1, 2);
            change(getId(v, b, c), v, ptr - 1, 0);
            
            triangles[ptr++] = {getId(v, c, a), k - 3, k - 1};
            change(k - 3, -1, ptr - 1, 1);
            change(k - 1, -1, ptr - 1, 2);
            change(getId(v, c, a), v, ptr - 1, 0);
            
            g[v * 3] = ptr - 1;
            g[v * 3 + 1] = ptr - 2;
            g[v * 3 + 2] = ptr - 3;
            
            for (int z = 0; z < 3; ++z) {
                qu.push(triangles[v].e[z]);
            }
        } else {
            int a = edges[on].first, b = edges[on].second;
            int u = info[on].t[1] + info[on].t[0] - v;
            int c = getOther(v, a, b);
            int d = getOther(u, a, b);
            edges[ptre++] = {perm[i], a};
            edges[ptre++] = {perm[i], b};
            edges[ptre++] = {perm[i], c};
            edges[ptre++] = {perm[i], d};
            
            int k = ptre;
            
            vector<int> vctx = {v, u};
            vector<int> vctz = {c, d};
            vector<int> vct = {a, b};
            
            for (int j = 0; j < 2; ++j) {
                int x = vctx[j];
                int z = vctz[j];
                for (int q = 0; q < 2; ++q) {
                    int id = getId(x, vct[q], z);
                    triangles[ptr++] = {k - 2 + j, k - 4 + q, id};
                    g[x * 3 + q] = ptr - 1;
                    change(id, x, ptr - 1, 2);
                    change(k - 4 + q, -1, ptr - 1, 1);
                    change(k - 2 + j, -1, ptr - 1, 0);
                }
            }
            
            qu.push(getId(v, a, c));
            qu.push(getId(v, c, b));
            qu.push(getId(u, a, d));
            qu.push(getId(u, b, d));
        }
        
        common = perm[i];
        legalize();
    }
    
    vector<array<int, 2>> ee;
    for (int v = 0; v < ptr; ++v) {
        if (g[v * 3] != -1) {
            continue;
        }
        for (int z = 0; z < 3; ++z) {
            int j = triangles[v].e[z];
            int u = edges[j].first, v = edges[j].second;
            if (u < 0 || v < 0) {
                continue;
            }
            ee.pb({p[u].id, p[v].id});
        }
    }
    return ee;
}

const int MAXN = 2e5 + 100;

int dsu_p[MAXN], dsu_sz[MAXN];

int dsu_get(int v) {
    return v == dsu_p[v] ? v : dsu_p[v] = dsu_get(dsu_p[v]);
}

bool join(int u, int v) {
    u = dsu_get(u); v = dsu_get(v);
    if (u == v) return false;
    if (dsu_sz[u] < dsu_sz[v]) swap(u, v);;
    dsu_sz[u] += dsu_sz[v];
    dsu_p[v] = u;
    return true;
}

signed main() {
    ios_base::sync_with_stdio(false);
    cin.tie(0);

    int n;
    cin >> n;
    vector<array<int, 2>> pt(n);
    vector<int> r(n);
    for (int i = 0; i < n; ++i) {
        cin >> pt[i][0] >> pt[i][1] >> r[i];
    }

    auto res = solve(pt);

    auto get_len = [&](int i, int j) {
        int dx = (pt[i][0] - pt[j][0]);
        int dy = (pt[i][1] - pt[j][1]);
        return dx * dx + dy * dy - r[i] * r[i] - r[j] * r[j];
    };

    sort(res.begin(), res.end(), [&](array<int, 2> a, array<int, 2> b) {
        return get_len(a[0], a[1]) < get_len(b[0], b[1]);
    });

    iota(dsu_p, dsu_p + n, 0);
    fill(dsu_sz, dsu_sz + n, 1);

    cout << "YES\n";
    for (auto elem : res) {
        if (join(elem[0], elem[1])) {
            cout << pt[elem[0]][0] << " " << pt[elem[0]][1] << " ";
            cout << pt[elem[1]][0] << " " << pt[elem[1]][1] << "\n";
        }
    }

    return 0;
}