//
// Created by 35395 on 2024/10/9.
//
#include<bits/stdc++.h>
using namespace std;
#define int long long
#define fi first
#define se second

using db = double;
const db eps = 1e-9;

int sgn(db x) {
    if(fabs(x) < eps) return 0;
    if(x < 0) return -1;
    return 1;
}

struct Point {
    db x, y;

    Point () {
        x = y = 0;
    }

    Point (db _x, db _y) {
        x = _x, y = _y;
    }

    void input() {
        cin >> x >> y;
    }

    friend inline Point operator-(Point A, Point B) {
        return Point(A.x - B.x, A.y - B.y);
    }

    friend inline Point operator+(Point A, Point B) {
        return Point(A.x + B.x, A.y + B.y);
    }

    friend inline Point operator/(Point A, int t) {
        return Point(A.x / t, A.y / t);
    }

    friend inline db operator*(Point A, Point B) {
        return A.x * B.x + A.y * B.y;
    }

    friend inline db operator^(Point A, Point B) {
        return A.x * B.y - A.y * B.x;
    }
};

struct Line {
    Point s, e;
    Line () {}
    Line (Point _s, Point _e) {
        s = _s;
        e = _e;
    }

    void input() {
        s.input();
        e.input();
    }

    bool PointOnSegment(Point p) {
        return sgn((p - s) ^ (e - s)) == 0 && sgn((p - s) * (p - e)) <= 0;
    }
};

struct Polygon {
    int n;
    vector<Point> p;
    vector<Line> l;

    Polygon () {
        n = 0;
        p.clear();
        l.clear();
    }

    void input() {
        n = 3;
        p.resize(n);
        l.resize(n);
        for(int i = 0; i < n; i++) {
            p[i].input();
        }
        for(int i = 0; i < n; i++) {
            l[i] = Line(p[i], p[(i + 1) % n]);
        }
    }

    db area() {
        db ans = 0;
        for(int i = 2; i < n; i++) {
            ans += (p[i] - p[0]) ^ (p[i - 1] - p[0]);
        }
        return fabs(ans) / 2;
    }
};

db area(Point a, Point b, Point c) {
    db ans = 0;
    ans += (c - a) ^ (b - a);
    ans /= 2;
    return fabs(ans);
}

void solve() {
    Polygon poly;
    poly.input();
    Point p;
    p.input();

    int cnt = 0;
    Line l1, l2;
    for(auto l: poly.l) {
        if(l.PointOnSegment(p)) {
            cnt++;
            l1 = l;
        } else {
            l2 = l;
        }
    }

    if(cnt == 0) {
        cout << "-1\n";
        return;
    }

    if(cnt == 2) {
        for(auto l: poly.l) {
            if(!l.PointOnSegment(p)) {
                Point x = (l.s + l.e) / 2;
                cout << x.x << ' ' << x.y << '\n';
                return;
            }
        }
    }

    int idx, g;
    for(int i = 0; i < 3; i++) {
        if(!l1.PointOnSegment(poly.p[i])) {
            idx = i;
            break;
        }
    }

    db mj = poly.area() / 2;
    if(area(poly.p[idx], poly.p[(idx + 1) % 3], p) < mj) {
        g = (idx - 1 + 3) % 3;
    } else {
        g = (idx + 1) % 3;
    }

    if(poly.p[g].x != poly.p[idx].x) {
        bool flag = false;
        if(poly.p[g].x > poly.p[idx].x) {
            flag = true;
        }
        db l = min(poly.p[g].x, poly.p[idx].x), r = max(poly.p[g].x, poly.p[idx].x);
        Point ans;
        while(r - l > eps) {
            db mid = (l + r) / 2;
            Point o;
            o.x = mid;
            o.y = poly.p[g].y - (poly.p[g].y - poly.p[idx].y) * (poly.p[g].x - mid) / (poly.p[g].x - poly.p[idx].x);
            ans = o;
            if(sgn(area(o, p, poly.p[g]) - mj) >= 0) {
                if(flag) {
                    l = mid;
                } else {
                    r = mid;
                }
            } else {
                if(flag) {
                    r = mid;
                } else {
                    l = mid;
                }
            }
        }
        cout << ans.x << ' ' << ans.y << '\n';
    } else {
        bool flag = false;
        if(poly.p[g].y > poly.p[idx].y) {
            flag = true;
        }
        db l = min(poly.p[g].y, poly.p[idx].y), r = max(poly.p[g].y, poly.p[idx].y);
        Point ans;
        while(r - l > eps) {
            db mid = (l + r) / 2;
            Point o;
            o.y = mid;
            o.x = poly.p[g].x - (poly.p[g].x - poly.p[idx].x) * (poly.p[g].y - mid) / (poly.p[g].y - poly.p[idx].y);
            ans = o;
            if(sgn(area(o, p, poly.p[g]) - mj) >= 0) {
                if(flag) {
                    l = mid;
                } else {
                    r = mid;
                }
            } else {
                if(flag) {
                    r = mid;
                } else {
                    l = mid;
                }
            }
        }
        cout << ans.x << ' ' << ans.y << '\n';
    }
}

signed main() {
    ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);
    cout << fixed << setprecision(10);
    int T = 1;
    cin >> T;
    while(T--) {
        solve();
    }
    return 0;
}