Go: package main

import (
        "fmt"
)

func main() {
        var x1, y1, x2, y2, x3, y3, px, py float64
        var oax, oay, obx, oby, opx, opy float64
        var det float64
        var s, t float64

        for {
                _, err := fmt.Scanf("%f %f %f %f %f %f %f %f", &x1, &y1, &x2, &y2, &x3, &y3, &px, &py)
                if err != nil {
                        break
                }
                oax = x2 - x1
                oay = y2 - y1
                obx = x3 - x1
                oby = y3 - y1
                opx = px - x1
                opy = py - y1
                det = oax*oby - obx*oay

                if det == 0 {
                        fmt.Printf("NO\n")
                } else {
                        s = (oby*opx - obx*opy) / det
                        t = (oax*opy - oay*opx) / det

                        if (s+t < 1 && s > 0 && t > 0) {
                                fmt.Printf("YES\n")
                        } else {
                                fmt.Printf("NO\n")
                        }
                }
        }
}

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

const double EPS = 1e-8;
const double INF = 1e12;
typedef complex<double> P; //Point
namespace std {
  bool operator < (const P& a, const P& b) {
    return real(a) != real(b) ? real(a) < real(b) : imag(a) < imag(b);
  }
}
double cross(const P& a, const P& b) {
  return imag(conj(a)*b);
}
double dot(const P& a, const P& b) {
  return real(conj(a)*b);
}
struct L : public vector<P> { // Line
  L(const P &a, const P &b) {
    push_back(a); push_back(b);
  }
};
typedef vector<P> G;
struct C {  //Circle
  P p; double r;
  C(const P &p, double r) : p(p), r(r) { }
};

int ccw(P a, P b, P c) {
  b -= a; c -= a;
  if (cross(b, c) > 0)   return +1;       // counter clockwise
  if (cross(b, c) < 0)   return -1;       // clockwise
  if (dot(b, c) < 0)     return +2;       // c--a--b on line
  if (norm(b) < norm(c)) return -2;       // a--b--c on line
  return 0;                               // a--c--b on line
}

//cross  L line  S senbun  P point
bool intersectLL(const L &l, const L &m) {
  return abs(cross(l[1]-l[0], m[1]-m[0])) > EPS || // non-parallel
         abs(cross(l[1]-l[0], m[0]-l[0])) < EPS;   // same line
}
bool intersectLS(const L &l, const L &s) {
  return cross(l[1]-l[0], s[0]-l[0])*       // s[0] is left of l
         cross(l[1]-l[0], s[1]-l[0]) < EPS; // s[1] is right of l
}
bool intersectLP(const L &l, const P &p) {
  return abs(cross(l[1]-p, l[0]-p)) < EPS;
}
bool intersectSS(const L &s, const L &t) {
  return ccw(s[0],s[1],t[0])*ccw(s[0],s[1],t[1]) <= 0 &&
         ccw(t[0],t[1],s[0])*ccw(t[0],t[1],s[1]) <= 0;
}
bool intersectSP(const L &s, const P &p) {
  return abs(s[0]-p)+abs(s[1]-p)-abs(s[1]-s[0]) < EPS; // triangle inequality
}

//distance
P projection(const L &l, const P &p) {
  double t = dot(p-l[0], l[0]-l[1]) / norm(l[0]-l[1]);
  return l[0] + t*(l[0]-l[1]);
}
P reflection(const L &l, const P &p) {
  return p + 2.0*(projection(l, p) - p);
}
double distanceLP(const L &l, const P &p) {
  return abs(p - projection(l, p));
}
double distanceLL(const L &l, const L &m) {
  return intersectLL(l, m) ? 0 : distanceLP(l, m[0]);
}
double distanceLS(const L &l, const L &s) {
  if (intersectLS(l, s)) return 0;
  return min(distanceLP(l, s[0]), distanceLP(l, s[1]));
}
double distanceSP(const L &s, const P &p) {
  const P r = projection(s, p);
  if (intersectSP(s, r)) return abs(r - p);
  return min(abs(s[0] - p), abs(s[1] - p));
}
double distanceSS(const L &s, const L &t) {
  if (intersectSS(s, t)) return 0;
  return min(min(distanceSP(s, t[0]), distanceSP(s, t[1])),
             min(distanceSP(t, s[0]), distanceSP(t, s[1])));
}
P crosspoint(const L &l, const L &m) {
  double A = cross(l[1] - l[0], m[1] - m[0]);
  double B = cross(l[1] - l[0], l[1] - m[0]);
  if (abs(A) < EPS && abs(B) < EPS) return m[0]; // same line
  if (abs(A) < EPS) assert(false); // !!!PRECONDITION NOT SATISFIED!!!
  return m[0] + B / A * (m[1] - m[0]);
}

vector<P> p(3);
P q;

bool check() {
  for(int i = 0; i < p.size(); ++i) {
    P s = p[i];
    P t = p[(i+1)%p.size()];
    if(cross(t-s, q-s) < 0.0) return false;
  }
  return true;
}

int main() {
  while(cin >> p[0].real() >> p[0].imag()  >> p[1].real() >> p[1].imag() >> p[2].real() >> p[2].imag() >> q.real() >> q.imag()) {
    if(check()) cout << "YES" << endl;
    else {
      swap(p[0],p[1]);
      if(check()) cout << "YES" << endl;
      else cout << "NO" << endl;
    }
  }
  return 0;
}

C++: #include <iostream>

using namespace std;

int islineCross(double x1, double y1, double x2, double y2, double c1, double c2, double d1, double d2) {
  if (((c2-y1)*(x1-x2)-(c1-x1)*(y1-y2))*((d2-y1)*(x1-x2)-(d1-x1)*(y1-y2)) > 0)
    return -1;
  else
    return 0;
}

int main() {
  double x1,x2,x3,y1,y2,y3,xp,yp;

  cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> xp >> yp;
  while(!cin.eof()) {
    int CrossCount = 0;
    if (islineCross(x1,y1,x2,y2,xp,yp,xp+1,yp) == 0)
      CrossCount++;
    if (islineCross(x2,y2,x3,y3,xp,yp,xp+1,yp) == 0)
      CrossCount++;
    if (islineCross(x1,y1,x3,y3,xp,yp,xp+1,yp) == 0)
      CrossCount++;
    
    if (CrossCount == 1)
      cout << "YES" << endl;
    else
      cout << "NO" << endl;
    cin >> x1 >> y1 >> x2 >> y2 >> x3 >> y3 >> xp >> yp;
  } 

  return 0;
}

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

int main(){
  double x1,y1,x2,y2,x3,y3,xp,yp,xp_,yp_;
  double c,d,a1x,a1y,a2x,a2y;
  while(cin>>x1>>y1>>x2>>y2>>x3>>y3>>xp>>yp){
    // cout <<x1<<" "<<y1<<" "<<x2<<" "<<y2<<" "<<x3<<" "<<y3<<" "<<xp<<" "<<yp;
    a1x=x2-x1;
    a1y=y2-y1;
    a2x=x3-x1;
    a2y=y3-y1;
    xp_=xp-x1;
    yp_=yp-y1;
    // cout <<a1x<<a1y<<a2x<<a2y<<xp_<<yp_<<endl;
    c = (xp_*a2y-yp_*a2x)/(a1x*a2y-a2x*a1y);
    d = (-xp_*a1y+yp_*a1x)/(a1x*a2y-a2x*a1y);
    // cout <<"C: "<<c<<",D: "<<d<<endl;
    if (c<0){cout<<"NO"<<endl;continue;}
    if (d<0){cout<<"NO"<<endl;continue;}
    if ((c+d)>1){cout<<"NO"<<endl;continue;}
    cout <<"YES"<<endl;
  }
  return 0;
}

C++: #include<iostream>
#include<cstdio>
#include<complex>
using namespace std;
typedef complex<double> xy_t;
double cross_product(xy_t a, xy_t b) { return (conj(a)*b).imag(); };
int main() {
	xy_t z[8], p;
	double set[8], s1, s2, s3;
	while (
		scanf("%lf%lf%lf%lf%lf%lf%lf%lf", set, set + 1, set + 2, set + 3, set + 4, set + 5, 

set + 6, set + 7)
		== 8) {
		for (int i = 0; i < 3; i++) {
			z[i] = xy_t(set[i*2], set[i*2 + 1]);
		}
		p = xy_t(set[6], set[7]);
		for (int i = 0; i < 3; i++)
			z[i] -= p;
		s1 = cross_product(z[0], z[1]);
		s2 = cross_product(z[1], z[2]);
		s3 = cross_product(z[2], z[0]);
		if ((s1 > 0 && s2 > 0 && s3 > 0) || (s1 < 0 && s2 < 0 && s3 < 0))
			cout << "YES" << endl;
		else
			cout << "NO" << endl;
	}
	return 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
#define REP(i,a,b) for(int i=a;i<b;i++)
#define rep(i,n) REP(i,0,n)
typedef complex<double> P;
double dot(P const& a, P const& b) {
  return real(conj(a)*b);
}
double cross(P const& a, P const& b) {
  return imag(conj(a)*b);
}
int ccw(P a, P b, P c) {
  b -= a, c -= a;
  if(cross(b, c) > 0) return +1; // counter clockwise
  if(cross(b, c) < 0) return -1;  // clockwise
  if(dot(b, c) < 0) return +2;    // c-a-b
  if(norm(b) < norm(c)) return -2;  // a-b-c
  return 0; // on segment
}
int main () {
  P ps[4];
  while(1) {
    rep(i, 4) {
      cin >> ps[i].real() >> ps[i].imag();
    }
    if(cin.eof()) break;
    int sum = 0;
    rep(i, 3) {
      sum += ccw(ps[i], ps[(i+1)%3], ps[3]);
    }
    if(sum == 3 || sum == -3) cout << "YES\n";
    else cout << "NO\n";
  }
  return 0;
}