#include<iostream>
#include<fstream>
#include<sstream>
#include<string>
#include<cstdio>
#include<cstdlib>
#include<cstring>
#include<ctime>
#include<stack>
#include<queue>
#include<set>
#include<map>
#include<vector>
#include<list>
#include<algorithm>
#include<utility>
#include<complex>
#include<vector>
#include<algorithm>
#include<complex>
#include<map>
#include<math.h>
using namespace std;
namespace geo{

	typedef complex<double> P;
	typedef vector<P> Poly;
	const double eps = 1e-10;
	typedef pair<P, P> Line;
	typedef pair<P, double> Circle;
#define mp(a,b) make_pair(a,b)

	//?????????????????????????????????????????¨???
	inline void x(P& p, double n){ p.real(n); }
	inline void y(P& p, double n){ p.imag(n); }
	inline double x(P& p){ return p.real(); }
	inline double y(P& p){ return p.imag(); }

	//????????????a??¨b?????????
	inline double dot(const P a, const  P b){//A dot B
		return a.real()*b.real() + a.imag()*b.imag();
	}

	//????????????a??¨b?????????
	inline double cross(const P a, const P b){//A cross B
		return a.real()*b.imag() - a.imag()*b.real();
	}


	// ??´???l??¨???p??¨????????¢
	inline double distance_line(P p, Line l) {
		auto c = p;
		auto a = l.first;
		auto b = l.second;
		return abs(cross(b - a, c - a)) / abs(b - a);
	}
	// ??????l??¨???p??¨????????¢
	inline double distance_line_segment(P p, Line l) {
		auto a = l.first;
		auto b = l.second;
		auto c = p;
		if (dot(b - a, c - a) < eps) return abs(c - a);
		if (dot(a - b, c - b) < eps) return abs(c - b);
		return abs(cross(b - a, c - a)) / abs(b - a);
	}

	//??´???l,q???????????????(????????????false)
	inline bool isintersected_line(Line p, Line q){
		return (abs(cross(p.first - p.second, q.first - q.second))>eps);
	}

	// ?????????????????¨??????????????????????????????????????????
	int comp(const P &l, const P &r){
		if (l.real() == r.real())
			return(l.imag() < r.imag());
		return(l.real() < r.real());
	}

	// ??????p??????????????????????¨?????????§Poly???????´?
	// Poly p : ?????¨????????????
	// ???????????§O(nlogn)
	inline Poly convex_hull(Poly& p){
		int n = (int)p.size();
		Poly res(2 * n);
		int k = 0, t;
		sort(p.begin(), p.end(), comp);
		for (int i = 0; i < n; i++){
			while (k > 1 && (cross(res[k - 1] - res[k - 2], p[i] - res[k - 1]) < eps))k--;
			res[k++] = p[i];
		}
		t = k;
		for (int i = n - 2; i >= 0; i--){
			while (k > t && (cross(res[k - 1] - res[k - 2], p[i] - res[k - 1]) < eps))k--;
			res[k++] = p[i];
		}
		res.resize(k - 1);
		return res;
	}


	// ???p?????????????????¨????????¨????????????true
	// Poly l : ???????¨????????????????,????????°n
	// P p    : ???????????????????????????
	// ?????¨??§????????¢?´¢ O(log n)
	inline bool convex_in(const Poly& l, const P& p){
		int a = 0, b = (int)l.size(), c;
		double A, C;
		const P g = (l[a] + l[b - 1] + l[b / 2]) / 3.0;
		while (b - a > 1){
			c = (a + b) / 2;
			A = cross(l[a] - g, p - l[a]);
			C = cross(l[c] - g, p - l[c]);
			if (cross(l[a] - g, l[c] - g) >= 0){
				if (A > -eps&&C < -eps)b = c;
				else a = c;
			}
			else {

				if (C < -eps || A > -eps)b = c;
				else a = c;
			}
		}
		return(cross(l[b%l.size()] - l[a], p - l[b%l.size()]) > -eps);
	}


	// ??????l?????¢????????????
	// Poly l : ???????¨????????????????,????????°n
	// O(n)
	inline double convex_area(const Poly& l){
		double res = 0;
		int n = (int)l.size();
		for (int i = 2; i < n; i++)
			res += (abs(cross(l[i - 1] - l[0], l[i] - l[i - 1]))) / 2.0;
		return res;
	}

	//???p????????????c?????\?????????????±?????????????
	inline vector<Line> tangent_line(Circle c, P p){
		vector<Line> res;
		P Mp = c.first;
		double r = c.second;
		P v = p - Mp, e;
		double dist = abs(v);
		if (dist > r + eps){
			double _cos = r / dist;
			double _sin = sqrt(1.0 - _cos*_cos);
			v *= r / dist;
			x(e, _cos*x(v) - _sin*y(v));
			y(e, _sin*x(v) + _cos*y(v));
			res.push_back(mp(p, Mp + e));
			x(e, _cos*x(v) + _sin*y(v));
			y(e, -_sin*x(v) + _cos*y(v));
			res.push_back(mp(p, Mp + e));
		}

		return res;
	}

	//2????????±????????´??\???????±???????
	inline vector<Line> inner_common_tangent_line(Circle p, Circle q){
		vector<Line> res;
		P Mp = p.first, Mq = q.first;
		double Rp = p.second, Rq = q.second;
		double dist = abs(Mp - Mq);
		if (dist > Rp + Rq + eps){
			P mid = (Rp*Mq + Rq*Mp) / (Rp + Rq);
			res = tangent_line(p, mid);
		}

		return res;
	}

	//2????????±????????´??\???????±???????
	inline vector<Line> outer_common_tangent_line(Circle p, Circle q){
		vector<Line> res;
		P Mp = p.first, Mq = q.first;
		double Rp = p.second, Rq = q.second;
		P v = Mp - Mq;
		double dist = abs(v);
		if (dist > Rp - Rq + eps){
			if (abs(Rp - Rq) < eps){
				P e = v*P(0, 1);
				e /= dist;
				res.push_back(mp(Mp + e, Mq + e));
				res.push_back(mp(Mp - e, Mq - e));
			}
			else{
				P mid = Mp + (Mq - Mp) * Rp / (Rp - Rq);
				res = tangent_line(p, mid);
			}
		}
		return res;
	}

}


int main(){
	int n;
	cin >> n;
	for (int i = 0; i < n; i++){
		double a, b, c, d;
		cin >> a >> b >> c >> d;
		geo::P p(a, b), q(c, d);
		geo::Line l1 = mp(p, q);
		cin >> a >> b >> c >> d;
		geo::P s(a, b), t(c, d);
		geo::Line l2 = mp(s, t);
		if (geo::isintersected_line(l1, l2) == false)cout << "YES" << endl;
		else cout << "NO" << endl;
	}
	return(0);
}