#include <bits/stdc++.h>
#define endl '\n'
#define int long long
#define x first
#define y second
using namespace std;
typedef pair<int, int> PII;
typedef pair<double, double> PDD;

tuple<int, int, int> dir(PII a, PII b) {
    tuple<int, int, int> res = { b.x - a.x, b.y - a.y, 0 };
    auto &[dx, dy, k] = res;
    if ( dx == 0 && dy == 0 ) return res;
    k = __gcd( abs(dx), abs(dy) );
    dx /= k, dy /= k;
    return res;
}

int check( tuple<int, int, int> d1, tuple<int, int, int> d2 ) {
    auto &[dx1, dy1, k1] = d1;
    auto &[dx2, dy2, k2] = d2;
    if ( dx1 == dx2 && dy1 == dy2 ) {
        if ( k1 * 2 < k2 ) return 1;
        else if ( k1 < k2 ) return 2;
        else return 0;
    }
    return 0;
}

int cymbal(PII a, PII b, PII c) {
    return abs( a.x * ( b.y - c.y ) + b.x * ( c.y - a.y ) + c.x * ( a.y - b.y ) );
}

double cymbal(PDD a, PDD b, PDD c) {
    return abs( a.x * ( b.y - c.y ) + b.x * ( c.y - a.y ) + c.x * ( a.y - b.y ) );
}

PDD cabbagea( PII p1, PII p2, tuple<int, int, int> d, int s ) {
    auto &[dx, dy, k] = d;
    PDD pp1 = { p1.x, p1.y }, pp2 = { p2.x, p2.y };
    double l = 0, r = k;
 PDD res;
    while (r-l>=0.00000001) {
        double m = ( l + r ) / 2;
         res = { (double)p2.x + m * dx, (double)p2.y + m * dy };
        double dist = cymbal(pp1, pp2, res) * 2 - s;
        if ( abs(dist) < 1e-5 ) return res;
        else if ( dist > 0 ) r = m-0.000000001;
        else l = m;
    }
    return res;
}

void solve() {
    PII p1, p2, p3, p;
    cin >> p1.x >> p1.y >> p2.x >> p2.y >> p3.x >> p3.y >> p.x >> p.y;
    auto d12 = dir(p1, p2), d13 = dir(p1, p3), d23 = dir(p2, p3);
    auto d21 = dir(p2, p1), d31 = dir(p3, p1), d32 = dir(p3, p2);
    cout << fixed << setprecision(12);
    if ( p == p1 ) {
        cout << ( p2.x + p3.x ) * 0.5 << ' ' << ( p2.y + p3.y ) * 0.5 << endl;
    } else if ( p == p2 ) {
        cout << ( p1.x + p3.x ) * 0.5 << ' ' << ( p1.y + p3.y ) * 0.5 << endl;
    } else if ( p == p3 ) {
        cout << ( p1.x + p2.x ) * 0.5 << ' ' << ( p1.y + p2.y ) * 0.5 << endl;
    } else if ( p.x * 2 == p1.x + p2.x && p.y * 2 == p1.y + p2.y ) {
        cout << p3.x << ' ' << p3.y << endl;
    } else if ( p.x * 2 == p1.x + p3.x && p.y * 2 == p1.y + p3.y ) {
        cout << p2.x << ' ' << p2.y << endl;
    } else if ( p.x * 2 == p2.x + p3.x && p.y * 2 == p2.y + p3.y ) {
        cout << p1.x << ' ' << p1.y << endl;
    } else {
        auto d1p = dir(p1, p), d2p = dir(p2, p);
        int c12 = check(d1p, d12), c13 = check(d1p, d13), c23 = check(d2p, d23);
        if ( c12 == 0 && c13 == 0 && c23 == 0 ) {
            cout << -1 << endl;
            return;
        }
        PDD ans;
        int s = cymbal(p1, p2, p3);
        if ( c12 == 1 ) {
            ans = cabbagea(p, p2, d23, s);
        } else if ( c12 == 2 ) {
            ans = cabbagea(p, p1, d13, s);
        } else if ( c13 == 1 ) {
            ans = cabbagea(p, p3, d32, s);
        } else if ( c13 == 2 ) {
            ans = cabbagea(p, p1, d12, s);
        } else if ( c23 == 1 ) {
            ans = cabbagea(p, p3, d31, s);
        } else if ( c23 == 2 ) {
            ans = cabbagea(p, p2, d21, s);
        }
        cout << ans.x << ' ' << ans.y << endl;
    }
}

signed main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    cout.tie(nullptr);
    int t = 1;
    cin >> t;
    while (t--) solve();
    return 0;
}