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 <complex>
#include <cmath>
#include <vector>
#include <cstdio>
#include <iostream>
using namespace std;

typedef complex<double> xy_t;

double dot_product(xy_t a, xy_t b) { return (conj(a)*b).real(); }
double cross_product(xy_t a, xy_t b) { return (conj(a)*b).imag(); }
xy_t projection(xy_t p, xy_t b) { return b*dot_product(p,b)/norm(b); }

int main(){
  double x[4], y[4];
  double pab, pbc, pca;
  while(true){
    for(int i=0; i<4; ++i){
      cin >> x[i] >> y[i];
    }
    if(!cin) break;
    xy_t a(x[0],y[0]), b(x[1],y[1]), c(x[2],y[2]), p(x[3],y[3]);
    pab = cross_product(a-p,b-p) / 2;
    pbc = cross_product(b-p,c-p) / 2;
    pca = cross_product(c-p,a-p) / 2;
    bool ok = ((pab>0) && (pbc>0) && (pca>0)) || ((pab<0) && (pbc<0) && (pca<0));
    cout << (ok ? "YES" : "NO") << endl;
  }
}

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

class Vec{
public:
	double x, y;
	Vec(const double x, const double y) :x(x), y(y){}
	Vec() :x(0), y(0){}
	double cross(const Vec& tgt){
		return (x*tgt.y) - (y*tgt.x);
	}
};

Vec operator - (const Vec& v2, const Vec& v1){
	Vec v(v2.x - v1.x, v2.y - v1.y);
	return v;
}

istream& operator >> (istream& strm, Vec& v){
	strm >> v.x >> v.y;
	return strm;
}

bool direc_v(const Vec& v1, const Vec& v2, const Vec& vp){
	if ((v2 - v1).cross(vp - v2) >= 0) return true;
	return false;
}

int main(){
	Vec a, b, c, p;
	
	auto direc = bind(direc_v, placeholders::_1, placeholders::_2, ref(p));

	while (cin >> a >> b >> c >> p){
		if (direc(a, b) != direc(b, c)){
			cout << "NO" << endl;
			continue;
		}
		if (direc(a, b) != direc(c, a)){
			cout << "NO" << endl;
			continue;
		}
		cout << "YES" << endl;
	}

	return 0;
}

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

double d(double x1,double y1,double x2,double y2)
{
	return sqrt((x2-x1)*(x2-x1)+(y2-y1)*(y2-y1));
}

double s(double x1,double y1,double x2,double y2,double x3,double y3)
{
	double a = d(x1,y1,x2,y2),b = d(x1,y1,x3,y3),c = d(x2,y2,x3,y3);
	double p = (a + b + c)/2;
	return sqrt(p*(p-a)*(p-b)*(p-c));
}

int main()
{
	double x1,y1,x2,y2,x3,y3,xp,yp;
	while(cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> xp >> yp)
	{
	 double s1 = s(x1,y1,x2,y2,xp,yp),s2 = s(x1,y1,x3,y3,xp,yp),s3 = s(x2,y2,x3,y3,xp,yp),sum = s(x1,y1,x2,y2,x3,y3); 
	 if(abs(sum-(s1+s2+s3))<0.00000000000000000001) cout << "YES" << endl;
	 else cout << "NO" << endl; 
    }
	return 0;
}

C++: #include <iostream>
#include <iomanip>
#include <math.h>
#include <utility>
#include <cstdlib>
using namespace std;

int main(){
	double x[3],y[3],xp,yp;
	cin >> x[0] >> y[0] >> x[1] >> y[1] >> x[2] >> y[2] >> xp >> yp;
	bool ans=true;
	for(int i=0;i<3;i++){
		double gaiseki;
		int k = (i+1)%3;
		double vx,vy,vpx,vpy;
		vx = x[k]-x[i];
		vy = y[k]-y[i];
		vpx = xp-x[i];
		vpy = yp-y[i];
		gaiseki = vx*vpy-vy*vpx;
		if(gaiseki<=0) ans = false;
	}
	if(ans){
		cout << "YES" << endl;
	}else{
		cout << "NO" << endl;
	}

	return 0;
}

C++: #include <iostream>

#define SIZE 3

using namespace std;

float innerProduct(float xp, float yp, float x1, float y1, float x2, float y2) {
	return (xp - x1) * (x2 - x1) + (yp - y1) * (y2 - y1);
}

int main() {
	float x[SIZE], y[SIZE], xp, yp, a, b, c;

	while (cin>>x[0]>>y[0]>>x[1]>>y[1]>>x[2]>>y[2]>>xp>>yp) {
		a = innerProduct(xp, yp, x[0], y[0], x[1], y[1]);
		b = innerProduct(xp, yp, x[1], y[1], x[2], y[2]);
		c = innerProduct(xp, yp, x[2], y[2], x[0], y[0]);

		if ((a > 0 && b > 0 && c > 0) || (a < 0 && b < 0 && c < 0)) {
			cout << "YES";
		}
		else {
			cout << "NO";
		}
		cout << endl;
	}
	return 0;
}

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

#define pb(n) push_back(n)
#define fi first
#define se second
#define X real()
#define Y imag()
#define all(r) (r).begin(),(r).end()
#define gsort(st,en) sort((st),(en),greater<int>())
#define vmax(ary) *max_element(all(ary))
#define vmin(ary) *min_element(all(ary))
#define debug(x) cout<<#x<<": "<<x<<endl
#define fcout(n) cout<<fixed<<setprecision((n))
#define scout(n) cout<<setw(n)
#define vary(type,name,size,init) vector< type> name(size,init)

#define rep(i,n) for(int i = 0; i < (int)(n);++i)
#define REP(i,a,b) for(int i = (a);i < (int)(b);++i)
#define repi(it,array) for(auto it = array.begin(),end = array.end(); it != end;++it)
#define repa(n,array) for(auto &n :(array))

using ll = long long;
using vi = vector<int>;
using vl = vector<ll>;
using dict = map<string,int>;
using comd = complex<double>;
using pii = pair<int,int> ;

constexpr int imax = ((1<<30)-1)*2+1 ;
constexpr int inf = 100000000;
constexpr double PI = acos(-1.0) ;
double eps = 1e-10 ;
const int dy[] = {-1,0,1,0};
const int dx[] = {0,-1,0,1};

inline bool value(int x,int y,int w,int h){
  return (x >= 0 && x < w && y >= 0 && y < h);
}

double CalcDist(comd p1, comd p2){
  return sqrt(pow(p1.X - p2.X,2.0) + pow(p1.Y -p2.Y,2.0));
}

template<typename T>
void Unique(vector<T> &v){
  sort(all(v));
  v.erase(all(v),v.end());
}

template<typename T>
T ston(string& str, T n){
  istringstream sin(str) ;
  T num ;
  sin >> num ;
  return num ;
}

void Ans(bool f){
  if(f) cout << "YES"<<endl;
  else cout << "NO"<<endl;
}

double EPS = 1e-10;
double add(double a, double b){
  if(abs(a+b) < EPS* (abs(a) + abs(b))) return 0;
  return a+b;
}
struct P{
  double x,y;
  P(){}
  P(double _x,double _y):x(_x),y(_y){}
  P operator + (P p){
    return P(add(x,p.x) ,add(y,p.y));
  }
  P operator - (P p){
    return P(add(x,-p.x) ,add(y,-p.y));
  }
  P operator * (double d){
    return P(x * d,y * d);
  }
  double norm(){
    return x*x + y*y;
  }
  double dot(P p){
    return add(x * p.x,y*p.y);
  }
  double det(P p){
    return add(x*p.y,-y*p.x);
  }
  double dist2(P p){
    return ((*this-p).x * (*this-p).x) + ((*this-p).y * (*this-p).y);
  }
  double GetSlope(P &p){
    P tmp = *this - p;
    return tmp.y/tmp.x;
  }
};
//???????????????????????¨?????????
bool on_seg(P p1,P p2,P q){
  return (p1-q).det(p2-q) == 0 && (p1-q).dot(p2-q) <= 0;
}

bool check(P p1,P p2,P p3, P p4){
  P a = p1 - p2,b = p3 - p2, p = p4 - p2;
  double theta1 = acos(a.dot(b)/(a.norm() * b.norm()));
  double thetap = acos(a.dot(p)/(a.norm() * p.norm()));
  return thetap <= theta1 ;
}

int main(){
  cin.tie(0);
  ios::sync_with_stdio(false);
  double a,b,c,d,e,f,xp,yp;
  while(cin >> a >> b >> c >> d >> e >> f >> xp >> yp){
    bool flag = true;
    double acx = c-a,abx = e-a,acy = d-b,aby = f-b,apx = xp-a,apy = yp - b;
    P p1 = P(a,b),p2 = P(c,d),p3 = P(e,f),p4 = P(xp,yp);
    Ans(check(p1,p2,p3,p4) && check(p1,p3,p2,p4) && check(p3,p1,p2,p4));
  }
  return 0;
}

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

int main(){
	double x1, y1, x2, y2, x3, y3, xp, yp;
	while(cin>>x1>>y1>>x2>>y2>>x3>>y3>>xp>>yp){
		double sall = (x1-x2)*(y1+y2) + (x2-x3)*(y2+y3) + (x3-x1)*(y3+y1);
		double s1 = (x1-x2)*(y1+y2) + (x2-xp)*(y2+yp) + (xp-x1)*(yp+y1);
		double s2 = (x1-xp)*(y1+yp) + (xp-x3)*(yp+y3) + (x3-x1)*(y3+y1);
		double s3 = (xp-x2)*(yp+y2) + (x2-x3)*(y2+y3) + (x3-xp)*(y3+yp);
		if(abs(sall) == abs(s1)+abs(s2)+abs(s3)){
			cout<<"YES"<<endl;
		} else {
			cout<<"NO"<<endl;
		}
	}
}