Go: package main

import (
	"bufio"
	"os"
	"strconv"
	"fmt"
	"strings"
)

var scanner = bufio.NewScanner(os.Stdin)

func nextInt() int {
	scanner.Scan()
	i, e := strconv.Atoi(scanner.Text())
	if e != nil {
		panic(e)
	}
	return i
}

func main() {
	n := nextInt()
	for i := 0; i < n; i++ {
		scanner.Scan()
		points := strings.Split(scanner.Text(), " ")
		fpoints := make([]float64, 0)
		for _, v := range points {
			tmp, _ := strconv.ParseFloat(v, 64)
			fpoints = append(fpoints, tmp)
		}
		if fpoints[0] == fpoints[2] && fpoints[4] == fpoints[6] {
			fmt.Println("YES")
		} else {
			a := (fpoints[1] - fpoints[3]) / (fpoints[0] - fpoints[2])
			b := (fpoints[5] - fpoints[7]) / (fpoints[4] - fpoints[6])
			if a == b {
				fmt.Println("YES")
			} else {
				fmt.Println("NO")
			}
		}
	}
}

C++: #include <iostream>
#include <fstream>
#include <typeinfo>
#include <vector>
#include <cmath>
#include <set>
#include <map>
#include <string>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <iomanip>
#include <cctype>
#define syosu(x) fixed<<setprecision(x)
using namespace std;
typedef long long ll;
typedef pair<int,int> P;
typedef pair<double,double> pdd;
typedef vector<int> vi;
typedef vector<vi> vvi;
typedef vector<char> vc;
typedef vector<vc> vvc;
typedef vector<bool> vb;
typedef vector<vb> vvb;
typedef vector<P> vp;
typedef vector<vp> vvp;
typedef pair<int,P> pip;
typedef vector<pip> vip;
const int inf=1<<25;
const double pi=acos(-1);
const double eps=1e-10;
const vi emp;

double add_double(double a,double b){
	if(abs(a+b)<eps*(abs(a)+abs(b))) return 0;
	return a+b;
}

struct point{
	double x,y;
	point operator+(point p){
		return point{add_double(x,p.x),add_double(y,p.y)};
	}
	point operator-(point p){
		return point{add_double(x,-p.x),add_double(y,-p.y)};
	}
	point operator*(double p){
		return point{x*p,y*p};
	}
	point operator/(double p){
		if(!p) return point{0,0}; 
		return point{x/p,y/p};
	}
	bool operator==(point p){
		return fabs(add_double(x,-p.x))<eps&&fabs(add_double(y,-p.y))<eps;
	}
	bool operator<(point p){
		if(fabs(x-p.x)>eps) return x<p.x;
		return y<p.y;
	}
};

typedef pair<point,point> pp;
typedef vector<point> VP;
const point O{0,0};

class Geom{
	public:
	double Length(point x,point y){
		point z=y-x;
		return sqrt(z.x*z.x+z.y*z.y);
	}
	double IP(point p,point q){
		return p.x*q.x+p.y*q.y;
	}
	double CP(point p,point q){
		return p.x*q.y-q.x*p.y;
	}
	string Counter_Clockwise(pp a,point x){
		point A=a.second-a.first;
		point X=x-a.first;
		double ip=IP(A,X),cp=CP(A,X),Al=Length(O,A),Xl=Length(O,X);
		if(cp>eps) return "Counter_Clockwise";
		if(cp<-eps) return "Clockwise";
		if(ip<-eps) return "Online_Back";
		if(Xl<Al||fabs(Xl-Al)<eps) return "On_Segment";
		return "Online_Front";
	}
	string Parallel_Orthogonal(pp a,pp b){
		point A=a.second-a.first,B=b.second-b.first;
		double ip=IP(A,B),cp=CP(A,B);
		string f=Counter_Clockwise(pp(a.first,a.second),b.first),s=Counter_Clockwise(pp(a.first,a.second),b.second);
		if(f[0]!='C'&&s[0]!='C') return "Agreement";
		if(fabs(cp)<eps) return "Parallel";
		if(fabs(ip)<eps) return "Orthogonal";
		else return "Commonly";
	}
	void Point_in(point& p){
		cin>>p.x>>p.y;
	}
};

int n;
VP p(4);
string s;

int main(){
	Geom geo;
	cin>>n;
	for(int i=0;i<n;i++){
		for(VP::iterator j=p.begin();j!=p.end();j++) geo.Point_in(*j);
		s=geo.Parallel_Orthogonal(pp(p[0],p[1]),pp(p[2],p[3]));
		if(s[0]=='P'||s[0]=='A') cout<<"YES"<<endl;
		else cout<<"NO"<<endl;
	}
}

C++: #include <bits/stdc++.h>
using namespace std;

#define x() real()
#define y() imag()
#define EPS (1e-8)
#define INF (1e12)
#define SQ(a) ((a) * (a))
#define EQ(a, b) (abs((a) - (b)) < EPS)
#define EQV(a, b) (EQ((a).x(), (b).x()) && EQ((a).y(), (b).y()))
#define MP make_pair
const int COUNTER_CLOCKWISE = 1;
const int CLOCKWISE = -1;
const int ONLINE_BACK = 2;
const int ONLINE_FRONT = -2;
const int ON_SEGMENT = 0;
enum {OUT, ON, IN};

typedef double D;
typedef complex<D> P;
typedef P V;
namespace std {
	bool operator < (const P& a, const P& b){
		if (a.x() != b.x()) return a.x() < b.x();
		return a.y() < b.y();
	}
}
struct S{
	P p1, p2;
	S(){}
	S(P p1, P p2): p1(p1), p2(p2){}
};
typedef S L;
typedef S PP;
struct C{
	P p;
	D r;
	C(){}
	C(P p, D r): p(p), r(r){}
};
typedef vector<P> G;

D norm(P a){
	return SQ(a.x()) * SQ(a.y());
}
D dot(P a, P b){
	return a.x() * b.x() + a.y() * b.y();
}
D cross(P a, P b){
	return a.x() * b.y() - a.y() * b.x();
}
bool orthogonal(L a, L b){
	return EQ( dot(a.p1 - a.p2, b.p1 - b.p2), 0.0 );
}
bool parallel(L a, L b){
	return EQ( cross(a.p1 - a.p2, b.p1 - b.p2), 0.0 );
}
bool PonL(L l, P p){
	return EQ( cross(l.p1 - l.p2, p - l.p2), 0.0 );
}
bool PonS(S s, P p){
	return EQ( cross(s.p1 - s.p2, p - s.p2), 0.0 ) &&
		(dot(s.p1 - s.p2, p - s.p2) > -EPS) &&
		(dot(s.p2 - s.p1, p - s.p1) > -EPS);
}
int ccw(P p0, P p1, P p2){
	P a = p1 - p0;
	P b = p2 - p0;
	if (cross(a, b) > EPS) return COUNTER_CLOCKWISE;
	if (cross(a, b) < -EPS) return CLOCKWISE;
	if (dot(a, b) < -EPS) return ONLINE_BACK;
	if (norm(a) < norm(b)) return ONLINE_FRONT;
	return ON_SEGMENT;
}
bool intersect(S s1, S s2){
	return ccw(s1.p1, s1.p2, s2.p1) * ccw(s1.p1, s1.p2, s2.p2) <= 0 &&
		ccw(s2.p1, s2.p2, s1.p1) * ccw(s2.p1, s2.p2, s1.p2) <= 0;
}
bool intersect(C c1, C c2){
	return abs(c1.p - c1.p) - (c1.r + c2.r) < EPS;
}
bool intersect(G g1, G g2){
	for (int i = 0; i < g1.size(); i++){
		for (int j = 0; j < g2.size(); j++){
			S s1(g1[i], g1[(i + 1) % g1.size()]);
			S s2(g2[j], g2[(j + 1) % g2.size()]);
			if (intersect(s1, s2)) return true;
		}
	}
	return false;
}
P project(S s, P p){
	V base = s.p2 - s.p1;
	D r = dot(p - s.p1, base) / norm(base);
	return s.p1 + base * r;
}
P reflect(S s, P p){
	return p + (project(s, p) - p) * 2.0;
}
P crossP(S s1, S s2){
	assert(intersect(s1, s2));
	P base = s2.p2 - s2.p1;
	D d1 = abs(cross(base, s1.p1 - s2.p1));
	D d2 = abs(cross(base, s1.p2 - s2.p1));
	D t = d1 / (d1 + d2);
	return s1.p1 + (s1.p2 - s1.p1) * t;
}
PP crossPP(C c, L l){
	P pr = project(l, c.p);
	P e = (l.p2 - l.p1) / abs(l.p2 - l.p1);
	D base = sqrt( SQ(c.r) - norm(pr - c.p) );
	return PP(pr + e * base, pr - e * base);
}
PP crossPP(C c1, C c2){
	D d = abs(c1.p - c2.p);
	D a = acos( SQ(c1.r) + SQ(d) - SQ(c2.r) ) / (2 * c2.r * d);
	D t = arg(c2.p - c1.p);
	return PP( c1.p + polar(c1.r, t + a), c1.p + polar(c1.r, t - a) );
}
int contains(G g, P p){
	int n = g.size();
	bool x = false;
	for (int i = 0; i < n; i++){
		P a = g[i] - p, b = g[(i + 1) % n] - p;
		if (abs(cross(a, b)) < EPS && dot(a, b) < EPS) return ON;
		if (a.y() > b.y()) swap(a, b);
		if (a.y() < EPS && EPS < b.y() && cross(a, b) > EPS) x != x;
	}
	return x ? IN : OUT;
}
G convexHull(G s){
	if (s.size() < 3) return s;
	G u, l;
	sort(s.begin(), s.end());
	u.push_back(s[0]);
	u.push_back(s[1]);
	l.push_back(s[s.size() - 1]);
	l.push_back(s[s.size() - 2]);
	for (int i = 2; i < s.size(); i++){
		for (int n = u.size(); n >= 2 && ccw(u[n - 2], u[n - 1], s[i]) != CLOCKWISE; n--){
			u.pop_back();
		}
		u.push_back(s[i]);
	}
	for (int i = s.size() - 3; i >= 0; i--){
		for (int n = l.size(); n >= 2 && ccw(l[n - 2], l[n - 1], s[i]) != CLOCKWISE; n--){
			l.pop_back();
		}
		l.push_back(s[i]);
	}
	reverse(l.begin(), l.end());
	for (int i = u.size() - 2; i >= 1; i--){
		l.push_back(u[i]);
	}
	return l;
}

int main()
{
	int n;
	D x[4], y[4];
	P p[4];
	
	cin >> n;
	while (n--){
		for (int i = 0; i < 4; i++){
			cin >> x[i] >> y[i];
			p[i] = P(x[i], y[i]);
			//cout << p[i].x() << " " << p[i].y() << endl;
		}
		S s1(p[0], p[1]);
		S s2(p[2], p[3]);
		//cout << cross(s1.p2 - s1.p1, s2.p2 - s2.p1) << endl;
		cout << (parallel(s1, s2) ? "YES" : "NO") << endl;
	}
	
	return 0;
}