Go: package main

import (
	"bufio"
	"os"
	"strings"
	"strconv"
	"fmt"
)

func check(x, y, x1, y1, x2, y2 float64) float64 {
	return (x2-x1)*y - (y2-y1)*x + x1*y2 - x2*y1
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	a := make([]float64, 8)
	for scanner.Scan() {
		info := strings.Split(scanner.Text(), ",")
		for j := 0; j < 8; j++ {
			a[j], _ = strconv.ParseFloat(info[j], 64)
		}
		if check(a[0], a[1], a[2],a[3], a[6], a[7])*check(a[4], a[5], a[2], a[3], a[6], a[7]) < 0 && check(a[6], a[7], a[0], a[1], a[4], a[5])*check(a[2],a[3], a[0], a[1], a[4], a[5]) < 0 {
			fmt.Println("YES")	
		} else {
			fmt.Println("NO")
		}
	}
}

C++: #include <cstdio>
#include <cmath>
#define vertex 4
#define PI (atan(1.0) * 4.0)

using namespace std;

int main(void){
	int i;
	double x[vertex], y[vertex], theta, ax, ay, bx, by;
	while(scanf("%lf%*c%lf%*c",&x[0],&y[0]) != EOF){
		for(i = 1;i < vertex;i++){
			scanf("%lf%*c%lf%*c",&x[i],&y[i]);
		}
		printf("%f\n",PI);
		for(i = 0;i < vertex;i++){
			ax = x[i] - x[(i + 1) % vertex];
			ay = y[i] - y[(i + 1) % vertex];
			bx = x[(i + 2) % vertex] - x[(i + 1) % vertex];
			by = y[(i + 2) % vertex] - y[(i + 1) % vertex];
			theta = 180 * acos((ax * bx + ay * by) / (sqrt(pow(ax,2.0) + pow(ay,2.0)) * sqrt(pow(bx,2.0) + pow(by,2.0)))) / PI;
			printf("%f\n",theta);
			if(theta > 90){
				printf("NO\n");
				break;
			}
		}
		if(i == vertex){
			printf("YES\n");
		}
	}
	return 0;
}

C++: #include <iostream>
#include <vector>
#include <list>
#include <algorithm>
#include <set>
#include <queue>
#include <stack>
#include <string>
#include <sstream>
#include <map>
#include <cstdio>
#include <cstdlib>
#include <cmath>
#include <cstring>
#include <complex>

#define rep(i, n) for(int i = 0; i < n; i ++)
#define COUNT(i, n) for(int i = 1; i <= n; i ++)
#define ITER(c) __typeof((c).begin())
#define each(c, it) for(ITER(c) it =(c).begin(); it!=(c).end(); it++)
#define ALL(c) c.begin(), c.end()
#define mp make_pair
#define pb push_back
#define MEMSET(v, h) memset((v), h, sizeof(v))
#define X real()
#define Y imag()

using namespace std; 

typedef pair<int, int> pii;
typedef long long ll;
typedef vector<int> vi;
typedef vector<string> vs;
typedef complex<double> P;

const int INF = 1 << 24;

bool isNoConv(P, P, P, P);

int main(void){
    for(vector<P> p(4);;){
        if(!~scanf("%lf,%lf", &p[0].X, &p[0].Y)) break;
        char c;
        COUNT(i, 3) cin >> c >> p[i].X >> c >> p[i].Y;
        
        cout << ((isNoConv(p[0], p[2], p[1], p[3]) || isNoConv(p[1], p[3], p[0], p[2])) ? "NO":"YES") << endl;
    }
 
    return 0;
}

bool isNoConv(P p1, P p2, P p3, P p4){
    return ((p1.X - p2.X) * (p3.Y - p1.Y) - 
            (p1.Y - p2.Y) * (p3.X - p1.X)) * 
           ((p1.X - p2.X) * (p4.Y - p1.Y) - 
            (p1.Y - p2.Y) * (p4.X - p1.X)) > 0;
}

C++: #include <bits/stdc++.h>
using namespace std;
#define FOR(i, s, n) for(int i = s; i < (int)n; i++)
#define per(i, n) for(int i = n; i >= 0; i--)
#define ROF(i, s, n) for(int i = s; i >= (int)n; i--)
#define FORIT(i, A) for (auto i : A)
#define PRINT(x) cout << (x) << "\n"
#define ALL(a) (a).begin(),(a).end()
#define RALL(a) (a).rbegin(), (a).rend()
#define MP make_pair
#define EACH(i, n) for (__typeof((n).begin()) i = (n).begin(); i != (n).end(); ++i)
#define SZ(a) int((a).size())
#define EXIST(s,e) ((s).find(e)!=(s).end())
#define SORT(c) sort((c).begin(),(c).end())
#define CLR(a) memset((a), 0 ,sizeof(a))
#define NCLR(a) memset((a), -1 ,sizeof(a))
#define dump(x) cout << #x << " = " << (x) << "\n";
#define debug(x) cout << #x << " = " << (x) << " (L" << __LINE__ << ")" << " " << __FILE__ << "\n";
#define sq(n) (n) * (n)
typedef vector<int> VI;
typedef vector<VI> VVI;
typedef vector<string> VS;
typedef pair<int, int> PII;
typedef long long LL;
typedef vector<LL> VLL;
typedef vector<VLL> VVLL;
typedef unsigned int uint;
typedef unsigned long long ull;
typedef priority_queue<int> maxpq;
typedef priority_queue< int, vector<int>, greater<int> > minpq;
typedef complex<double> P;
static const double EPS = 1e-10;
static const double PI = acos( -1.0 );
static const int mod = 1000000007;
static const int INF = 1 << 30;
static const LL LL_INF = 1152921504606846976;
static const int dx[] = { -1, 0, 1, 0, 1, -1, 1, -1 };
static const int dy[] = { 0, -1, 0, 1, 1, 1, -1, -1 };
 
bool collision_detection( double x1, double y1, double x2, double y2, double x3, double y3, double xp, double yp ) {
    x2 -= x1;
    x3 -= x1;
    xp -= x1;
    y2 -= y1;
    y3 -= y1;
    yp -= y1;
    double t_size = fabs( ( x2 * y3 - y2 * x3 ) / 2 );
    t_size -= fabs( ( x2 * yp -  y2 * xp ) / 2 );
    t_size -= fabs( ( x3 * yp -  y3 * xp ) / 2 );
    x2 -= xp;
    x3 -= xp;
    y2 -= yp;
    y3 -= yp;
    yp = xp = 0;
    t_size -= fabs( ( x2 * y3 - y2 * x3 ) / 2 );
    return fabs( t_size ) < 1e-10;
}
 
int main() {
    double x[ 4 ], y[ 4 ];
    while ( ~scanf( "%lf,%lf,%lf,%lf,%lf,%lf,%lf,%lf", &x[ 0 ], &y[ 0 ], &x[ 1 ], &y[ 1 ], &x[ 2 ], &y[ 2 ], &x[ 3 ], &y[ 3 ] ) ) {
        bool print_yes = true;
        for ( int i = 0; i < 4; i++ ) {
            if ( collision_detection( x[ ( i + 1 ) % 4 ], y[ ( i + 1 ) % 4 ], x[ ( i + 2 ) % 4 ], y[ ( i + 2 ) % 4 ], x[ ( i + 3 ) % 4 ], y[ ( i + 3 ) % 4 ], x[ i ], y[ i ] ) ) {
                print_yes = false;
                break;
            }
        }
        printf( "%s\n", print_yes ? "YES" : "NO" );
    }
    return 0;
}

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

int isConvex(double ax, double ay, double ox, double oy, double bx, double by){
	double x1 = ax - ox;
	double y1 = ay - oy;
	double x2 = bx - ox;
	double y2 = by - oy;
	double angle;
	
	angle = (x1*x2+y1*y2) / (sqrt(x1*x1+y1*y1)*sqrt(x2*x2+y2*y2));
	
	if(angle < 0.0f)return 1;
	return 0;
}

int main() {
	float ax,ay, bx,by, cx,cy, dx,dy;
	
	while( scanf("%f,%f,%f,%f,%f,%f,%f,%f",&ax,&ay,&bx,&by,&cx,&cy,&dx,&dy) + 1 ){
		
		if(
			isConvex(ax,ay,bx,by,cx,cy) |
			isConvex(bx,by,cx,cy,dx,dy) |
			isConvex(cx,cy,dx,dy,ax,ay) |
			isConvex(dx,dy,ax,ay,bx,by)
		)cout<<"NO"<<endl;
		else cout<<"YES"<<endl;
	}
	
	return 0;
}