Go: package main

import "fmt"

func main() {
	var x1, x2, x3, y1, y2, y3, xp, yp float64
	for {
		v, _ := fmt.Scanf("%f %f %f %f %f %f %f %f", &x1, &y1, &x2, &y2, &x3, &y3, &xp, &yp)
		// println(x1, x2, x3, y1, y2, y3, xp, yp)
		if v != 8 {
			break
		}
		ok1 := true
		ok2 := true
		if (x2-x1)*(yp-y1)-(xp-x1)*(y2-y1)<0 {
			ok1 = false
		} else {
			ok2 = false
		}
		if (x3-x2)*(yp-y2)-(xp-x2)*(y3-y2)<0 {
			ok1 = false
		} else {
			ok2 = false
		}
		if (x1-x3)*(yp-y3)-(xp-x3)*(y1-y3)<0 {
			ok1 = false
		} else {
			ok2 = false
		}
		if ok1 || ok2 {
			fmt.Println("YES")
		} else {
			fmt.Println("NO")
		}
	}
}

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

#define rep(i,n) for(int i=0; i<n; i++)
#define swap(a,b) tmp=ver[b], ver[b]=ver[a], ver[a]=tmp;
int main(){
	double x1, y1, x2, y2, x3, y3, xp, yp;
	double p, q, r;
	while(cin>>x1>>y1>>x2>>y2>>x3>>y3>>xp>>yp){
		p=(x2-x1)*(yp-x1)-(y2-y1)*(xp-x1);
		q=(x3-x2)*(yp-x2)-(y3-y2)*(xp-x2);
		r=(x1-x3)*(yp-x3)-(y1-y3)*(xp-x3);
		if(p*q>0 && q*r>0 && r*p>0){
			cout << "YES" << endl;
		}
		else {
			cout << "NO" << endl;
		}
	}
	return 0;
}

C++: #include<iostream>
#include<cstdio>
#include<algorithm>
#include<cmath>
#include<vector>
#include<iomanip>
using namespace std;
#define EPS (1e-10)
#define equals(a, b) (fabs((a) - (b)) < EPS)

class Point{
	public:
		double x, y;

		Point(double x = 0, double y = 0): x(x), y(y) {}

		Point operator + (Point p){ return Point(x + p.x, y + p.y);}
		Point operator - (Point p){ return Point(x - p.x, y - p.y);}
		Point operator * (double a){ return Point(a * x, a * y);}
		Point operator / (double a){ return Point(x / a, y / a);}

		double abs(){ return sqrt(norm());}
		double norm(){ return x * x + y * y;}

		bool operator < (const Point &p) const{
			return x != p.x ? x < p.x : y < p.y;
		}

		bool operator == (const Point &p) const{
			return fabs(x - p.x) < EPS && fabs(y - p.y) < EPS;
		}
};

struct Segment {
	Point p1, p2;
};
typedef Segment Line;

class Circle{
	public:
		Point c;
		double r;
		Circle(Point c = Point(), double r = 0.0): c(c), r(r) {}
};

typedef Point Vector;
typedef vector<Point> Polygon;

double dot(Vector a, Vector b){
	return a.x * b.x + a.y * b.y;
}
double cross(Vector a, Vector b){
	return a.x * b.y - a.y * b.x;
}

int contains(Polygon g, Point p){
	int n = g.size();
	bool x = false;
	for(int i = 0; i < n; i++){
		Point a = g[i] - p, b = g[(i + 1) % n] - p;
		if(abs(cross(a, b)) < EPS && dot(a, b) < EPS) return 1;
		if(a.y > b.y) swap(a, b);
		if(a.y < EPS && EPS < b.y && cross(a, b) > EPS) x = !x;
	}
	return (x ? 2 : 0);
}

int main(){
	int n;
	Polygon g(3); Point p;
	for(;;){
		if(!(cin >> g[0].x)) break;
		cin >> g[0].y;
		for(int i = 1; i < 3; i++){
			cin >> g[i].x >> g[i].y;
		}
		cin >> p.x >> p.y;
		if(contains(g, p) == 2) cout << "YES" << endl;
		else cout << "NO" << endl;
	}
	return 0;
}

C++: #include <iostream>
using namespace std;
int isintersecter(double x1,double y1,double x2,double y2,double px,double py,
		  double qx,double qy){
  if(((py-y1)*(x1-x2)-(y1-y2)*(px-x1))*((qy-y1)*(x1-x2)-(y1-y2)*(qx-x1)) < 0)return 1;
  else return 0;
}
int main(){
  double x1,y1,x2,y2,x3,y3,xp,xy;
  while(cin>>x1>>y1>>x2>>y2>>x3>>y3>>xp>>xy)
    {
      if(isintersecter(x1,y1,x2,y2,x3,y3,xp,xy) || 
	 isintersecter(x2,y2,x3,y3,x1,y1,xp,xy) || 
	 isintersecter(x1,y1,x3,y3,x2,y2,xp,xy) )cout << "NO" << endl;
      else cout << "YES" << endl;
    }
}

C++: #include <bits/stdc++.h>
#define r(i,n) for(int i=0;i<n;i++)
using namespace std;
int main(){
  double a[3],b[3],c,d,e,f,x,y;
  while(cin>>a[0]>>a[1]>>a[2]>>b[0]>>b[1]>>b[2]>>c>>d){
    sort(a,a+3);sort(b,b+3);
    if(a[0]<c&&c<a[2]&&b[0]<d&&d<b[2])cout<<"YES"<<endl;
    else cout<<"NO"<<endl;
  }
}

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

struct TCoordinate
{
	double x;
	double y;
};

bool IsSameSide(TCoordinate T1, TCoordinate T2, TCoordinate L1, TCoordinate L2)
{
	if(L1.x == L2.x){
		if((T1.x - L1.x) * (T2.x - L2.x) > 0){
			return true;
		}else{
			return false;
		}
	}else{
		if(((L2.x - L1.x) * (T1.y - L1.y) - (L2.y - L1.y) * (T1.x - L1.x)) * ((L2.x - L1.x) * (T2.y - L1.y) - (L2.y - L1.y) * (T2.x - L1.x)) > 0){
			return true;
		}else{
			return false;
		}
	}
}

int main()
{
	while(true){
		TCoordinate A1, A2, A3, Ap;
		cin >> A1.x >> A1.y >> A2.x >> A2.y >> A3.x >> A3.y >> Ap.x >> Ap.y;
		if(cin.eof() == true) break;
		if(IsSameSide(A3, Ap, A1, A2) && IsSameSide(A1, Ap, A2, A3) && IsSameSide(A2, Ap, A3, A1)){
			cout << "YES" << endl;
		}else{
			cout << "NO" << endl;
		}
	}
	return 0;
}

C++: #include <cstdio>
#include <cmath>
#include <utility>
using namespace std;

#define x first
#define y second

struct vector { double x, y, l; };

int main()
{
    pair<double, double> p[4];

    while (~scanf("%lf %lf", &p->x, &p->y)){
        vector v[3];
        double angle[3];

        for (int i = 1; i < 4; i++) scanf("%lf %lf", &p[i].x, &p[i].y);
        for (int i = 0; i < 3; i++){
            v[i].x = p[i].x - p[3].x;
            v[i].y = p[i].y - p[3].y;
            v[i].l = sqrt(v[i].x * v[i].x + v[i].y * v[i].y);
        }
        for (int i = 0; i < 3; i++){
            double product = v[i].x * v[(i + 1) % 3].x + v[i].y * v[(i + 1) % 3].y;
            angle[i] = acos(product / v[i].l / v[(i + 1) % 3].l);
        }

        if (angle[0] + angle[1] + angle[2] == 2 * M_PI){
            puts("YES");
        }
        else {
            puts("NO");
        }
    }

    return 0;
}