Write a program that reads the coordinates of the vertices of a convex n-sided polygon (a polygon whose internal angles are less than 180 degrees, that is, a polygon that is not dented) and outputs its area. The vertices are named Vertex 1, Vertex 2, Vertex 3, ... Vertex n according to the order of edge connections.

However, n is 3 or more and 20 or less. You can also use the following formula to find the area S from the lengths a, b, and c of the three sides of the triangle.

<image>



input

The input is given in the following format:


x1, y1
x2, y2
::
xn, yn


xi and yi are real numbers that represent the x and y coordinates of vertex i, respectively.

output

Outputs the area S (real number) on one line. The output can contain an error of 0.000001 or less.

Example

Input

0.0,0.0
0.0,1.0
1.0,1.0
2.0,0.0
1.0,-1.0


Output

2.500000

Difficulty: UNKNOWN_DIFFICULTY

Starter code:

Solutions:
i = 0
x = []
y = []
while 1:
	try:
		(a, b) = map(float, input().split(','))
		x.append(a)
		y.append(b)
	except EOFError:
		break
S = 0
for i in range(len(x) - 2):
	a = ((x[0] - x[i + 1]) ** 2 + (y[0] - y[i + 1]) ** 2) ** 0.5
	b = ((x[0] - x[i + 2]) ** 2 + (y[0] - y[i + 2]) ** 2) ** 0.5
	c = ((x[i + 1] - x[i + 2]) ** 2 + (y[i + 1] - y[i + 2]) ** 2) ** 0.5
	z = (a + b + c) / 2
	S += (z * (z - a) * (z - b) * (z - c)) ** 0.5
print(S)


def cross(x, y):
	return (x.conjugate() * y).imag

def area_polygon(points):
	area = 0
	n = len(points)
	for i in range(n):
		area += cross(points[i], points[(i + 1) % n])
	return area / 2
import sys
p = []
for line in sys.stdin:
	(x, y) = map(float, line.split(','))
	p.append(complex(x, y))
print(area_polygon(p))


import sys
s = 0
p = [list(map(float, e.split(','))) for e in sys.stdin]
(x, y) = p[0]
for i in range(len(p) - 2):
	(a, b) = p[i + 1]
	(c, d) = p[i + 2]
	s += ((a - x) * (d - y) - (b - y) * (c - x)) / 2
print(abs(s))


import math
f = []
while True:
	try:
		st = input().strip().split(',')
		(x, y) = list(map(float, st))
		f.append(x + y * 1j)
	except EOFError:
		break
px = [p.real for p in f]
ox = (max(px) + min(px)) / 2.0
py = [p.imag for p in f]
oy = (max(py) + min(py)) / 2.0
fo = ox + oy * 1j
ss = 0.0
for i in range(len(f)):
	if i == len(f) - 1:
		j = 0
	else:
		j = i + 1
	a = abs(f[i] - fo)
	b = abs(f[j] - fo)
	c = abs(f[j] - f[i])
	z = (a + b + c) / 2.0
	s = math.sqrt(z * (z - a) * (z - b) * (z - c))
	ss += s
print('%.6f' % ss)


number = []
answer = 0
while 1:
	try:
		(x, y) = map(float, input().split(','))
		number.append((x, y))
	except:
		number.append(number[0])
		for i in range(len(number) - 1):
			answer += (number[i][0] - number[i + 1][0]) * (number[i][1] + number[i + 1][1])
		if answer < 0:
			answer = answer * -1
		print('{:.6f}'.format(answer / 2))
		break


import math
X = []
Y = []

def area(a, b, c):
	p = math.sqrt((X[a] - X[b]) ** 2 + (Y[a] - Y[b]) ** 2)
	q = math.sqrt((X[b] - X[c]) ** 2 + (Y[b] - Y[c]) ** 2)
	r = math.sqrt((X[c] - X[a]) ** 2 + (Y[c] - Y[a]) ** 2)
	z = (p + q + r) / 2
	return math.sqrt(z * (z - p) * (z - q) * (z - r))
while True:
	try:
		(a, b) = map(float, input().split(','))
		X.append(a)
		Y.append(b)
	except EOFError:
		break
ans = 0.0
for i in range(1, len(X) - 1):
	ans += area(0, i, i + 1)
print(ans)


import sys
import math

class mymath:
	pi = 3.141592653589793

	def pnum_eratosthenes(self, n):
		ptable = [0 for i in range(n + 1)]
		plist = []
		for i in range(2, n + 1):
			if ptable[i] == 0:
				plist.append(i)
				for j in range(i + i, n + 1, i):
					ptable[j] = 1
		return plist

	def pnum_check(self, n):
		if n == 1:
			return False
		elif n == 2:
			return True
		else:
			for x in range(2, n):
				if n % x == 0:
					return False
			return True

	def gcd(self, a, b):
		if b == 0:
			return a
		return self.gcd(b, a % b)

	def lcm(self, a, b):
		return a * b // self.gcd(a, b)

	def mul(self, A, B):
		ans = []
		for a in A:
			c = 0
			for (j, row) in enumerate(a):
				c += row * B[j]
			ans.append(c)
		return ans

	def is_integer(self, n):
		try:
			float(n)
		except ValueError:
			return False
		else:
			return float(n).is_integer()

	def dist(self, A, B):
		d = 0
		for i in range(len(A)):
			d += (A[i] - B[i]) ** 2
		d = d ** (1 / 2)
		return d

	def abs(self, n):
		if n >= 0:
			return n
		else:
			return -n
mymath = mymath()

class output:

	def list(self, l):
		l = list(l)
		for (i, num) in enumerate(l):
			print(num, end='')
			if i != len(l) - 1:
				print(' ', end='')
		print()
output = output()

def printA(A):
	N = len(A)
	for (i, n) in enumerate(A):
		print(n, end='')
		if i != N - 1:
			print(' ', end='')
	print()

def get_input(s=' '):
	N = []
	while True:
		try:
			N.append([float(x) for x in input().split(s)])
		except EOFError:
			break
	return N

def CalcArea(A, B, C):
	a = ((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2) ** 0.5
	b = ((B[0] - C[0]) ** 2 + (B[1] - C[1]) ** 2) ** 0.5
	c = ((C[0] - A[0]) ** 2 + (C[1] - A[1]) ** 2) ** 0.5
	z = (a + b + c) / 2
	return (z * (z - a) * (z - b) * (z - c)) ** 0.5
D = get_input(',')
ans = 0.0
for i in range(1, len(D) - 1):
	ans += CalcArea(D[0], D[i], D[i + 1])
print(ans)


import sys
from math import sqrt, atan2, acos, sin, cos, hypot
from sys import stdin
input = stdin.readline

class Point(object):
	epsilon = 1e-10

	def __init__(self, x=0.0, y=0.0):
		if isinstance(x, tuple):
			self.x = x[0]
			self.y = x[1]
		else:
			self.x = x
			self.y = y

	def __add__(self, other):
		return Point(self.x + other.x, self.y + other.y)

	def __sub__(self, other):
		return Point(self.x - other.x, self.y - other.y)

	def __mul__(self, other):
		return Point(other * self.x, other * self.y)

	def __truediv__(self, other):
		return Point(self.x / other, self.y / other)

	def __lt__(self, other):
		if self.x == other.x:
			return self.y < other.y
		else:
			return self.x < other.x

	def __eq__(self, other):
		from math import fabs
		if fabs(self.x - other.x) < Point.epsilon and fabs(self.y - other.y) < Point.epsilon:
			return True
		else:
			return False

	def norm(self):
		return self.x * self.x + self.y * self.y

	def __abs__(self):
		return sqrt(self.norm())

	def ccw(self, p0, p1):
		a = Vector(p1 - p0)
		b = Vector(self - p0)
		if Vector.cross(a, b) > Point.epsilon:
			return 1
		elif Vector.cross(a, b) < -Point.epsilon:
			return -1
		elif Vector.dot(a, b) < -Point.epsilon:
			return 2
		elif a.norm() < b.norm():
			return -2
		else:
			return 0

	def project(self, s):
		base = Vector(s.p2 - s.p1)
		a = Vector(self - s.p1)
		r = Vector.dot(a, base)
		r /= base.norm()
		return s.p1 + base * r

	def reflect(self, s):
		proj = self.project(s)
		return self + (proj - self) * 2

	def distance(self, s):
		if Vector.dot(s.p2 - s.p1, self - s.p1) < 0.0:
			return abs(self - s.p1)
		if Vector.dot(s.p1 - s.p2, self - s.p2) < 0.0:
			return abs(self - s.p2)
		return abs(Vector.cross(s.p2 - s.p1, self - s.p1) / abs(s.p2 - s.p1))

class Vector(Point):

	def __init__(self, x=0.0, y=0.0):
		if isinstance(x, tuple):
			self.x = x[0]
			self.y = x[1]
		elif isinstance(x, Point):
			self.x = x.x
			self.y = x.y
		else:
			self.x = x
			self.y = y

	def __add__(self, other):
		return Vector(self.x + other.x, self.y + other.y)

	def __sub__(self, other):
		return Vector(self.x - other.x, self.y - other.y)

	def __mul__(self, other):
		return Vector(other * self.x, other * self.y)

	def __truediv__(self, other):
		return Vector(self.x / other, self.y / other)

	@classmethod
	def dot(cls, a, b):
		return a.x * b.x + a.y * b.y

	@classmethod
	def cross(cls, a, b):
		return a.x * b.y - a.y * b.x

	@classmethod
	def is_orthogonal(cls, a, b):
		return abs(Vector.dot(a, b)) < Vector.epsilon

	@classmethod
	def is_parallel(cls, a, b):
		return abs(Vector.cross(a, b)) < Vector.epsilon

class Segment(object):

	def __init__(self, p1=Point(), p2=Point()):
		if isinstance(p1, Point):
			self.p1 = p1
			self.p2 = p2
		elif isinstance(p1, tuple):
			self.p1 = Point(p1[0], p1[1])
			self.p2 = Point(p2[0], p2[1])

	def intersect(self, s):
		ans1 = s.p1.ccw(self.p1, self.p2) * s.p2.ccw(self.p1, self.p2)
		ans2 = self.p1.ccw(s.p1, s.p2) * self.p2.ccw(s.p1, s.p2)
		return ans1 <= 0 and ans2 <= 0

	def cross_point(self, s):
		base = s.p2 - s.p1
		d1 = abs(Vector.cross(base, self.p1 - s.p1))
		d2 = abs(Vector.cross(base, self.p2 - s.p1))
		t = d1 / (d1 + d2)
		return self.p1 + (self.p2 - self.p1) * t

	def distance(self, s):
		if self.intersect(s):
			return 0.0
		d1 = s.p1.distance(self)
		d2 = s.p2.distance(self)
		d3 = self.p1.distance(s)
		d4 = self.p2.distance(s)
		return min(d1, d2, d3, d4)

	@classmethod
	def is_orthogonal(cls, s1, s2):
		a = Vector(s1.p2 - s1.p1)
		b = Vector(s2.p2 - s2.p1)
		return Vector.is_orthogonal(a, b)

	@classmethod
	def is_parallel(cls, s1, s2):
		a = Vector(s1.p2 - s1.p1)
		b = Vector(s2.p2 - s2.p1)
		return Vector.is_parallel(a, b)

class Line(Segment):
	pass

class Cirle(object):

	def __init__(self, x, y=Point(), r=1.0):
		if isinstance(x, Point):
			self.c = x
			self.r = y
		elif isinstance(x, tuple):
			self.c = Point(x[0], x[1])
			self.r = r

	def cross_points(self, s):
		if isinstance(s, Segment):
			pr = self.c.project(s)
			e = (s.p2 - s.p1) / abs(s.p2 - s.p1)
			base = sqrt(self.r * self.r - (pr - self.c).norm())
			return (pr + e * base, pr - e * base)
		elif isinstance(s, Cirle):
			c2 = s
			d = abs(self.c - c2.c)
			a = acos((self.r * self.r + d * d - c2.r * c2.r) / (2 * self.r * d))
			t = atan2(c2.c.y - self.c.y, c2.c.x - self.c.x)
			temp1 = Point(cos(t + a) * self.r, sin(t + a) * self.r)
			temp2 = Point(cos(t - a) * self.r, sin(t - a) * self.r)
			return (self.c + temp1, self.c + temp2)

class Triangle(object):

	def __init__(self, p1, p2, p3):
		self.p1 = p1
		self.p2 = p2
		self.p3 = p3

	def length(self):
		l1 = hypot(self.p1.x - self.p2.x, self.p1.y - self.p2.y)
		l2 = hypot(self.p2.x - self.p3.x, self.p2.y - self.p3.y)
		l3 = hypot(self.p3.x - self.p1.x, self.p3.y - self.p1.y)
		return (l1, l2, l3)

	def area(self):
		(a, b, c) = self.length()
		z = (a + b + c) / 2.0
		return sqrt(z * (z - a) * (z - b) * (z - c))

def main(args):
	points = []
	for line in sys.stdin:
		(x, y) = map(float, line.split(','))
		points.append(Point(x, y))
	area = 0.0
	p1 = points[0]
	points = points[1:]
	while len(points) > 1:
		p2 = points[0]
		p3 = points[1]
		t = Triangle(p1, p2, p3)
		area += t.area()
		points = points[1:]
	print('{:.8f}'.format(area))
main(sys.argv[1:])


import sys

def area_of_triangle(x, y, z):
	return ((y[0] - x[0]) * (z[1] - x[1]) - (z[0] - x[0]) * (y[1] - x[1])) / 2
p = [list(map(float, line.split(','))) for line in sys.stdin]
print(sum([area_of_triangle(p[0], p[i], p[i + 1]) for i in range(1, len(p) - 1)]))


def cross(x, y):
	return (x.conjugate() * y).imag

def area_polygon(points):
	area = 0
	n = len(points)
	for i in range(n):
		area += cross(points[i], points[(i + 1) % n])
	return area / 2
import sys
p = []
for line in sys.stdin:
	(x, y) = map(float, line.split(','))
	p.append(complex(x, y))
print(abs(area_polygon(p)))


import math

def calc_d(a, b):
	return math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)
p = []
while True:
	try:
		p.append(list(map(float, input().split(','))))
	except:
		break
n = len(p)
s = 0
for i in range(1, n - 1):
	a = calc_d(p[0], p[i])
	b = calc_d(p[0], p[i + 1])
	c = calc_d(p[i], p[i + 1])
	z = (a + b + c) / 2
	s += math.sqrt(z * (z - a) * (z - b) * (z - c))
print(s)


from math import sqrt
x = []
y = []
while 1:
	try:
		a = [float(i) for i in input().split(',')]
		x.append(a[0])
		y.append(a[1])
	except EOFError:
		break
n = len(x)
S = 0
for i in range(n - 2):
	if i == 0:
		a = sqrt((x[1] - x[0]) ** 2 + (y[1] - y[0]) ** 2)
	b = sqrt((x[i + 2] - x[i + 1]) ** 2 + (y[i + 2] - y[i + 1]) ** 2)
	c = sqrt((x[i + 2] - x[0]) ** 2 + (y[i + 2] - y[0]) ** 2)
	z = (a + b + c) / 2
	s = sqrt(z * (z - a) * (z - b) * (z - c))
	S = S + s
	a = c
print('{:.6f}'.format(S))


ans = 0
(x, y) = map(float, input().split(','))
(k1, k2) = map(float, input().split(','))
while 1:
	try:
		(k3, k4) = map(float, input().split(','))
		a = ((k1 - x) ** 2 + (k2 - y) ** 2) ** 0.5
		b = ((k3 - x) ** 2 + (k4 - y) ** 2) ** 0.5
		c = ((k1 - k3) ** 2 + (k2 - k4) ** 2) ** 0.5
		z = (a + b + c) / 2
		ans += (z * (z - a) * (z - b) * (z - c)) ** 0.5
		(k1, k2) = (k3, k4)
	except:
		break
print(ans)


p = []
try:
	while True:
		(x, y) = map(float, input().split(','))
		p.append(complex(x, y))
except EOFError:
	pass
n = len(p)
sum = 0.0
for i in range(1, n - 1):
	(a, b) = (p[i] - p[0], p[i + 1] - p[0])
	s = (a.conjugate() * b).imag
	sum += s
print('%.6f' % (abs(sum) / 2.0))


import sys
s = 0
p = [list(map(float, e.split(','))) for e in sys.stdin]
(x, y) = p[0]
for i in range(len(p) - 2):
	(a, b) = p[i + 1]
	(c, d) = p[i + 2]
	s += (a * d - b * c + (b - d) * x + (c - a) * y) / 2
print(abs(s))


def op(u, v):
	return (complex.conjugate(u) * v).imag
f = []
while True:
	try:
		st = input().strip().split(',')
		(x, y) = list(map(float, st))
		f.append(x + y * 1j)
	except EOFError:
		break
s = 0.0
fo = f[0]
for j in range(2, len(f)):
	i = j - 1
	s += op(f[i] - fo, f[j] - fo) / 2.0
print('%.6f' % abs(s))


vertices = []
for _ in range(20):
	try:
		vertices.append([float(x) for x in input().split(',')])
	except:
		break
n = len(vertices)

def dist(p, q):
	return ((p[0] - q[0]) ** 2 + (p[1] - q[1]) ** 2) ** 0.5

def area(p, q, r):
	a = dist(p, q)
	b = dist(q, r)
	c = dist(r, p)
	z = (a + b + c) / 2
	return (z * (z - a) * (z - b) * (z - c)) ** 0.5
S = 0
for i in range(1, n - 1):
	S += area(vertices[0], vertices[i], vertices[i + 1])
print(S)


import math
f = []
while True:
	try:
		st = input().strip().split(',')
		(x, y) = list(map(float, st))
		f.append(x + y * 1j)
	except EOFError:
		break
ss = 0.0
fo = f[0]
for j in range(2, len(f)):
	i = j - 1
	a = abs(f[i] - fo)
	b = abs(f[j] - fo)
	c = abs(f[j] - f[i])
	z = (a + b + c) / 2.0
	s = math.sqrt(z * (z - a) * (z - b) * (z - c))
	ss += s
print('%.6f' % ss)


import cmath
import math
P = []
try:
	while True:
		(x, y) = map(float, input().split(','))
		P.append(complex(x, y))
except EOFError:
	pass

def cross_product(a, b):
	return (a.conjugate() * b).imag
N = len(P)
total = 0.0
for i in range(1, N - 1):
	(a, b, c) = (P[0], P[i], P[i + 1])
	total += 0.5 * cross_product(P[i] - P[0], P[i + 1] - P[0])
print('%.6f' % abs(total))


import math
import cmath

def cross_product(a, b):
	return (a.conjugate() * b).imag
L = []
try:
	while True:
		(x, y) = map(float, input().split(','))
		L.append(complex(x, y))
except EOFError:
	pass
N = len(L)
S = 0
for i in range(1, N - 1):
	(a, b, c) = (L[0], L[i], L[i + 1])
	S += abs(cross_product(b - a, c - a)) / 2
print(S)


import sys
import os
import math

def length(v, w):
	x_diff = v[0] - w[0]
	y_diff = v[1] - w[1]
	return math.sqrt(x_diff ** 2 + y_diff ** 2)
X = []
Y = []
for s in sys.stdin:
	(x, y) = map(float, s.split(','))
	X.append(x)
	Y.append(y)
n = len(X)
answer = 0
for i in range(1, n - 1):
	p0 = (X[0], Y[0])
	p1 = (X[i], Y[i])
	p2 = (X[i + 1], Y[i + 1])
	a = length(p0, p1)
	b = length(p1, p2)
	c = length(p2, p0)
	z = (a + b + c) / 2
	S = math.sqrt(z * (z - a) * (z - b) * (z - c))
	answer += S
print(answer)


p1 = complex(*list(map(float, input().split(','))))
p2 = complex(*list(map(float, input().split(','))))
ans = 0

def area(p, q, r):
	return ((p - r).conjugate() * (q - r)).imag / 2
try:
	while True:
		p3 = complex(*list(map(float, input().split(','))))
		ans += area(p1, p2, p3)
		p2 = p3
except EOFError:
	print(abs(ans))


import sys, math
l = [list(map(float, i.split(','))) for i in sys.stdin]
S = 0
for (i, j) in enumerate(l):
	(xn, yn) = j
	if i != len(l) - 1:
		(xn_1, yn_1) = l[i + 1]
	else:
		(xn_1, yn_1) = l[0]
	a = math.sqrt(xn ** 2 + yn ** 2)
	b = math.sqrt(xn_1 ** 2 + yn_1 ** 2)
	c = math.sqrt((xn_1 - xn) ** 2 + (yn_1 - yn) ** 2)
	z = (a + b + c) / 2
	S += math.sqrt(z * (z - a) * (z - b) * (z - c))
print(S)


import sys
from math import sqrt, hypot

def _hypot(p1, p2):
	return hypot(p2[0] - p1[0], p2[1] - p1[1])

def heron(p1, p2, p3):
	(e1, e2, e3) = (_hypot(p1, p2), _hypot(p2, p3), _hypot(p1, p3))
	z = (e1 + e2 + e3) / 2
	return sqrt(z * (z - e1) * (z - e2) * (z - e3))
a = [tuple(map(float, l.split(','))) for l in sys.stdin]
result = 0
for (p1, p2) in zip(a[1:], a[2:]):
	result += heron(a[0], p1, p2)
print(result)


import cmath

def norm(c):
	a = abs(c)
	return a * a

def dot_product(a, b):
	return (a.conjugate() * b).real

def cross_product(a, b):
	return (a.conjugate() * b).imag

def projection(p, b):
	return b * dot_product(p, b) / norm(b)
P = []
try:
	while True:
		(x, y) = map(float, input().strip().split(','))
		P.append(complex(x, y))
except EOFError:
	pass
N = len(P)
total = 0.0
for i in range(1, N - 1):
	(a, b, c) = (P[0], P[i], P[i + 1])
	total += cross_product(b - a, c - a)
print('%.6f' % (abs(total) / 2.0))


import math

def get_input():
	while True:
		try:
			yield ''.join(input())
		except EOFError:
			break
N = list(get_input())
(x0, y0) = [float(i) for i in N[0].split(',')]
ans = 0.0
for l in range(2, len(N)):
	(x1, y1) = [float(i) for i in N[l - 1].split(',')]
	(x2, y2) = [float(i) for i in N[l].split(',')]
	a = math.sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2)
	b = math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
	c = math.sqrt((x2 - x0) ** 2 + (y2 - y0) ** 2)
	z = (a + b + c) / 2.0
	S = math.sqrt(z * (z - a) * (z - b) * (z - c))
	ans += S
print(ans)


def solve():
	from sys import stdin
	lines = stdin
	(x1, y1) = map(float, lines.readline().split(','))
	(x2, y2) = map(float, lines.readline().split(','))
	vx1 = x2 - x1
	vy1 = y2 - y1
	area = 0
	for line in lines:
		(x3, y3) = map(float, line.split(','))
		vx2 = x3 - x1
		vy2 = y3 - y1
		area += abs(vx1 * vy2 - vy1 * vx2) / 2
		(vx1, vy1) = (vx2, vy2)
	print(area)
solve()


def read():
	return list(map(float, input().split(',')))

def triArea(va, vb, vc):
	return abs((va[0] - vc[0]) * (vb[1] - vc[1]) - (va[1] - vc[1]) * (vb[0] - vc[0])) / 2
v1 = read()
va = read()
vb = read()
s = triArea(v1, va, vb)
while 1:
	try:
		va = vb
		vb = read()
		s += triArea(v1, va, vb)
	except:
		break
print(s)


def cross(x, y):
	return (x.conjugate() * y).imag

def area_polygon(points):
	area = 0
	n = len(points)
	for i in range(n):
		area += cross(points[i], points[(i + 1) % n])
	return area / 2
import sys
p = []
for line in sys.stdin:
	(x, y) = map(float, line.split(','))
	p.append(x + y * 1j)
print(abs(area_polygon(p)))


import sys
f = sys.stdin

def triangle_area(a, b, c):
	z = (a + b + c) / 2
	s = (z * (z - a) * (z - b) * (z - c)) ** 0.5
	return s
apexes = []
for line in f:
	(x, y) = map(float, line.split(','))
	apexes.append(x + y * 1j)
s = 0
for i in range(2, len(apexes)):
	s += triangle_area(abs(apexes[0] - apexes[i - 1]), abs(apexes[0] - apexes[i]), abs(apexes[i] - apexes[i - 1]))
print(s)


import sys
s = 0
p = [list(map(float, e.split(','))) for e in sys.stdin]
n = len(p)
for i in range(n):
	(a, b) = p[i]
	(c, d) = p[-~i % n]
	s += a * d - b * c
print(s / 2)


import sys
s = 0
p = [list(map(float, e.split(','))) for e in sys.stdin]
(x, y) = p[0]
for i in range(len(p) - 2):
	(a, b) = p[i + 1]
	(c, d) = p[i + 2]
	s += (a - x) * (d - y) - (b - y) * (c - x)
print(abs(s) / 2)


(x, y) = map(float, input().split(','))
(bx, by) = map(float, input().split(','))
s = 0
while 1:
	try:
		(xx, yy) = map(float, input().split(','))
	except:
		break
	a = ((bx - xx) ** 2 + (by - yy) ** 2) ** 0.5
	b = ((x - bx) ** 2 + (y - by) ** 2) ** 0.5
	c = ((x - xx) ** 2 + (y - yy) ** 2) ** 0.5
	z = (a + b + c) / 2
	s += (z * (z - a) * (z - b) * (z - c)) ** 0.5
	(bx, by) = (xx, yy)
print(s)


n = 0
S = 0
xylst = []
while True:
	try:
		(x, y) = map(float, input().split(','))
		xylst.append([x, y])
		n += 1
	except EOFError:
		break
for i in range(-1, n - 1):
	S = S + abs(xylst[i][0] * xylst[i + 1][1] - xylst[i][1] * xylst[i + 1][0]) / 2
print(S)


def calc_area(p):
	(n, s) = (len(p), 0)
	p.append(p[0])
	for i in range(n):
		s += (p[i].real - p[i + 1].real) * (p[i].imag + p[i + 1].imag)
	return abs(s) / 2
p = []
while True:
	try:
		(x, y) = list(map(float, input().split(',')))
	except EOFError:
		break
	p.append(complex(x, y))
print(calc_area(p))


(x, y) = map(float, input().split(','))
(bx, by) = map(float, input().split(','))
s = 0
while 1:
	try:
		(xx, yy) = map(float, input().split(','))
	except:
		break
	a = (pow(bx - xx, 2) + pow(by - yy, 2)) ** 0.5
	b = (pow(x - bx, 2) + pow(y - by, 2)) ** 0.5
	c = (pow(x - xx, 2) + pow(y - yy, 2)) ** 0.5
	z = (a + b + c) / 2
	s += (z * (z - a) * (z - b) * (z - c)) ** 0.5
	(bx, by) = (xx, yy)
print(s)


import sys
s = 0
p = [list(map(float, e.split(','))) for e in sys.stdin]
n = len(p)
for i in range(n):
	(a, b) = p[i]
	(c, d) = p[-~i % n]
	s += a * d - b * c
print(abs(s) / 2)


import sys, math, os
PYDEV = os.environ.get('PYDEV')
if PYDEV == 'True':
	sys.stdin = open('sample-input.txt', 'rt')

def poly_area(polygon, M):
	A = 0
	for i in range(M):
		(x1, y1) = (polygon[i][0], polygon[i][1])
		(x2, y2) = (polygon[(i + 1) % M][0], polygon[(i + 1) % M][1])
		A += x1 * y2 - x2 * y1
	return abs(A / 2)
poly = [[float(_) for _ in line.split(',')] for line in sys.stdin]
print('%.6f' % poly_area(poly, len(poly)))


import sys
readlines = sys.stdin.readlines
write = sys.stdout.write

def solve():
	P = []
	for line in readlines():
		(x, y) = map(float, line.split(','))
		P.append((x, y))
	N = len(P)
	s = 0
	for i in range(N):
		(x0, y0) = P[i - 1]
		(x1, y1) = P[i]
		s += x0 * y1 - x1 * y0
	write('%.16f\n' % (abs(s) / 2))
solve()


import math
import cmath

def dot(a: complex, b: complex):
	return (a.conjugate() * b).real

def cross(a: complex, b: complex):
	return (a.conjugate() * b).imag
p = []
try:
	while True:
		(x, y) = map(float, input().split(','))
		p.append(complex(x, y))
except EOFError:
	pass
S = 0
for i in range(1, len(p) - 1):
	S += cross(p[i] - p[0], p[i + 1] - p[0])
print(abs(S) / 2)


xlst = []
ylst = []
while True:
	try:
		(x, y) = map(float, input().split(','))
		xlst.append(x)
		ylst.append(y)
	except EOFError:
		break
num = len(xlst)
(cx, cy) = (sum(xlst) / num, sum(ylst) / num)
xlst.append(xlst[0])
ylst.append(ylst[0])
ans = 0
for i in range(num):
	(x1, y1, x2, y2) = (xlst[i], ylst[i], xlst[i + 1], ylst[i + 1])
	a = ((x2 - x1) ** 2 + (y2 - y1) ** 2) ** (1 / 2)
	b = ((x1 - cx) ** 2 + (y1 - cy) ** 2) ** (1 / 2)
	c = ((x2 - cx) ** 2 + (y2 - cy) ** 2) ** (1 / 2)
	z = (a + b + c) / 2
	s = (z * (z - a) * (z - b) * (z - c)) ** (1 / 2)
	ans += s
print(ans)


import sys
s = 0
p = [list(map(float, e.split(','))) for e in sys.stdin]
(x, y) = p[0]
print(abs(sum(((p[i][0] - x) * (p[i + 1][1] - y) - (p[i][1] - y) * (p[i + 1][0] - x) for i in range(1, len(p) - 1)))) / 2)


def norm(c):
	a = abs(c)
	return a * a

def dot_product(a, b):
	return (a.conjugate() * b).real

def cross_product(a, b):
	return (a.conjugate() * b).imag

def projection(p, b):
	return b * dot_product(p, b) / norm(b)
P = []
try:
	while True:
		(x, y) = map(float, input().split(','))
		P.append(complex(x, y))
except EOFError:
	pass
N = len(P)
total = 0.0
for i in range(1, N - 1):
	(a, b, c) = (P[0], P[i], P[i + 1])
	S = abs(cross_product(b - a, c - a)) / 2
	total += S
print('%.6f' % total)


import math
import cmath

def area(b, c):
	theta = cmath.phase(b)
	C = c * complex(math.cos(-theta), math.sin(-theta))
	return abs(b) * C.imag / 2
P = []
try:
	while True:
		(x, y) = map(float, input().split(','))
		P.append(complex(x, y))
except EOFError:
	pass
except ValueError:
	pass
P.append(P[0])
N = len(P)
total = 0.0
for i in range(0, N - 1):
	(b, c) = (P[i], P[i + 1])
	total += area(b, c)
print(abs(total))


def cross_product(a, b):
	return (a.conjugate() * b).imag
P = []
try:
	while True:
		(x, y) = map(float, input().split(','))
		P.append(complex(x, y))
except EOFError:
	pass
N = len(P)
total = 0.0
for i in range(1, N - 1):
	(a, b, c) = (P[0], P[i], P[i + 1])
	total += cross_product(b - a, c - a)
print('%.6f' % (abs(total) / 2.0))


a = []
try:
	while True:
		(x, y) = map(float, input().split(','))
		a.append(complex(x, y))
except EOFError:
	pass
n = len(a)
ans = 0.0
p = a[0]
for i in range(n - 2):
	(q, r) = (a[i + 1], a[i + 2])
	ans += ((q - p).conjugate() * (r - p)).imag / 2
print(abs(ans))


import math

def angle(i1, j1, i2, j2, i3, j3):
	a = math.sqrt((i1 - i2) ** 2 + (j1 - j2) ** 2)
	b = math.sqrt((i2 - i3) ** 2 + (j2 - j3) ** 2)
	c = math.sqrt((i3 - i1) ** 2 + (j3 - j1) ** 2)
	z = (a + b + c) / 2
	S = math.sqrt(z * (z - a) * (z - b) * (z - c))
	return S
ans = 0
(x1, y1) = map(float, input().split(','))
(x2, y2) = map(float, input().split(','))
while True:
	try:
		(x3, y3) = map(float, input().split(','))
	except EOFError:
		break
	ans += angle(x1, y1, x2, y2, x3, y3)
	x2 = x3
	y2 = y3
print('{:.6f}'.format(ans))