#include <bits/stdc++.h>
using namespace std;
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)

class Point {
public:
	double x, y;
	Point(double x = 0.0, double y = 0.0) :
			x(x), y(y) {
	}

	Point operator +(Point p) {
		return Point(x + p.x, y + p.y);
	}
	Point operator -(Point p) {
		return Point(x - p.x, y - p.y);
	}
	Point operator *(double k) {
		return Point(x * k, y * k);
	}
	Point operator /(double k) {
		return Point(x / k, y / k);
	}

	double norm() {
		return x * x + y * y;
	}
	double abs() {
		return sqrt(norm());
	}

	bool operator <(Point p) {
		return x != p.x ? x < p.x : y < p.y;
	}
	bool operator ==(Point p) {
		return equals(x, p.x) && equals(y, p.y);
	}
};
typedef Point Vector;

class Segment {
public:
	Point p1, p2;
	Segment(Point p1 = Point(), Point p2 = Point()) :
			p1(p1), p2(p2) {
	}
};
typedef Segment Line;

double dot(Vector v1, Vector v2) {
	return v1.x * v2.x + v1.y * v2.y;
}
double cross(Vector v1, Vector v2) {
	return v1.x * v2.y - v1.y * v2.x;
}
bool isOrthogonal(Vector v1, Vector v2) {
	return equals(dot(v1, v2), 0.0);
}
bool isOrthogonal(Segment s1, Segment s2) {
	return equals(dot(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
bool isOrthogonal(Point l1, Point l2, Point m1, Point m2) {
	return isOrthogonal(l2 - l1, m2 - m1);
}
bool isParallel(Vector v1, Vector v2) {
	return equals(cross(v1, v2), 0.0);
}
bool isParallel(Segment s1, Segment s2) {
	return equals(cross(s1.p2 - s1.p1, s2.p2 - s2.p1), 0.0);
}
bool isParallel(Point l1, Point l2, Point m1, Point m2) {
	return isParallel(l1 - l2, m1 - m2);
}

enum PositionSP {
	COUNTER_CLOCKWISE = -1,
	CLOCKWISE = 1,
	ONLINE_BACK = 2,
	ONLINE_FRONT = -2,
	ON_SEGMENT = 0
};
PositionSP ccw(Point p1, Point p2, Point p) {
	Vector a = p2 - p1, b = p - p1;
	if (cross(a, b) > EPS)
		return COUNTER_CLOCKWISE;
	else if (cross(a, b) < -EPS)
		return CLOCKWISE;
	else if (dot(a, b) < -EPS)
		return ONLINE_BACK;
	else if (a.norm() < b.norm())
		return ONLINE_FRONT;
	else
		return ON_SEGMENT;
}
bool intersect(Point p1, Point p2, Point p3, Point p4) {
	return (ccw(p1, p2, p3) * ccw(p1, p2, p4) <= 0
			&& ccw(p3, p4, p1) * ccw(p3, p4, p2) <= 0);
}
bool intersect(Segment s1, Segment s2) {
	return intersect(s1.p1, s1.p2, s2.p1, s2.p2);
}
Point intersection(Segment s1, Segment s2) {
	double d1 = abs(cross(s2.p2 - s2.p1, s1.p1 - s2.p1));
	double d2 = abs(cross(s2.p1 - s2.p2, s1.p2 - s2.p2));
	return s1.p1 + (s1.p2 - s1.p1) * d1 / (d1 + d2);
}

double distancePP(Point p1, Point p2) {
	return (p1 - p2).abs();
}
double distanceLP(Line l, Point p) {
	return abs(cross(l.p2 - l.p1, p - l.p1) / distancePP(l.p2, l.p1));
}
double distanceSP(Segment s, Point p) {
	if (dot(s.p2 - s.p1, p - s.p1) < 0.0)
		return distancePP(s.p1, p);
	else if (dot(s.p1 - s.p2, p - s.p2) < 0.0)
		return distancePP(s.p2, p);
	else
		return distanceLP(s, p);
}
double distanceSS(Segment s1, Segment s2) {
	if (intersect(s1, s2))
		return 0.0;
	else {
		return min(min(distanceSP(s1, s2.p1), distanceSP(s1, s2.p2)),
				min(distanceSP(s2, s1.p1), distanceSP(s2, s1.p2)));
	}
}

int main() {
	int q;
	cin >> q;
	for (int i = 0; i < q; i++) {
		Segment s1, s2;
		cin >> s1.p1.x >> s1.p1.y;
		cin >> s1.p2.x >> s1.p2.y;
		cin >> s2.p1.x >> s2.p1.y;
		cin >> s2.p2.x >> s2.p2.y;
		Point x = intersection(s1, s2);
		cout << fixed << setprecision(10) << x.x << " " << x.y << endl;
	}
	return 0;
}



Measured memory_bytes: 3244