#include <bits/stdc++.h>

using namespace std;

#define EPS 1e-10

struct Point {
    double x, y;

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

    Point operator + (const Point &p)const{ return Point(x+p.x,y+p.y); }
    Point operator - (const Point &p)const{ return Point(x-p.x,y-p.y); }
    Point operator * (const double &k)const{ return Point(x*k,y*k); }
};

double dot(const Point &a, const Point &b)
{
    return a.x * b.x + a.y * b.y;
}

double cross(const Point &a, const Point &b)
{
    return a.x * b.y - b.x * a.y;
}

double norm(const Point &p)
{
    return dot(p, p);
}

#define COUNTER_CLOCKWISE +1
#define CLOCKWISE         -1
#define ONLINE_BACK       +2
#define ONLINE_FRONT      -2
#define ON_SEGMENT        +0
typedef Point Vector;

int ccw(const Point &p0, const Point &p1, const Point &p2)
{
    Vector a = p1 - p0;
    Vector b = p2 - p0;
    if (cross(a, b) > EPS) return COUNTER_CLOCKWISE;
    if (cross(a, b) < -EPS) return CLOCKWISE;
    if (dot(a, b) < -EPS) return ONLINE_BACK;
    if (norm(a) < norm(b)) return ONLINE_FRONT;
    return ON_SEGMENT;
}

typedef vector<Point> Polygon;

bool sortY(Point p1, Point p2)
{
    if (p1.y != p2.y) {
	return (p1.y - p2.y < -EPS);
    } else { 
	return (p1.x - p2.x < -EPS);
    }
}

Polygon convex_hull(Polygon &ps)
{
    int N = ps.size(), j = 0;
    Polygon pg(N*2);
    sort(ps.begin(), ps.end(), sortY);
    for (int i = 0; i < N; i++, j++) {
	while (j >= 2 && ccw(pg[j-2], pg[j-1], ps[i]) == -1) {
	    j--;
	}
	pg[j] = ps[i];
    }
    int k = j+1;
    for (int i = N-2; i >= 0; i--, j++) {
	while (j >= k && ccw(pg[j-2], pg[j-1], ps[i]) == -1) {
	    j--;
	}
	pg[j] = ps[i];
    }
    pg.resize(j-1);
    return pg;
}

int main()
{
    Polygon pg(4);
    char c;
    while (cin >> pg[0].x >> c >> pg[0].y) {
        for (int i = 1; i < 4; i++) {
            cin >> c >> pg[i].x >> c >> pg[i].y;
        }
        cout << (convex_hull(pg).size() == 4 ? "YES" : "NO") << endl;
    }
    return 0;
}