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)
		}
		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<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);
}

C++: #include <iostream>
#include <cmath>

using namespace std;

void swap(double &x, double &y, double &xx, double &yy) 
{
  double tmp_x = x;
  double tmp_y = y;
  x = xx;
  y = yy;
  xx = tmp_x;
  yy = tmp_y;
}

bool isZero(double x) 
{
  return x < 0.00001;
}

void compute(double x1, double y1, double x2, double y2, double x3, double y3, double x4, double y4) 
{
  if (x1 > x2)
    swap(x1, y1, x2, y2);
  else if (x1 == x2 && y1 > y2)
    swap(x1, y1, x2, y2);
  if (x3 > x4)
    swap(x3, y3, x4, y4);
  else if (x3 == x4 && y3 > y4)
    swap(x3, y3, x4, y4);

  double diff_x12 = x2 - x1;
  double diff_y12 = y2 - y1;
  double diff_x34 = x4 - x3;
  double diff_y34 = y4 - y3;

  if (isZero(diff_x12) && isZero(diff_y12))
    cout << "NO" << endl;
  else if (isZero(diff_x34) && isZero(diff_y34))
    cout << "NO" << endl;  
  else if (!isZero(diff_x12) && !isZero(diff_x34)) {
    double ab = diff_y12 / diff_x12;
    double cd = diff_y34 / diff_x34;
    if (isZero(abs(ab - cd)))
      cout << "YES" << endl;
    else
      cout << "NO" << endl;
  }
  else if (isZero(diff_x12) && isZero(diff_x34)) 
    cout << "YES" << endl;  
  else
    cout << "NO" << endl;  
}

int main(void) 
{
  int n;
  cin >> n;
  for (int i=0; i < n; i++) {
    double x1, y1, x2, y2, x3, y3, x4, y4;
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> x4 >> y4;

    //cout << x1 << " " << y1 << " " << x2 << " " << y2 << " " << x3 << " " << y3 << " " << x4 << " " << y4;
    

    compute(x1, y1, x2, y2, x3, y3, x4, y4);
  }
  
  return 0;
}

C++: #include <iostream>
#include <complex>
using namespace std;

int main(){
  int n;
  cin >> n;

  for(int i=0;i<n;i++){
    complex<double> v[4];
    for(int j=0;j<4;j++){
      double x,y;
      cin >> x >> y;
      v[j]=complex<double>(x,y);
    }

    if((conj(v[1]-v[0])*(v[3]-v[2])).imag()==0)
      cout << "YES" << endl;
    else
      cout << "NO" << endl;
  }

  return 0;
}