#include <iostream>
#include <algorithm>
#include <cassert>
#include <vector>
#include <cmath>
#include <stdio.h>

using namespace std;

//-------------------------------------------------------------------------
// geometric library

namespace geometry {

#define EPS 1E-10 ///< 0とみなすサイズ。適当

	struct point {
		double x;
		double y;

		point& operator += (const point& rhs) { x += rhs.x; y += rhs.y; return *this; }
		point& operator -= (const point& rhs) { x -= rhs.x; y -= rhs.y; return *this; }
		point& operator /= (double factor) { x /= factor; y /= factor; return *this; }
		point& operator *= (double factor) { x *= factor; y *= factor; return *this; }
		bool operator == (const point& rhs) const { return (std::abs(x - rhs.x) < EPS) && (std::abs(y - rhs.y) < EPS); }
		bool operator != (const point& rhs) const { return !(*this == rhs); }
		bool operator <= (const point& rhs) const { return x < rhs.x || (x == rhs.x && y <= rhs.y); }
		bool operator >= (const point& rhs) const { return x > rhs.x || (x == rhs.x && y >= rhs.y); }
		bool operator < (const point& rhs) const { return !(*this >= rhs); }
		bool operator > (const point& rhs) const { return !(*this <= rhs); }
	};

	enum rotate_dir {
		rotate_None = 0,
		rotate_CW = 1,
		rotate_CCW = -1
	};

	point operator + (const point& p1, const point& p2)
	{
		point p(p1);
		p += p2;
		return p;
	}

	point operator / (const point& p1, double factor)
	{
		point p(p1);
		p /= factor;
		return p;
	}

	point operator - (const point& p1, const point& p2)
	{
		point p(p1);
		p -= p2;
		return p;
	}

	///! 2点の距離
	double get_distance(const point& p1, const point& p2)
	{
		return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
	}

	double cross_product(const point& p1, const point& p2)
	{
		return p1.x * p2.y - p2.x * p1.y;
	}

	///! p1-p2-p3が左右どちらの方向に折れているかを判定
	rotate_dir direction(const point& p1, const point& p2, const point& p3)
	{
		point p1_p3 = p1 - p3;
		point p2_p3 = p2 - p3;
		double cross = cross_product(p1_p3, p2_p3);

		if (std::abs(cross) < EPS) {
			return rotate_None;
		}
		else if (cross > 0) {
			return rotate_CW;
		}
		else {
			return rotate_CCW;
		}
	}

	bool is_convex(const point* points, int num_points) {
		assert(num_points >= 3);

		rotate_dir base_dir = direction(points[0], points[1], points[2]);
		if (base_dir == rotate_None) {
			return false;
		}

		for (int i = 1; i < num_points; i++) {
			if (direction(points[i], points[(i + 1)%num_points], points[(i + 2)%num_points]) != base_dir) {
				return false;
			}
		}
		return true;
	}

} // namespace geometry

//-------------------------------------------------------------------------
// solution

using namespace geometry;

double get_area_of_triangle(const point& p1, const point& p2, const point& p3) {
	double a = get_distance(p1, p2);
	double b = get_distance(p2, p3);
	double c = get_distance(p3, p1);
	double z = (a + b + c) / 2;

	assert(z > a && z > b && z > c); // 3角形であるための条件

	return sqrt(z * (z - a) * (z - b) * (z - c));
}

double get_area_of_convex(const vector<point>& points) {
	double S = 0.0;

	assert(is_convex(&points[0], points.size()));

	for (int i = 2; i < points.size(); i++) {
		S += get_area_of_triangle(points[0], points[i - 1], points[i]);
	}
	return S;
}

int main(void) {
	vector<point> points;
	point p;
	char sep;

	while (cin >> p.x >> sep >> p.y) {
		points.push_back(p);
	}

	cout << get_area_of_convex(points);
	return 0;
}