Go: package main

import (
        "fmt"
        "math/big"
)

func main() {
        var x1, x2, x3, x4, y1, y2, y3, y4 big.Float
        var n int
        fmt.Scanf("%d", &n)
        for i := 0; i < n; i++ {
                fmt.Scanf("%f %f %f %f %f %f %f %f",
                        &x1, &y1, &x2, &y2, &x3, &y3, &x4, &y4)
                var lx, ly, mx, my, mul1, mul2, sub, zz big.Float
                lx.Sub(&x2, &x1)
                ly.Sub(&y2, &y1)
                mx.Sub(&x4, &x3)
                my.Sub(&y4, &y3)
                mul1.Mul(&lx, &my)
                mul2.Mul(&ly, &mx)
                sub.Sub(&mul1, &mul2)
                zz.SetFloat64(0.0)

                if sub.Cmp(&zz) == 0 {
                        fmt.Println("YES")
                } else {
                        fmt.Println("NO")
                }
        }
}

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

#define x() real()
#define y() imag()
#define EPS (1e-10)
#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;
}

C++: #include <cstdio>
#include <cstring>
#include <algorithm>
#include <string>
#include <cmath>
#include <stack>
#include <vector>
#include <iostream>


using namespace std;

int main()
{
	int n;
	scanf("%d", &n);
	for (int i = 0; i < n; ++i)
	{
		double x[4], y[4];
		for (int j = 0; j < 4; ++j)
			scanf("%lf %lf", x+j, y+j);

		double dx1 = x[1] - x[0];
		double dy1 = y[1] - y[0];
		double dx2 = x[3] - x[2];
		double dy2 = y[3] - y[2];
		if (dy1/dx1 == dy2/dx2)
			puts("YES");
		else
			puts("NO");
	}

	return 0;
}

C++: #include <stdio.h>
#define EPSIRON (1.0e-10)

int main(void){
    int n;
    double x1, x2, x3, x4, dx1, dx2;
    double y1, y2, y3, y4, dy1, dy2;
    double cp; // cross product
    
    scanf("%d", &n);
    for (int i=0; i<n; i++){
        scanf("%lf %lf %lf %lf", &x1, &y1, &x2, &y2);
        scanf("%lf %lf %lf %lf", &x3, &y3, &x4, &y4);
        dx1 = x2 - x1;
        dy1 = y2 - y1;
        dx2 = x4 - x3;
        dy2 = y4 - y3;
        cp = dx1 * dy2 - dy1 * dx2;
        printf("%s\n", cp < EPSIRON ? "YES" : "NO");
    }
    
    return 0;
}

C++: #include <iostream>
#include <cmath>
#include <vector>
#include <string>
#include <algorithm>
#include <climits>
using namespace std;

int main(){
    double e = 1e-8;
    double x[4];
    double y[4];
    double s;
    double t;
    double u;
    double v;
    double m;
    int n;
    cin >> n;

    for (int t = 0;t < n;++t) {
        for (int i = 0;i < 4;++i){
            cin >> x[i] >> y[i]; 
        }
    }
    s = x[1] - x[0];
    t = y[1] - y[0];
    u = x[3] - x[2];
    v = y[3] - y[2];

    if(s * v - t * u > 0){
        double m = s * v - t * u;
    }
    else{
        double m = t * u - s * v;
    }

    if(m<e){
        cout << "YES" << endl;
    }
//    else{
//        cout << "NO" << endl;
//    }
//    return 0;


    cout << "NO" << endl;
}

C++: #include <iostream>

int main() {
	int n;
	double x1, y1, x2, y2, x3, y3, x4, y4;
	std::cin >> n;

	for (int i = 0; i < n; i++) {
		std::cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4;
		if ((y2 - y1) / (x2 - x1) == (y4 - y3) / (x4 - x3)) {
			std::cout << "YES" << std::endl;
		}
		else {
			std::cout << "NO" << std::endl;
		}
	}





}

C++: #include<vector>
#include<iostream>
#include<cstdio>
using namespace std;
double x1,y1,x2,y2,x3,y3,x4,y4;
int n;
int main(){
    int n;
    scanf("%d",&n);
    for(int i=0;i<n;i++){
      scanf("%lf%lf%lf%lf%lf%lf%lf%lf",&x1,&y1,&x2,&y2,&x3,&y3,&x4,&y4);
      if((y2-y1)/(x2-x1)==(y4-y3)/(x4-x3)) printf("YES\n");
      else printf("NO\n");
    }
}