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<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-8;
	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 <math.h>
using namespace std;

int main()
{
	double x1, y1, x2, y2, x3, y3, x4, y4;
	double slope_ab, slope_cd;
	int loop;
	int i = 0;

	cin >> loop;

	while(cin>>x1>>y1>>x2>>y2>>x3>>y3>>x4>>y4){

		slope_ab = (y2-y1) / (x2-x1);
		slope_cd = (y4-y3) / (x4-x3);

		if(fabs(slope_ab - slope_cd) < 1.0E-10){
			cout << "YES" << endl;
		}else{
			cout << "NO" << endl;
		}
	}
}

C++: for i in range(input()):
	a,b,c,d,e,f,g,h=map(float,raw_input().split())
	print "YES" if abs((d-b)*(g-e)-(c-a)*(h-f))<1e-9 else "NO"

C++: /*
http://judge.u-aizu.ac.jp/onlinejudge/description.jsp?id=0021&lang=jp
*/

#include<stdio.h>
int main(void)
{
    int n,i;
    double ax,ay,bx,by,cx,cy,dx,dy;
    double slope1,slope2;


    scanf("%d",&n);

    for(i=0;i<n;i++){
        scanf("%lf %lf %lf %lf %lf %lf %lf %lf",&ax,&ay,&bx,&by,&cx,&cy,&dx,&dy);

        slope1=(by-ay)/(bx-ax);
        slope2=(dy-cy)/(dx-cx);

        if(slope1==slope2){
            printf("YES");
        }else{
            printf("NO");
        }
    }
    return 0;
}

C++: #include <iostream>

using namespace std;

const double EPS = 1e-10;

bool ok(double val) {
	return (val >= 0.0 ? val : -val) < EPS;
}

int main() {
	int n;
	cin >> n;
	for (int i = 0; i < n; i++) {
		double x[4], y[4];
		for (int j = 0; j < 4; j++)
			cin >> x[j] >> y[j];
		double xx1 = x[0]-x[1], xx2 = x[2]-x[3];
		double yy1 = y[0]-y[1], yy2 = y[2]-y[3];
		if (ok(xx1*yy2 - xx2*yy1))
			cout << "YES" << endl;
		else
			cout << "NO" << endl;
	}
	return 0;
}