Nowadays all circuses in Berland have a round arena with diameter 13 meters, but in the past things were different.

In Ancient Berland arenas in circuses were shaped as a regular (equiangular) polygon, the size and the number of angles could vary from one circus to another. In each corner of the arena there was a special pillar, and the rope strung between the pillars marked the arena edges.

Recently the scientists from Berland have discovered the remains of the ancient circus arena. They found only three pillars, the others were destroyed by the time.

You are given the coordinates of these three pillars. Find out what is the smallest area that the arena could have.

Input

The input file consists of three lines, each of them contains a pair of numbers –– coordinates of the pillar. Any coordinate doesn't exceed 1000 by absolute value, and is given with at most six digits after decimal point.

Output

Output the smallest possible area of the ancient arena. This number should be accurate to at least 6 digits after the decimal point. It's guaranteed that the number of angles in the optimal polygon is not larger than 100.

Examples

Input

0.000000 0.000000
1.000000 1.000000
0.000000 1.000000


Output

1.00000000

Difficulty: HARD
Tags: Geometry

Mathematics

Starter code:

Solutions:
from math import *

def g(x, y):
	if y < 0.001:
		return x
	else:
		return g(y, fmod(x, y))
p = [list(map(float, input().split())) for i in range(3)]
(a, b, c) = [hypot(x1 - x2, y1 - y2) for ((x1, y1), (x2, y2)) in [(p[0], p[1]), (p[0], p[2]), (p[1], p[2])]]
(A, B, C) = [acos((y * y + z * z - x * x) / 2 / z / y) for (x, y, z) in [(a, b, c), (b, c, a), (c, a, b)]]
R = a / 2 / sin(A)
u = 2 * g(A, g(B, C))
print(round(R * R * pi / u * sin(u), 7))


import math

def gcd(x, y):
	epsilon = 0.0001
	while x > epsilon and y > epsilon:
		if x > y:
			x -= math.floor(x / y) * y
		else:
			y -= math.floor(y / x) * x
	return x + y
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
a = math.sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
b = math.sqrt((x2 - x3) ** 2 + (y2 - y3) ** 2)
c = math.sqrt((x1 - x3) ** 2 + (y1 - y3) ** 2)
angle_a = math.acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c))
angle_b = math.acos((a ** 2 + c ** 2 - b ** 2) / (2 * a * c))
angle_c = math.acos((a ** 2 + b ** 2 - c ** 2) / (2 * a * b))
s = 0.5 * a * b * math.sin(angle_c)
r = a * b * c / (4 * s)
n = math.pi / gcd(angle_a, gcd(angle_b, angle_c))
print('%.6f' % (n * 0.5 * r * r * math.sin(2 * math.pi / n)))


from math import sin, cos, pi, sqrt
NUMPOINTS = 3
MAXSIDES = 100
PRECISION = 4
DEBUG = False

def log(arg, highlight=False):
	if not DEBUG:
		return
	if highlight:
		print('\x1b[4m' + str(arg) + '\x1b[0m')
	else:
		print(arg)
p = []
epsilon = 10 ** (-1 * PRECISION)
log('Error: {}'.format(epsilon))
log('Source points', True)
for i in range(NUMPOINTS):
	s = [float(n) for n in input().strip().split()]
	p.append((s[0], s[1]))
log(p)
log('Permuted points', True)
if p[1][0] == p[0][0]:
	tmp = p[2]
	p[2] = p[1]
	p[1] = tmp
if p[2][0] == p[1][0]:
	tmp = p[2]
	p[2] = p[0]
	p[0] = tmp
log(p)
log('Line slope coefficients', True)
ma = (p[1][1] - p[0][1]) / (p[1][0] - p[0][0])
mb = (p[2][1] - p[1][1]) / (p[2][0] - p[1][0])
log('ma = {}, mb = {}'.format(ma, mb))
log('Circumcircle center', True)
x = (ma * mb * (p[0][1] - p[2][1]) + mb * (p[0][0] + p[1][0]) - ma * (p[1][0] + p[2][0])) / (2 * (mb - ma))
y = -1 * (x - (p[0][0] + p[1][0]) / 2) / ma + (p[0][1] + p[1][1]) / 2
log('x = {}, y = {}'.format(x, y))
log('Point offset', True)
(tmp, p) = (p, [])
for point in tmp:
	p.append((point[0] - x, point[1] - y))
log(p)
for n in range(3, MAXSIDES + 1):
	log('Number of sides: {}'.format(n), True)
	matched = 1
	d = 2 * pi / n
	sind = sin(d)
	cosd = cos(d)
	log('d = {}, sind = {}, cosd = {}'.format(d, sind, cosd))
	pd = p[0]
	for i in range(1, n):
		pd = (pd[0] * cosd - pd[1] * sind, pd[0] * sind + pd[1] * cosd)
		log('i = {}, p = {}'.format(i, pd))
		for point in p[1:]:
			delta = sqrt((point[0] - pd[0]) ** 2 + (point[1] - pd[1]) ** 2)
			log('\tpoint = {}, delta = {}'.format(point, delta))
			if delta < epsilon:
				matched += 1
	if matched == NUMPOINTS:
		break
radius = sqrt(p[0][0] ** 2 + p[0][1] ** 2)
area = n * radius ** 2 * sind / 2
print(area)


from math import sqrt, asin, pi, sin, cos
eps = 1e-06

def dist2(ax, ay, bx, by):
	return (ax - bx) ** 2 + (ay - by) ** 2

def cross_prod(ax, ay, bx, by):
	return ax * by - ay * bx

def inner_prod(ax, ay, bx, by):
	return ax * bx + ay * by

def find(x, y, s, c):
	for i in range(len(s)):
		if abs(x - s[i]) < eps and abs(y - c[i]) < eps:
			return True
	return False

def pool(x):
	if abs(x) < eps:
		return 1.0
	if x < 0:
		return x / pi + 2
	return x / pi

def main():
	(Ax, Ay) = map(float, input().split())
	(Bx, By) = map(float, input().split())
	(Cx, Cy) = map(float, input().split())
	D = 2 * (Ax * (By - Cy) + Bx * (Cy - Ay) + Cx * (Ay - By))
	Ox = ((Ax ** 2 + Ay ** 2) * (By - Cy) + (Bx ** 2 + By ** 2) * (Cy - Ay) + (Cx ** 2 + Cy ** 2) * (Ay - By)) / D
	Oy = ((Ax ** 2 + Ay ** 2) * (Cx - Bx) + (Bx ** 2 + By ** 2) * (Ax - Cx) + (Cx ** 2 + Cy ** 2) * (Bx - Ax)) / D
	R2 = dist2(Ox, Oy, Ax, Ay)
	s1 = cross_prod(Ax - Ox, Ay - Oy, Bx - Ox, By - Oy) / R2
	c1 = inner_prod(Ax - Ox, Ay - Oy, Bx - Ox, By - Oy) / R2
	s2 = cross_prod(Ax - Ox, Ay - Oy, Cx - Ox, Cy - Oy) / R2
	c2 = inner_prod(Ax - Ox, Ay - Oy, Cx - Ox, Cy - Oy) / R2
	for n in range(3, 101):
		x = list(range(n))
		for j in range(len(x)):
			x[j] = x[j] * (2 * pi / n)
		s = list(map(sin, x))
		c = list(map(cos, x))
		if find(s1, c1, s, c) and find(s2, c2, s, c):
			area = 0.5 * n * R2 * sin(2 * pi / n)
			print('%.8f' % area)
			break
main()


from math import *

def gcd(x, y):
	if y < 0.001:
		return x
	return gcd(y, fmod(x, y))
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
a = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
b = sqrt((x2 - x3) ** 2 + (y2 - y3) ** 2)
c = sqrt((x3 - x1) ** 2 + (y3 - y1) ** 2)
p = float(a + b + c) / 2
S = sqrt(p * (p - a) * (p - b) * (p - c))
r = float(a * b * c) / float(4 * S)
anga = float(acos(float(b ** 2 + c ** 2 - a ** 2) / float(2 * b * c)))
angb = float(acos(float(c ** 2 + a ** 2 - b ** 2) / float(2 * c * a)))
angc = float(acos(float(a ** 2 + b ** 2 - c ** 2) / float(2 * a * b)))
n = pi / gcd(anga, gcd(angb, angc))
ans = float(n * r * r * sin(float(2 * pi) / n)) / 2
print('%.8f' % ans)


import sys, math

def distance(a, b, c, d):
	return ((d - b) ** 2 + (c - a) ** 2) ** 0.5

def gcd(a, b):
	if a < b:
		return gcd(b, a)
	if abs(b) < 0.001:
		return a
	else:
		return gcd(b, a - math.floor(a / b) * b)
ls = [i.split() for i in sys.stdin.readlines()]
(a1, a2) = ls[0]
(b1, b2) = ls[1]
(c1, c2) = ls[2]
a1 = float(a1)
a2 = float(a2)
b1 = float(b1)
b2 = float(b2)
c1 = float(c1)
c2 = float(c2)
A = distance(b1, b2, c1, c2)
B = distance(a1, a2, c1, c2)
C = distance(b1, b2, a1, a2)
(A, B, C) = sorted([A, B, C])
alpha = math.acos((B ** 2 + C ** 2 - A ** 2) / (2 * B * C))
beta = math.acos((C ** 2 + A ** 2 - B ** 2) / (2 * A * C))
gamma = math.acos((B ** 2 + A ** 2 - C ** 2) / (2 * B * A))
theta = gcd(gcd(alpha, beta), gamma)
n = math.pi / theta
r = A / (2 * math.sin(alpha))
area = r ** 2 * 0.5 * math.sin(2 * theta) * n
print(area)


import math

def distance(a, b):
	return math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)

def calr(a, b, c):
	o = math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)
	p = math.sqrt((a[0] - c[0]) ** 2 + (a[1] - c[1]) ** 2)
	q = math.sqrt((c[0] - b[0]) ** 2 + (c[1] - b[1]) ** 2)
	y = (o + p + q) / 2
	x = math.sqrt(y * (y - o) * (y - p) * (y - q))
	r = o * p * q / (4 * x)
	return ([x, y], r)

def caln(m, n, o):
	for i in range(1, 101):
		x = i * n / m
		y = i * o / m
		if abs(x - round(x)) < 0.001 and abs(y - round(y)) < 0.001:
			num = round(i + x + y)
			angle = 2 * math.pi / num
			return (angle, num)
a = list(map(float, input().split()))
b = list(map(float, input().split()))
c = list(map(float, input().split()))
(center, r) = calr(a, b, c)
length = [distance(a, b), distance(b, c), distance(a, c)]
length.sort()
theta1 = 2 * math.asin(length[0] / (2 * r))
theta2 = 2 * math.asin(length[1] / (2 * r))
theta3 = 2 * math.pi - theta1 - theta2
(angle, n) = caln(theta1, theta2, theta3)
square = 0.5 * r ** 2 * math.sin(angle) * n
print(square)


import math

class Point:

	def __init__(self, x, y):
		self.x = x
		self.y = y

	def plus(self, point):
		return Point(self.x + point.x, self.y + point.y)

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

	def minus(self, point):
		return self.plus(point.negate())

	def multiply(self, factor):
		return Point(self.x * factor, self.y * factor)

	def toString(self):
		return 'Point(' + str(self.x) + ',' + str(self.y) + ')'

class Vector:

	def __init__(self, a, b):
		self.a = a
		self.b = b

	def norm(self):
		p = self.b.minus(self.a)
		p = Point(-p.y, p.x)
		q = self.a.plus(self.b).multiply(0.5)
		p = p.plus(q)
		return Vector(q, p)

	def toString(self):
		return 'Vector(' + self.a.toString() + ',' + self.b.toString() + ')'

def solve(a, b, c, d, e, f):
	first = [a, b, c]
	first = [x / a for x in first]
	second = [d, e, f]
	for i in range(len(second)):
		second[i] -= d * first[i]
	e = second[1]
	second = [x / e for x in second]
	b = first[1]
	for i in range(len(first)):
		first[i] -= b * second[i]
	return (first[2], second[2])

def getCrossing(vA, vB):
	vA.c = vA.b
	vA.b = vA.b.minus(vA.a)
	vB.c = vB.b
	vB.b = vB.b.minus(vB.a)
	(m, n) = solve(vA.b.x, -vB.b.x, vB.a.x - vA.a.x, vA.b.y, -vB.b.y, vB.a.y - vA.a.y)
	center = vA.a.plus(vA.b.multiply(m))
	return center

def vsize(point):
	return math.sqrt(point.x ** 2 + point.y ** 2)

def getAngle(p1, p2, p3):
	a = vsize(p2.minus(p1))
	b = vsize(p3.minus(p1))
	c = vsize(p3.minus(p2))
	cosgamma = (c ** 2 - a ** 2 - b ** 2) / (-2 * a * b)
	cosgamma = max(cosgamma, -1)
	cosgamma = min(cosgamma, 1)
	gamma = math.acos(cosgamma)
	return gamma

def roundx(digs, num):
	factor = 10 ** digs
	num *= factor
	num = round(num)
	num /= factor
	return num

def getCenter(p1, p2, p3):
	v1 = Vector(p1, p2)
	v1 = v1.norm()
	v2 = Vector(p1, p3)
	v2 = v2.norm()
	cross = getCrossing(v1, v2)
	return Point(roundx(6, cross.x), roundx(6, cross.y))

def getMeasure(center, point, angle):
	diam = vsize(point.minus(center))
	return 0.5 * diam * diam * math.sin(angle)

def integers(nums):
	for i in nums:
		if not i.is_integer():
			return False
	else:
		return True

def getCommon(angles):
	m = min(angles[0], angles[1], angles[2])
	angles = [x / m for x in angles]
	for n in range(1000):
		if n == 0:
			continue
		ang2 = [roundx(3, x * n) for x in angles]
		if integers(ang2):
			nn = n
			break
	return m / nn

def getArea(center, points):
	a1 = getAngle(center, points[0], points[1])
	a2 = getAngle(center, points[1], points[2])
	a3 = getAngle(center, points[0], points[2])
	a4 = 2 * math.pi
	angles = [a1, a2, a3, a4]
	common = getCommon(angles)
	cols = round(2 * math.pi / common)
	common = 2 * math.pi / cols
	factor = 100000000
	area = cols * getMeasure(center, points[0], common)
	area *= factor
	area = round(area)
	area /= factor
	return area
points = []
for i in range(3):
	line = input()
	(a, b) = line.split(' ')
	p = Point(float(a), float(b))
	points.append(p)
center = getCenter(points[0], points[1], points[2])
area = getArea(center, points)
print(area)


import math
(array, newarray) = ([], [0] * 3)
for x in range(3):
	n = input().split()
	m = list(map(float, n))
	array.append(m)

def magn_sq(point):
	return point[0] ** 2 + point[1] ** 2

def dist_sq(point1, point2):
	return magn_sq([point1[0] - point2[0], point1[1] - point2[1]])

def circumcenter(point1, point2, point3):
	point_1 = [point1[0] - point3[0], point1[1] - point3[1]]
	point_2 = [point2[0] - point3[0], point2[1] - point3[1]]
	const = 2 * (point_1[0] * point_2[1] - point_1[1] * point_2[0])
	xcoord = (point_2[1] * magn_sq(point_1) - point_1[1] * magn_sq(point_2)) / const
	ycoord = (point_1[0] * magn_sq(point_2) - point_2[0] * magn_sq(point_1)) / const
	return [xcoord + point3[0], ycoord + point3[1]]

def checkInt(a):
	r = int(round(a, 0))
	return abs(r - a) / a < 0.0001
center = circumcenter(array[0], array[1], array[2])
center = list(map(lambda x: round(x, 1), center))
for x in array:
	x[0] = x[0] - center[0]
	x[1] = x[1] - center[1]
radius = math.sqrt(magn_sq(array[0]))
radius = round(radius, 6)
for x in range(3):
	newarray[x] = math.sqrt(dist_sq(array[x], array[(x + 1) % 3]))
for counter in range(3):
	if checkInt(newarray[counter]):
		newarray[counter] = round(newarray[counter], 0)

def distToAngle(p):
	if p / (2 * radius) > 1:
		return 0.5
	return math.asin(p / (2 * radius)) / math.pi
newarray = list(map(distToAngle, newarray))

def gcf(a, b):
	if a >= b:
		if a - b < 0.001:
			return a
		else:
			return gcf(a - b, b)
	else:
		return gcf(b, a)
gcd = 1 / gcf(gcf(newarray[0], newarray[1]), newarray[2])
i = 1
while not checkInt(i * gcd):
	i += 1
t = i * gcd
numsides = int(round(t, 0))
area = 0.5 * numsides * radius ** 2 * math.sin(2 * math.pi / numsides)
if area < 10:
	area = round(area, 0)
print(area)


import math
from math import atan

def normal(p1, p2):
	(x1, y1) = p1
	(x2, y2) = p2
	angle = atan((y2 - y1) / (x2 - x1)) + math.pi if x2 - x1 else math.pi / 2
	return (math.cos(angle), math.sin(angle), -((x1 + x2) * math.cos(angle) + (y1 + y2) * math.sin(angle)) / 2)

def center(p1, p2, p3):
	(a1, b1, c1) = normal(p1, p2)
	(a2, b2, c2) = normal(p2, p3)
	return ((b1 * c2 - b2 * c1) / (a1 * b2 - a2 * b1), (c1 * a2 - c2 * a1) / (a1 * b2 - a2 * b1))

def dist(p1, p2):
	(x1, y1) = p1
	(x2, y2) = p2
	return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)

def cp(center, radius, angle):
	(cx, cy) = center
	return (cx + math.cos(angle) * radius, cy + math.sin(angle) * radius)

def angle_for_cp(center, p):
	(cx, cy) = center
	(px, py) = p
	if px == cx:
		return math.pi / 2 if py > cy else -math.pi / 2
	elif px > cx:
		res = math.atan((py - cy) / (px - cx))
		if py < cy:
			res += math.pi * 2
	else:
		res = math.atan((py - cy) / (px - cx)) + math.pi
	return res

def parse_point():
	(px, py) = input().split(' ')
	return (float(px), float(py))
points = None
if points is None:
	points = [parse_point() for i in range(3)]
c = center(*points)
rad = dist(points[0], c)
alpha1 = angle_for_cp(c, points[0])

def dist_for_count(count):
	(index1, dist1) = min(((index, dist(points[1], cp(c, rad, math.pi * 2 / count * index + alpha1))) for index in range(1, count)), key=lambda item: item[1])
	(index2, dist2) = min(((index, dist(points[2], cp(c, rad, math.pi * 2 / count * index + alpha1))) for index in range(1, count) if index != index1), key=lambda item: item[1])
	return dist1 + dist2
best = next(((count,) for count in range(3, 101) if dist_for_count(count) < 0.001))

def square(points_count, radius):
	angle = math.pi * 2 / points_count
	tr_square = radius ** 2 * math.sin(angle / 2) * math.cos(angle / 2)
	return tr_square * points_count
print(square(best[0], rad))


import math
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())

def compute_triangle_area(x1, y1, x2, y2, x3, y3):
	return abs((x2 - x1) * (y3 - y1) - (x3 - x1) * (y2 - y1)) / 2
(a, b, c) = (math.hypot(x2 - x1, y2 - y1), math.hypot(x3 - x2, y3 - y2), math.hypot(x1 - x3, y1 - y3))
R = a * b * c / (4 * compute_triangle_area(x1, y1, x2, y2, x3, y3))
(A, B, C) = (math.acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c)), math.acos((a ** 2 + c ** 2 - b ** 2) / (2 * a * c)), math.acos((a ** 2 + b ** 2 - c ** 2) / (2 * a * b)))

def float_gcd(a, b, tol=0.0001):
	t = min(abs(a), abs(b))
	while abs(b) > tol:
		(a, b) = (b, a % b)
	return a
n = math.pi / float_gcd(float_gcd(A, B), C)
S = n * R ** 2 * math.sin(2 * math.pi / n) / 2
print(S)


import math

def dist(x1, y1, x2, y2):
	return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)

def angle(a, b, c):
	return math.acos((a * a + b * b - c * c) / (2 * a * b))

def f(a, b):
	if b > a:
		return f(b, a)
	if abs(b) < 1 / 10000:
		return a
	else:
		k = int(a / b)
		a -= k * b
		return f(b, a)
x = [0] * 3
y = [0] * 3
len = [0] * 3
ang = [0] * 3
for i in range(3):
	(x[i], y[i]) = map(float, input().split())
for i in range(3):
	len[i] = dist(x[i], y[i], x[(i + 1) % 3], y[(i + 1) % 3])
len.sort()
for i in range(3):
	ang[i] = angle(len[i], len[(i + 1) % 3], len[(i + 2) % 3])
ang.sort()
an = f(f(ang[0], ang[1]), ang[2]) * 2
n = 2 * math.pi / an
a = len[0] * math.sin(an / 2) / math.sin(ang[0])
s = n * a * a / (4 * math.tan(an / 2))
print('%.9f' % s)


import math
room = []
i = 0
while i < 3:
	i = i + 1
	room.append(list(map(float, input().split())))
k1 = (room[0][1] - room[1][1]) / (room[0][0] - room[1][0] + 1e-10)
k1 = -(1 / k1)
mid1 = [(room[0][0] + room[1][0]) / 2, (room[0][1] + room[1][1]) / 2]
b1 = mid1[1] - mid1[0] * k1
k2 = (room[0][1] - room[2][1]) / (room[0][0] - room[2][0] + 1e-10)
k2 = -(1 / k2)
mid2 = [(room[0][0] + room[2][0]) / 2, (room[0][1] + room[2][1]) / 2]
b2 = mid2[1] - mid2[0] * k2
x = (b2 - b1) / (k1 - k2)
y = k1 * x + b1
a = math.sqrt(pow(room[0][1] - room[1][1], 2) + pow(room[0][0] - room[1][0], 2))
b = math.sqrt(pow(room[0][1] - room[2][1], 2) + pow(room[0][0] - room[2][0], 2))
r = math.sqrt(pow(y - room[1][1], 2) + pow(x - room[1][0], 2))
cos1 = (2 * r * r - a * a) / (2 * r * r)
cos2 = (2 * r * r - b * b) / (2 * r * r)
cos1 = float('%.4f' % cos1)
cos2 = float('%.4f' % cos2)
a = 2 * math.pi / math.acos(cos1)
b = 2 * math.pi / math.acos(cos2)
a = 1 / a
b = 1 / b
i = 1
while i < 101:
	m = a * i
	if abs(m - int(m)) < 0.008 or abs(m - int(m) - 1) < 0.008:
		break
	i = i + 1
j = 1
while j < 101:
	m = b * j
	if abs(m - int(m)) < 0.008 or abs(m - int(m) - 1) < 0.008:
		break
	j = j + 1

def f(a, b):
	if a < b:
		c = a
		a = b
		b = c
	if a % b == 0:
		return b
	else:
		return f(a % b, b)
c = i * j / f(i, j)
if c > 100:
	c = 100
s = c * r * r * math.sin(2 * math.pi / c) / 2
print('%.6f' % s)


import math
eps = 0.0001
p = [input().split(' '), input().split(' '), input().split(' ')]
p.append(p[0])
for i in range(4):
	for j in range(2):
		p[i][j] = float(p[i][j])
s = [math.sqrt((p[i][0] - p[i + 1][0]) ** 2 + (p[i][1] - p[i + 1][1]) ** 2) for i in range(3)]
s.append(s[0])
s.append(s[1])
semi = (s[0] + s[1] + s[2]) / 2
a = [math.acos((-s[i] ** 2 + s[i + 1] ** 2 + s[i + 2] ** 2) / (2 * s[i + 1] * s[i + 2])) for i in range(3)]

def gcd(x, y):
	while abs(x) > eps and abs(y) > eps:
		if x > y:
			x -= math.floor(x / y) * y
		else:
			y -= math.floor(y / x) * x
	return x + y
R = s[0] * s[1] * s[2] / 4 / math.sqrt(semi)
for i in range(3):
	R /= math.sqrt(semi - s[i])
n = round(math.pi / gcd(a[0], gcd(a[1], a[2])))
A = n / 2 * R ** 2 * math.sin(2 * math.pi / n)
print(A)


import math

def stupidSolve(a, b, c, p, q, r):
	x0 = (c * q - b * r) / (a * q - b * p)
	y0 = (c * p - a * r) / (b * p - a * q)
	return (x0, y0)

def angleBetween3Points(x0, y0, x1, y1, x2, y2):
	result = math.atan2(y2 - y0, x2 - x0) - math.atan2(y1 - y0, x1 - x0)
	result = abs(result)
	if result > math.pi:
		result = 2 * math.pi - result
	return result

def areaRegularPolygonCircumradius(radius, numsides):
	area = radius * radius * numsides
	area *= math.sin(math.pi * 2 / numsides)
	area /= 2
	return area

def smallestPossibleNumberOfSides(a1, a2, a3):
	for numsides in range(3, 101):
		a0 = 2 * math.pi / numsides
		c1 = round(a1 / a0, 5)
		c2 = round(a2 / a0, 5)
		c3 = round(a3 / a0, 5)
		if c1 == int(c1) and c2 == int(c2) and (c3 == int(c3)):
			return numsides
(x1, y1) = tuple(map(float, input().split()))
(x2, y2) = tuple(map(float, input().split()))
(x3, y3) = tuple(map(float, input().split()))
a = 2 * (x2 - x1)
b = 2 * (y2 - y1)
c = x2 * x2 + y2 * y2 - (x1 * x1 + y1 * y1)
p = 2 * (x3 - x1)
q = 2 * (y3 - y1)
r = x3 * x3 + y3 * y3 - (x1 * x1 + y1 * y1)
(x0, y0) = stupidSolve(a, b, c, p, q, r)
OAB = angleBetween3Points(x0, y0, x1, y1, x2, y2)
OAC = angleBetween3Points(x0, y0, x1, y1, x3, y3)
OBC = angleBetween3Points(x0, y0, x2, y2, x3, y3)
numsides = smallestPossibleNumberOfSides(OAB, OAC, OBC)
radius = math.sqrt((x1 - x0) * (x1 - x0) + (y1 - y0) * (y1 - y0))
res = areaRegularPolygonCircumradius(radius, numsides)
print('{:.6f}'.format(res))


import math
EPSILON = 0.0001

def calRadians(x1, y1, x2, y2):
	product = x1 * x2 + y1 * y2
	norm1 = (x1 * x1 + y1 * y1) ** 0.5
	norm2 = (x2 * x2 + y2 * y2) ** 0.5
	cosVal = max(-1, min(1, product / norm1 / norm2))
	return math.acos(cosVal)

def calCentre(x1, y1, x2, y2, x3, y3):
	(a, b, c, d) = (x1 - x2, y1 - y2, x1 - x3, y1 - y3)
	e = (x1 * x1 - x2 * x2 - (y2 * y2 - y1 * y1)) / 2
	f = (x1 * x1 - x3 * x3 - (y3 * y3 - y1 * y1)) / 2
	ox = -(d * e - b * f) / (b * c - a * d)
	oy = -(a * f - c * e) / (b * c - a * d)
	return (ox, oy)
(x1, y1) = map(float, input().split(' '))
(x2, y2) = map(float, input().split(' '))
(x3, y3) = map(float, input().split(' '))
(ox, oy) = calCentre(x1, y1, x2, y2, x3, y3)
alpha1 = calRadians(x1 - ox, y1 - oy, x2 - ox, y2 - oy)
alpha2 = calRadians(x1 - ox, y1 - oy, x3 - ox, y3 - oy)
for i in range(3, 101):
	unit = 2 * math.pi / i
	if abs(alpha1 / unit - round(alpha1 / unit)) > EPSILON:
		continue
	if abs(alpha2 / unit - round(alpha2 / unit)) > EPSILON:
		continue
	radius = ((x1 - ox) ** 2 + (y1 - oy) ** 2) ** 0.5
	area = 0.5 * radius * radius * math.sin(unit) * i
	print(area)
	exit()


import math
import sys
(a, b) = map(float, input().split())
(c, d) = map(float, input().split())
(e, f) = map(float, input().split())
p = c - a
q = d - b
r = c * c + d * d - a * a - b * b
s = e - a
t = f - b
u = e * e + f * f - a * a - b * b
y0 = (p * u - r * s) / (2 * (p * t - q * s))
x0 = (r - 2 * q * y0) / (2 * p)
radius = math.sqrt((x0 - a) ** 2 + (y0 - b) ** 2)
dx = a - x0
dy = b - y0
angles = list(map(lambda t: math.atan2(*t), [(b - y0, a - x0), (d - y0, c - x0), (f - y0, e - x0)]))
angle_i = (2 * math.pi + angles[1] - angles[0]) % (2 * math.pi)
angle_j = (2 * math.pi + angles[2] - angles[0]) % (2 * math.pi)
for n in range(3, 101):
	slice = 2 * math.pi / n
	i = angle_i / slice
	j = angle_j / slice
	if abs(round(i) - i) > 1e-05 or abs(round(j) - j) > 1e-05:
		continue
	print(n, i, j, angle_i / slice, angle_j / slice, file=sys.stderr)
	area = radius ** 2 * n * math.sin(math.pi / n) * math.cos(math.pi / n)
	print(area)
	sys.exit()


import sys, math
input = sys.stdin.readline
from collections import defaultdict

def dist(A, B):
	return math.sqrt((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2)
PI = 3.141592653589793
A = list(map(float, input().split()))
B = list(map(float, input().split()))
C = list(map(float, input().split()))
a = dist(A, B)
b = dist(B, C)
c = dist(C, A)
s = (a + b + c) / 2
area = math.sqrt(s * (s - a) * (s - b) * (s - c))
r = a * b * c / (4 * area)

def angle(a, b, c):
	return math.acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c))
aA = angle(a, b, c)
aB = angle(b, c, a)
aC = angle(c, a, b)

def gcd(x, y):
	while abs(x) > 10 ** (-4) and abs(y) > 10 ** (-4):
		if x > y:
			x -= x // y * y
		else:
			y -= y // x * x
	return x + y
n = PI / gcd(gcd(aA, aB), aC)
print(round(n / 2 * r ** 2 * math.sin(2 * PI / n), 6))


import math
DEBUG = False

def area(d):
	if len(d) < 3:
		return False
	a = 0.0
	p = 0.5 * (d[0] + d[1] + d[2])
	a = math.sqrt(p * (p - d[0]) * (p - d[1]) * (p - d[2]))
	return a

def circumcircle(x, y):
	distance = euclidean(x, y)
	triangle_area = area(distance)
	return distance[0] * distance[1] * distance[2] / (4 * triangle_area)

def euclidean(x, y):
	d = []
	d.append(math.sqrt((x[0] - x[1]) ** 2 + (y[0] - y[1]) ** 2))
	d.append(math.sqrt((x[0] - x[2]) ** 2 + (y[0] - y[2]) ** 2))
	d.append(math.sqrt((x[1] - x[2]) ** 2 + (y[1] - y[2]) ** 2))
	return d

def normal_sin_value(sin_value):
	if sin_value > 1:
		return 1.0
	elif sin_value < -1:
		return -1.0
	else:
		return sin_value

def centerAngle(d, radius):
	angle = []
	angle.append(2 * math.asin(normal_sin_value(d[0] / (2 * radius))))
	angle.append(2 * math.asin(normal_sin_value(d[1] / (2 * radius))))
	angle.append(2 * math.pi - angle[0] - angle[1])
	if DEBUG:
		print(sum([a for a in angle]))
	return angle

def gcd(a, b):
	if a < 0.01:
		return b
	else:
		return gcd(math.fmod(b, a), a)

def main():
	x = []
	y = []
	for i in range(3):
		temp_input = input().split()
		x.append(float(temp_input[0]))
		y.append(float(temp_input[1]))
	edge_length = euclidean(x, y)
	triangle_area = area(edge_length)
	circumcircle_radius = circumcircle(x, y)
	angle = centerAngle(edge_length, circumcircle_radius)
	gcd_angle = gcd(gcd(angle[0], angle[1]), angle[2])
	result = 2 * math.pi / gcd_angle * circumcircle_radius * math.sin(gcd_angle) * circumcircle_radius * 0.5
	if DEBUG:
		print('circumcircle_radius', circumcircle_radius)
		print('totoal_angle', angle)
		print('gcd_angle', gcd_angle)
		print('len', edge_length)
	print('{:.8f}'.format(result))
main()


from math import acos, sin, pi

def f(x, y):
	return sum(((i - j) ** 2 for (i, j) in zip(x, y)))

def g(a, b, c):
	return acos((b + c - a) / (2 * (b * c) ** 0.5)) / pi

def h(x, n):
	return 0.01 < x * n % 1 < 0.99
(x, y, z) = (tuple(map(float, input().split())) for i in range(3))
(a, b, c) = (f(x, y), f(x, z), f(y, z))
(A, B) = (g(a, b, c), g(b, a, c))
(r, n) = (a / (8 * sin(A * pi) ** 2), 3)
while h(A, n) or h(B, n):
	n += 1
print(round(n * r * sin(2 * pi / n), 8))


from math import *

def norm(v):
	return sqrt(v[0] * v[0] + v[1] * v[1])

def sub(v1, v2):
	return (v1[0] - v2[0], v1[1] - v2[1])

def add(v1, v2):
	return (v1[0] + v2[0], v1[1] + v2[1])

def mult(v, d):
	return (v[0] * d, v[1] * d)

def div(v, d):
	return (v[0] / d, v[1] / d)

def dot(v1, v2):
	return v1[0] * v2[0] + v1[1] * v2[1]

def get_angle(v1, v2):
	temp = dot(v1, v2) / norm(v1) / norm(v2)
	temp = max(min(temp, 1.0), -1.0)
	return acos(temp)
l1 = input().split(' ')
l2 = input().split(' ')
l3 = input().split(' ')
p1 = (float(l1[0]), float(l1[1]))
p2 = (float(l2[0]), float(l2[1]))
p3 = (float(l3[0]), float(l3[1]))
mid1 = div(add(p1, p2), 2.0)
mid2 = div(add(p2, p3), 2.0)
dir1 = (p1[1] - p2[1], p2[0] - p1[0])
dir2 = (p2[1] - p3[1], p3[0] - p2[0])
a = mid1[0]
b = mid1[1]
x = dir1[0]
y = dir1[1]
c = mid2[0]
d = mid2[1]
w = dir2[0]
v = dir2[1]
t = (c * v - d * w + b * w - a * v) / (x * v - w * y)
center = add(mid1, mult(dir1, t))
radius = sub(p1, center)
radiusnorm = norm(radius)
r1 = radius
r2 = sub(p2, center)
r3 = sub(p3, center)
a1 = get_angle(r1, r2)
a2 = get_angle(r1, r3)
for i in range(3, 101):
	innerangle = 2.0 * pi / float(i)
	area = radiusnorm * radiusnorm / 2.0 * sin(innerangle) * i
	round1 = round(a1 / innerangle)
	round2 = round(a2 / innerangle)
	if isclose(round1, a1 / innerangle, rel_tol=1e-05) and isclose(round2, a2 / innerangle, rel_tol=1e-05):
		print(area)
		break


import math, fractions, functools

def rotated(array):
	(first, *rest) = array
	return rest + [first]

def rotations(array):
	for _ in range(len(array)):
		yield array
		array = rotated(array)

def is_approximately_whole(number, tolerance=0.0001):
	return abs(number - round(number)) < tolerance
points = [tuple(map(float, input().split())) for _ in range(3)]
k = 2.0 * sum((x0 * (y1 - y2) for ((x0, _), (_, y1), (_, y2)) in rotations(points)))
(cx, cy) = circumcenter = (1 / k * sum(((x0 ** 2 + y0 ** 2) * (y1 - y2) for ((x0, y0), (_, y1), (_, y2)) in rotations(points))), 1 / k * sum(((x0 ** 2 + y0 ** 2) * (x2 - x1) for ((x0, y0), (x1, _), (x2, _)) in rotations(points))))
normalized_points = [(x - cx, y - cy) for (x, y) in points]
absolute_angles = [math.atan2(y, x) for (x, y) in normalized_points]
angles = [(a1 - a0) % math.tau for (a0, a1) in zip(absolute_angles, rotated(absolute_angles))]
num_pillars = min((k for k in range(3, 101) if all((is_approximately_whole(k * angle / math.tau) for angle in angles))))
radius = math.hypot(*normalized_points[0])
area = num_pillars * radius ** 2 * math.sin(math.tau / num_pillars) / 2
print(area)


from math import *

def rt(x0, y0):
	return sum(((i - j) ** 2 for (i, j) in zip(x0, y0)))

def tr(a0, b0, c0):
	return acos((b0 + c0 - a0) / (2 * (b0 * c0) ** 0.5)) / pi

def trt(x0, n0):
	return 0.01 < x0 * n0 % 1 < 0.99
(x0, y0, z0) = (tuple(map(float, input().split())) for i in range(3))
(a0, b0, c0) = (rt(x0, y0), rt(x0, z0), rt(y0, z0))
(t0, s0) = (tr(a0, b0, c0), tr(b0, a0, c0))
(r0, n0) = (a0 / (8 * sin(t0 * pi) ** 2), 3)
while trt(t0, n0) or trt(s0, n0):
	n0 += 1
print(n0 * r0 * sin(2 * pi / n0))


from itertools import combinations
from math import acos, fmod, hypot, pi, sin

def main():
	coordinates = [list(map(float, input().split())) for i in range(3)]
	points = [Point(i, j) for [i, j] in coordinates]
	polygon = CyclicPolygon(points)
	print(str(round(polygon.area_of_smallest_regular_polygon(), 6)))

def gcd(v1, v2):
	return v1 if v2 < 0.001 else gcd(v2, fmod(v1, v2))

class Point:

	def __init__(self, x, y):
		self.x = x
		self.y = y

	def __eq__(self, other):
		if self.x == other.x and self.y == other.y:
			return True
		else:
			return False

	def __str__(self):
		return str(self.x) + ',' + str(self.y) + '  '

	def distance_to(self, point):
		return hypot(self.x - point.x, self.y - point.y)

	def angle_to(self, point_a, point_b):
		a_length = self.distance_to(point_a)
		b_length = self.distance_to(point_b)
		c_length = point_a.distance_to(point_b)
		angle = acos((a_length ** 2 + b_length ** 2 - c_length ** 2) / (2 * a_length * b_length))
		return angle

	def bisector_line(self, point):
		try:
			m = -(self.x - point.x) / (self.y - point.y)
		except ZeroDivisionError:
			m = float('inf')
		midpoint = Point((self.x + point.x) / 2, (self.y + point.y) / 2)
		c = midpoint.y - m * midpoint.x
		return Line(m, c)

class Line:

	def __init__(self, m, c):
		self.m = m
		self.c = c

	def concurrent_point(self, line):
		x = (self.c - line.c) / (self.m - line.m)
		y = self.m * (line.c - self.c) / (self.m - line.m) + self.c
		return Point(x, y)

	def has_concurrent_point(self, line):
		return True if self.m != line.m else False

class CyclicPolygon:

	def __init__(self, points):
		if self.are_cyclic(points):
			self.points = points
		else:
			raise ValueError

	def all_angles(self):
		angles = []
		for c in combinations(self.points, 3):
			angles.append(c[0].angle_to(c[1], c[2]))
			angles.append(c[1].angle_to(c[0], c[2]))
			angles.append(c[2].angle_to(c[0], c[1]))
		return set(angles)

	def are_cyclic(self, points):
		center = None
		for c in combinations(points, 3):
			l1 = c[0].bisector_line(c[1])
			l2 = c[0].bisector_line(c[2])
			concurrent_point = l1.concurrent_point(l2)
			if center is None or center == concurrent_point:
				center = concurrent_point
			else:
				return False
		return True

	def circumradius(self):
		A = self.points[0].angle_to(self.points[1], self.points[2])
		a = self.points[1].distance_to(self.points[2])
		return 0.5 * (a / sin(A))

	def area_of_smallest_regular_polygon(self):
		angles = self.all_angles()
		divisor = angles.pop()
		while len(angles) > 0:
			divisor = gcd(angles.pop(), divisor)
		sides = round(pi / divisor)
		return 0.5 * sides * self.circumradius() ** 2 * sin(2 * pi / sides)
main()

def test_gcd():
	assert gcd(8, 4) == 4
	assert gcd(12, 9) == 3
	assert gcd(9, 12) == 3

class TestPoint:

	def test_constructor_assignment(self):
		p = Point(1, 2)
		assert p.x == 1 and p.y == 2

	def test_distance_to(self):
		p1 = Point(3, 4)
		p2 = Point(0, 0)
		assert p1.distance_to(p2) == 5

	def test_angle_to(self):
		p1 = Point(0, 0)
		p2 = Point(1, 0)
		p3 = Point(0, 1)
		assert abs(p1.angle_to(p2, p3) - pi / 2) < 0.001

	def test_bisector_line(self):
		p1 = Point(0, 1)
		p2 = Point(1, 0)
		l = p1.bisector_line(p2)
		assert l.m == 1
		assert l.c == 0

class TestLine:

	def test_concurrent_point(self):
		l1 = Line(1, 0)
		l2 = Line(-1, 0)
		assert l1.concurrent_point(l2).x == 0 and l1.concurrent_point(l2).y == 0

	def test_has_concurrent_point(self):
		l1 = Line(1, 0)
		l2 = Line(1, 1)
		l3 = Line(2, 1)
		assert not l1.has_concurrent_point(l2)
		assert l1.has_concurrent_point(l3)

class TestCyclicPolygon:
	p1 = Point(0, 0)
	p2 = Point(1, 0)
	p3 = Point(0, 1)
	p4 = Point(1, 1)
	p5 = Point(5, 2)
	p6 = Point(7, 6)
	p7 = Point(8, 2)
	p8 = Point(10, 12)
	p9 = Point(15, 18)
	t1 = CyclicPolygon([p1, p2, p3])
	t2 = CyclicPolygon([p4, p5, p6])
	t3 = CyclicPolygon([p7, p8, p9])

	def test_valid_construction(self):
		p1 = Point(1, 0)
		p2 = Point(5, 19)
		p3 = Point(7, -22)
		CyclicPolygon([p1, p2, p3])

	def test_invalid_construction(self):
		p1 = Point(1, 0)
		p2 = Point(5, 19)
		p3 = Point(7, -22)
		p4 = Point(3, -22)
		p5 = Point(1, -10)
		with pytest.raises(ValueError):
			CyclicPolygon([p1, p2, p3, p4, p5])

	def test_all_angles(self):
		angles = sorted(self.t1.all_angles())
		assert angles[0] - pi / 4 < 0.001
		assert angles[1] - pi / 2 < 0.001
		angles = sorted(self.t2.all_angles())
		angles = sorted(self.t3.all_angles())

	def test_circumradius(self):
		assert self.t1.circumradius() - hypot(0.5, 0.5) < 0.001

	def test_area_of_smallest_regular_polygon(self):
		assert self.t1.area_of_smallest_regular_polygon() - 1 < 0.001


from math import *

def gcd(a, b):
	if b < pi / 100:
		return a
	return gcd(b, fmod(a, b))
x = []
for i in range(3):
	x.append(list(map(float, input().split())))
(A, B, C) = x
dist = lambda x, y: sqrt((y[1] - x[1]) ** 2 + (y[0] - x[0]) ** 2)
(a, b, c) = (dist(B, C), dist(A, C), dist(A, B))
s = (a + b + c) / 2
k = sqrt(s * (s - a) * (s - b) * (s - c))
R = a * b * c / (4 * k)
(x, y, z) = (acos(round((b ** 2 + c ** 2 - a ** 2) / (2 * b * c), 8)), acos(round((a ** 2 + c ** 2 - b ** 2) / (2 * a * c), 8)), acos(round((a ** 2 + b ** 2 - c ** 2) / (2 * a * b), 8)))
n = pi / gcd(x, gcd(y, z))
print(round(0.5 * n * R ** 2 * sin(2 * pi / n), 8))


import math
(Ax, Ay) = map(float, input().split())
(Bx, By) = map(float, input().split())
(Cx, Cy) = map(float, input().split())
ax_bx = Ax - Bx
ay_by = Ay - By
bx_cx = Bx - Cx
by_cy = By - Cy
cx_ax = Cx - Ax
cy_ay = Cy - Ay
a2 = bx_cx * bx_cx + by_cy * by_cy
b2 = cx_ax * cx_ax + cy_ay * cy_ay
c2 = ax_bx * ax_bx + ay_by * ay_by
S = abs(ax_bx * by_cy - ay_by * bx_cx) / 2
coef = -1 / (8 * S * S)
alpha_a = coef * a2 * (ax_bx * cx_ax + ay_by * cy_ay)
alpha_b = coef * b2 * (ax_bx * bx_cx + ay_by * by_cy)
alpha_c = coef * c2 * (cx_ax * bx_cx + cy_ay * by_cy)
Ux = alpha_a * Ax + alpha_b * Bx + alpha_c * Cx
Uy = alpha_a * Ay + alpha_b * By + alpha_c * Cy
R2 = a2 * b2 * c2 / (16 * S * S)
phiA = math.atan2(Ay - Uy, Ax - Ux)
phiB = math.atan2(By - Uy, Bx - Ux)
phiC = math.atan2(Cy - Uy, Cx - Ux)
phiAB = phiA - phiB
phiBC = phiB - phiC
phiCA = phiC - phiA
eps = 1e-05
n = 3
while n <= 100:
	phi = 2.0 * math.pi / n
	nAB = phiAB / phi
	nBC = phiBC / phi
	nCA = phiCA / phi
	nAB -= round(nAB)
	nBC -= round(nBC)
	nCA -= round(nCA)
	if abs(nAB) < eps and abs(nBC) < eps and (abs(nCA) < eps):
		S = 0.5 * n * R2 * math.sin(2.0 * math.pi / n)
		print('%.8f' % S)
		break
	n += 1


from collections import namedtuple
from math import acos, fabs, floor, pi, sin, sqrt
Point = namedtuple('Point', ['x', 'y'])
eps = 0.0004

def ro(p1, p2):
	return sqrt((p1.x - p2.x) ** 2 + (p1.y - p2.y) ** 2)

def square(p1, p2, p3):
	return abs((p2.x - p1.x) * (p3.y - p1.y) - (p2.y - p1.y) * (p3.x - p1.x)) / 2.0

def radius(p1, p2, p3):
	return ro(p1, p2) * ro(p2, p3) * ro(p1, p3) / square(p1, p2, p3) / 4.0

def angle(a, b, c):
	return acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c))

def gcd(a_ang, b_ang):
	while fabs(a_ang) > eps and fabs(b_ang) > eps:
		if a_ang > b_ang:
			a_ang -= floor(a_ang / b_ang) * b_ang
		else:
			b_ang -= floor(b_ang / a_ang) * a_ang
	return a_ang + b_ang

def sides(a_ang, b_ang, c_ang):
	return pi / gcd(gcd(a_ang, b_ang), c_ang)

def solver(coordinates):
	(p1, p2, p3) = coordinates
	a = ro(p1, p2)
	b = ro(p2, p3)
	c = ro(p3, p1)
	r = radius(p1, p2, p3)
	a_ang = angle(a, b, c)
	b_ang = angle(b, a, c)
	c_ang = angle(c, a, b)
	n = sides(a_ang, b_ang, c_ang)
	return n * r * r * sin(2 * pi / n) / 2

def main():
	coordinates = []
	for i in range(3):
		(x, y) = input().split()
		coordinates.append(Point(float(x), float(y)))
	result = solver(coordinates)
	print(result)
main()


import math
import sys
math.hypot = lambda x, y: math.sqrt(x * x + y * y)

def beta(x11, y11, x12, y12):
	t = (x11 * x12 + y11 * y12) / (math.hypot(x11, y11) * math.hypot(x12, y12))
	if math.fabs(t) > 1.0:
		t = round(t)
	return math.acos(t)
EPS = 0.001
PI = math.pi
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
l = math.hypot(x1 - x2, y1 - y2) * 0.5
xm = min(x1, x2) + math.fabs(x1 - x2) * 0.5
ym = min(y1, y2) + math.fabs(y1 - y2) * 0.5
xp = y1 - y2
yp = x2 - x1
p = math.hypot(xp, yp)
last = 0
mark = False
i = 3
while i < 101:
	phi = 2.0 * PI / float(i)
	j = i // 2
	while j > 0:
		h = float(l) / math.tan(phi * float(j) * 0.5)
		k = float(h) / float(p)
		x0_pos = xm - k * xp
		y0_pos = ym - k * yp
		x0_neg = xm + k * xp
		y0_neg = ym + k * yp
		r = math.hypot(x1 - x0_pos, y1 - y0_pos)
		c1 = math.fabs(math.hypot(x3 - x0_pos, y3 - y0_pos) - r) < EPS
		c2 = math.fabs(math.hypot(x3 - x0_neg, y3 - y0_neg) - r) < EPS
		if c1 or c2:
			if c1:
				(x0, y0) = (x0_pos, y0_pos)
			else:
				(x0, y0) = (x0_neg, y0_neg)
			b1 = beta(x3 - x0, y3 - y0, x1 - x0, y1 - y0)
			b2 = beta(x3 - x0, y3 - y0, x2 - x0, y2 - y0)
			b3 = beta(x1 - x0, y1 - y0, x2 - x0, y2 - y0)
			div = lambda b: math.fabs(b / phi - round(b / phi)) < EPS
			last = 0.5 * float(r) * float(r) * math.sin(phi) * float(i)
			if div(b1) and div(b2) and div(b3):
				print(last)
				mark = True
				break
		j -= 1
	if mark:
		break
	i += 1
if not mark:
	print(last)


import math
PI = 3.141592653589793
x = list(range(0, 3))
y = list(range(0, 3))
length = list(range(0, 3))
angle = list(range(0, 3))
for z in range(3):
	(x[z], y[z]) = [float(n) for n in input().split()]
for z in range(3):
	length[z] = ((x[(z + 1) % 3] - x[(z + 2) % 3]) ** 2 + (y[(z + 1) % 3] - y[(z + 2) % 3]) ** 2) ** 0.5
for z in range(3):
	a = length[(z + 1) % 3]
	b = length[(z + 2) % 3]
	c = length[z]
	angle[z] = math.acos((a * a + b * b - c * c) / (2 * a * b))
rad = length[0] / math.sin(angle[0]) / 2.0
for z in range(3, 101):
	base = 2 * PI / z
	t = 0
	for m in range(3):
		t += int((2 * angle[m] + 1e-06) / base)
	if abs(t * base - 2 * PI) < 1e-06:
		print(z * rad * rad * math.sin(base) / 2)
		break


import sys
import math

def float_gcd(a, b, rtol=0, atol=1e-05):
	t = min(abs(a), abs(b))
	while abs(b) > rtol * t + atol:
		(a, b) = (b, a % b)
	return a

def main():
	point_A = [float(x) for x in sys.stdin.readline().strip().split()]
	point_B = [float(x) for x in sys.stdin.readline().strip().split()]
	point_C = [float(x) for x in sys.stdin.readline().strip().split()]
	side_a = math.hypot(point_B[0] - point_C[0], point_B[1] - point_C[1])
	side_b = math.hypot(point_A[0] - point_C[0], point_A[1] - point_C[1])
	side_c = math.hypot(point_A[0] - point_B[0], point_A[1] - point_B[1])
	semiperimeter_T = (side_a + side_b + side_c) / 2
	area_T = (semiperimeter_T * (semiperimeter_T - side_a) * (semiperimeter_T - side_b) * (semiperimeter_T - side_c)) ** 0.5
	angle_A = math.acos((side_b ** 2 + side_c ** 2 - side_a ** 2) / (2 * side_b * side_c))
	angle_B = math.acos((side_a ** 2 + side_c ** 2 - side_b ** 2) / (2 * side_a * side_c))
	angle_C = math.acos((side_a ** 2 + side_b ** 2 - side_c ** 2) / (2 * side_a * side_b))
	R = side_a * side_b * side_c / (4 * area_T)
	n = math.pi / float_gcd(float_gcd(angle_A, angle_B), angle_C)
	A = math.sin(2 * math.pi / n) * n * R ** 2 / 2
	sys.stdout.write('{:.6f}'.format(A) + '\n')
main()


import math

def norm(arr):
	m = min(arr)
	r = []
	for i in arr:
		r.append(round(i / m, 5))
	return sorted(r)

def match(arr):
	a = norm(arr)
	for i in range(3, 101):
		for j in range(1, math.ceil(i / 2)):
			for k in range(1, i - j):
				tmp = [math.sin(math.pi * j / i), math.fabs(math.sin(math.pi * k / i)), math.fabs(math.sin(math.pi * (i - j - k) / i))]
				if a == norm(tmp):
					n = sorted(arr).pop() / sorted(tmp).pop() / 2
					return round(math.pow(n, 2) * (math.sin(math.pi / i) * math.cos(math.pi / i) * i), 6)
	return 0

def len(p1, p2):
	return math.sqrt(math.pow(float(p1[0]) - float(p2[0]), 2) + math.pow(float(p1[1]) - float(p2[1]), 2))
p1 = input().split(' ')
p2 = input().split(' ')
p3 = input().split(' ')
l1 = len(p1, p2)
l2 = len(p2, p3)
l3 = len(p1, p3)
area = match([l1, l2, l3])
print(area)


import math

def gcd(a, b):
	if a < b:
		return gcd(b, a)
	if abs(b) < 0.001:
		return a
	else:
		return gcd(b, a - math.floor(a / b) * b)

def main():
	coordinates = []
	for _ in range(3):
		coordinates.append(list(map(float, input().split())))
	edgeA = ((coordinates[1][0] - coordinates[0][0]) ** 2 + (coordinates[1][1] - coordinates[0][1]) ** 2) ** (1 / 2)
	edgeB = ((coordinates[2][0] - coordinates[1][0]) ** 2 + (coordinates[2][1] - coordinates[1][1]) ** 2) ** (1 / 2)
	edgeC = ((coordinates[2][0] - coordinates[0][0]) ** 2 + (coordinates[2][1] - coordinates[0][1]) ** 2) ** (1 / 2)
	angleA = math.acos((edgeB ** 2 + edgeC ** 2 - edgeA ** 2) / (2 * edgeB * edgeC))
	angleB = math.acos((edgeA ** 2 + edgeC ** 2 - edgeB ** 2) / (2 * edgeA * edgeC))
	angleC = math.acos((edgeA ** 2 + edgeB ** 2 - edgeC ** 2) / (2 * edgeA * edgeB))
	S = edgeA * edgeB * math.sin(angleC) / 2
	R = edgeA * edgeB * edgeC / (4 * S)
	n = math.pi / gcd(gcd(angleA, angleB), angleC)
	circusArea = n / 2 * R ** 2 * math.sin(2 * math.pi / n)
	print(circusArea)
main()


import math
s1 = input()
a = [eval(x) for x in s1.split()]
s2 = input()
b = [eval(x) for x in s2.split()]
s3 = input()
c = [eval(x) for x in s3.split()]
x1 = a[0]
y1 = a[1]
x2 = b[0]
y2 = b[1]
x3 = c[0]
y3 = c[1]
a1 = x2 - x1
b1 = y2 - y1
c1 = (x2 ** 2 - x1 ** 2 + y2 ** 2 - y1 ** 2) / 2
a2 = x3 - x2
b2 = y3 - y2
c2 = (x3 ** 2 - x2 ** 2 + y3 ** 2 - y2 ** 2) / 2
r1 = (c1 * b2 - c2 * b1) / (a1 * b2 - a2 * b1)
r2 = (c1 * a2 - c2 * a1) / (b1 * a2 - b2 * a1)
r = ((r1 - x1) ** 2 + (r2 - y1) ** 2) ** 0.5
small = 0
for n in range(3, 101):
	test1 = False
	test2 = False
	for k in range(1, n):
		x4 = (x1 - r1) * math.cos(2 * math.pi * k / n) - (y1 - r2) * math.sin(2 * math.pi * k / n) + r1
		y4 = (y1 - r2) * math.cos(2 * math.pi * k / n) + (x1 - r1) * math.sin(2 * math.pi * k / n) + r2
		if (x4 - x2) ** 2 + (y4 - y2) ** 2 < 0.0001:
			test1 = True
		if (x4 - x3) ** 2 + (y4 - y3) ** 2 < 0.0001:
			test2 = True
	if test1 == True and test2 == True:
		small = n
		break
print(small * r * r * math.sin(2 * math.pi / small) / 2)


import math

def gcd(x, y):
	if abs(y) < 0.0001:
		return x
	else:
		return gcd(y, math.fmod(x, y))
(Ax, Ay) = list(map(float, input().split()))
(Bx, By) = list(map(float, input().split()))
(Cx, Cy) = list(map(float, input().split()))
a = math.sqrt((Bx - Cx) * (Bx - Cx) + (By - Cy) * (By - Cy))
b = math.sqrt((Ax - Cx) * (Ax - Cx) + (Ay - Cy) * (Ay - Cy))
c = math.sqrt((Ax - Bx) * (Ax - Bx) + (Ay - By) * (Ay - By))
s = (a + b + c) / 2
area_triangle = math.sqrt(s * (s - a) * (s - b) * (s - c))
r = a * b * c / (4 * area_triangle)
Angle_A = math.acos((b * b + c * c - a * a) / (2 * b * c))
Angle_B = math.acos((a * a + c * c - b * b) / (2 * a * c))
Angle_C = math.acos((b * b + a * a - c * c) / (2 * b * a))
n = math.pi / gcd(gcd(Angle_A, Angle_B), Angle_C)
print(n * r * r * math.sin(2 * math.pi / n) / 2)


from math import pi, sqrt, acos, sin

def gcd(x, y):
	while abs(x) > 0.0001 and abs(y) > 0.0001:
		if x > y:
			x -= x // y * y
		else:
			y -= y // x * x
	return x + y
(x1, y1) = map(float, input().split(' '))
(x2, y2) = map(float, input().split(' '))
(x3, y3) = map(float, input().split(' '))
s1 = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
s2 = sqrt((x1 - x3) ** 2 + (y1 - y3) ** 2)
s3 = sqrt((x2 - x3) ** 2 + (y2 - y3) ** 2)
angle1 = acos((s1 * s1 + s2 * s2 - s3 * s3) / (2 * s1 * s2))
angle2 = acos((s2 * s2 + s3 * s3 - s1 * s1) / (2 * s2 * s3))
angle3 = acos((s1 * s1 + s3 * s3 - s2 * s2) / (2 * s1 * s3))
N = pi / gcd(angle1, gcd(angle2, angle3))
p = 0.5 * (s1 + s2 + s3)
S = sqrt(p * (p - s1) * (p - s2) * (p - s3))
R = s1 * s2 * s3 / (4 * S)
S = 0.5 * N * R * R * sin(2 * pi / N)
print(S)


from math import acos
from math import pi
from math import sin
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
a = x2 - x1
b = y2 - y1
c = (x1 ** 2 + y1 ** 2 - x2 ** 2 - y2 ** 2) / 2
d = x3 - x1
e = y3 - y1
f = (x1 ** 2 + y1 ** 2 - x3 ** 2 - y3 ** 2) / 2
x = (-c * e + b * f) / (a * e - b * d)
y = (-a * f + c * d) / (a * e - b * d)

def find_angle(ax, ay, bx, by):
	dot = ax * bx + ay * by
	cosine = dot / ((ax ** 2 + ay ** 2) ** 0.5 * (bx ** 2 + by ** 2) ** 0.5)
	return acos(cosine)
theta1 = find_angle(x1 - x, y1 - y, x2 - x, y2 - y)
theta2 = find_angle(x1 - x, y1 - y, x3 - x, y3 - y)
n = 1
while not (abs(round(theta1 / (2 * pi / n)) - theta1 / (2 * pi / n)) < 0.001 and abs(round(theta2 / (2 * pi / n)) - theta2 / (2 * pi / n)) < 0.001):
	n += 1
r = ((x1 - x) ** 2 + (y1 - y) ** 2) ** 0.5
s = n * r * r * sin(2 * pi / n) / 2
print('{:6f}'.format(s))


from math import *
pi = 3.14159265359

def gcd(x, y):
	if abs(y) < 0.0001:
		return x
	else:
		return gcd(y, fmod(x, y))

def min_area_of_polygon(Ax, Ay, Bx, By, Cx, Cy):
	a = sqrt((Bx - Cx) * (Bx - Cx) + (By - Cy) * (By - Cy))
	b = sqrt((Ax - Cx) * (Ax - Cx) + (Ay - Cy) * (Ay - Cy))
	c = sqrt((Ax - Bx) * (Ax - Bx) + (Ay - By) * (Ay - By))
	semiperimeter = (a + b + c) / 2
	area_triangle = sqrt(semiperimeter * (semiperimeter - a) * (semiperimeter - b) * (semiperimeter - c))
	Radius = a * b * c / (4 * area_triangle)
	Angle_A = acos((b * b + c * c - a * a) / (2 * b * c))
	Angle_B = acos((a * a + c * c - b * b) / (2 * a * c))
	Angle_C = acos((b * b + a * a - c * c) / (2 * b * a))
	n = pi / gcd(gcd(Angle_A, Angle_B), Angle_C)
	area = n * Radius * Radius * sin(2 * pi / n) / 2
	return area
points = list()
for i in range(0, 3):
	coord = input()
	point = coord.split()
	for i in range(0, 2):
		point[i] = float(point[i])
		points.append(point[i])
Ax = points[0]
Ay = points[1]
Bx = points[2]
By = points[3]
Cx = points[4]
Cy = points[5]
print('%.8f' % min_area_of_polygon(Ax, Ay, Bx, By, Cx, Cy))


__author__ = 'Eddie'

def get_filehandler(is_file):
	if is_file:
		return open(file='data')
	else:
		import sys
		return sys.stdin
import math

def get_allrads():
	rads = []
	for n in range(3, 101):
		rads.append((2 * math.pi / n, n))
	return rads

def get_r(a, b, c):
	x_u = (a[0] ** 2 - b[0] ** 2 + a[1] ** 2 - b[1] ** 2) * (a[1] - c[1]) - (a[0] ** 2 - c[0] ** 2 + a[1] ** 2 - c[1] ** 2) * (a[1] - b[1])
	x_d = 2 * (a[1] - c[1]) * (a[0] - b[0]) - 2 * (a[1] - b[1]) * (a[0] - c[0])
	x = x_u / x_d
	y_u = (a[0] ** 2 - b[0] ** 2 + a[1] ** 2 - b[1] ** 2) * (a[0] - c[0]) - (a[0] ** 2 - c[0] ** 2 + a[1] ** 2 - c[1] ** 2) * (a[0] - b[0])
	y_d = 2 * (a[1] - b[1]) * (a[0] - c[0]) - 2 * (a[1] - c[1]) * (a[0] - b[0])
	y = y_u / y_d
	return (x, y)

def get_rads(a, b, c, r):
	rads = [_get_rad(a, b, r), _get_rad(a, c, r), _get_rad(b, c, r)]
	return rads

def _get_rad(*args):
	edge = []
	for _i in range(len(args)):
		for _j in range(_i + 1, len(args)):
			length = ((args[_i][0] - args[_j][0]) ** 2 + (args[_i][1] - args[_j][1]) ** 2) ** 0.5
			edge.append(length)
	cos = (edge[1] ** 2 + edge[2] ** 2 - edge[0] ** 2) / (2 * edge[1] * edge[2])
	cos = max(cos, -1)
	return math.acos(cos)

def rad_times(a, b):
	return abs(a - b) < 1e-06 or b % a < 1e-06 or abs(b % a - a) < 1e-06

def get_n(rads, all_rads):
	for rad in all_rads:
		for rad_t in rads:
			if not rad_times(rad[0], rad_t):
				break
		else:
			return rad[1]

def get_R(r, a):
	return ((r[0] - a[0]) ** 2 + (r[1] - a[1]) ** 2) ** 0.5
fh = get_filehandler(False)
(a, b, c) = map(lambda x: [float(v) for v in x.strip().split()], fh.readlines())
r = get_r(a, b, c)
rads = get_rads(a, b, c, r)
all_rads = get_allrads()
n = get_n(rads, all_rads)
R = get_R(r, a)
area = 0.5 * n * R ** 2 * math.sin(2 * math.pi / n)
print(area)


from math import atan2, modf, pi, sin, sqrt

def dist(a, b):
	dx = a[0] - b[0]
	dy = a[1] - b[1]
	return sqrt(dx * dx + dy * dy)
p1 = [float(x) for x in input().split()]
p2 = [float(x) for x in input().split()]
p3 = [float(x) for x in input().split()]
ang = [0, 0, 0]
ang[0] = atan2(p2[1] - p1[1], p2[0] - p1[0]) - atan2(p3[1] - p1[1], p3[0] - p1[0])
ang[1] = atan2(p1[1] - p2[1], p1[0] - p2[0]) - atan2(p3[1] - p2[1], p3[0] - p2[0])
ang[2] = atan2(p2[1] - p3[1], p2[0] - p3[0]) - atan2(p1[1] - p3[1], p1[0] - p3[0])
for i in range(3):
	if ang[i] < -pi:
		ang[i] += 2 * pi
	if ang[i] > pi:
		ang[i] -= 2 * pi
	ang[i] = abs(ang[i] * 2)
a = dist(p1, p2)
b = dist(p2, p3)
c = dist(p3, p1)
p = (a + b + c) * 0.5
r = a * b * c / 4 / sqrt(p * (p - a) * (p - b) * (p - c))
for i in range(3, 101):
	cur = 2 * pi / i
	if all((abs(modf(abs(x / cur))[0] - 0.5) > 0.5 - 5e-06 for x in ang)):
		print(i * r * r * sin(cur) * 0.5)
		exit()


import math
coords = []
for i in range(3):
	ls = input().split(' ')
	coords.append((float(ls[0]), float(ls[1])))

def diff(p1, p2):
	return math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)

def angle(p1, p2, p3):
	v1 = (p2[0] - p1[0], p2[1] - p1[1])
	v2 = (p2[0] - p3[0], p2[1] - p3[1])
	try:
		ang = math.acos((v1[0] * v2[0] + v1[1] * v2[1]) / (diff(v1, (0, 0)) * diff(v2, (0, 0))))
	except ValueError:
		ang = math.acos(round((v1[0] * v2[0] + v1[1] * v2[1]) / (diff(v1, (0, 0)) * diff(v2, (0, 0)))))
	return min(ang, 2 * math.pi - ang)

def f():
	diff1 = diff(coords[0], coords[1])
	diff2 = diff(coords[0], coords[2])
	diff3 = diff(coords[1], coords[2])
	(p1, p2, p3) = coords
	if math.isclose(diff1, diff2) and math.isclose(diff2, diff3) and math.isclose(diff1, diff3):
		print(math.sqrt(3) / 4 * diff1 ** 2)
		return
	if math.isclose(diff1, diff2):
		ang = angle(p2, p1, p3)
		n = 360 / (180 - math.degrees(ang))
		print(0.25 * n * diff1 ** 2 * 1 / math.tan(math.pi / n))
		return
	if math.isclose(diff1, diff3):
		ang = angle(p1, p2, p3)
		n = 360 / (180 - math.degrees(ang))
		print(0.25 * n * diff1 ** 2 * 1 / math.tan(math.pi / n))
		return
	if math.isclose(diff2, diff3):
		ang = angle(p1, p3, p2)
		n = 360 / (180 - math.degrees(ang))
		print(0.25 * n * diff2 ** 2 * 1 / math.tan(math.pi / n))
		return
	A = 2 * (p1[0] - p2[0])
	B = 2 * (p1[1] - p2[1])
	E = p1[0] ** 2 - p2[0] ** 2 + p1[1] ** 2 - p2[1] ** 2
	C = 2 * (p1[0] - p3[0])
	D = 2 * (p1[1] - p3[1])
	F = p1[0] ** 2 - p3[0] ** 2 + p1[1] ** 2 - p3[1] ** 2
	y = (E * C - F * A) / (B * C - D * A)
	x = (F - D * y) / C
	R2 = -(2 * p1[0] * x + 2 * p1[1] * y - p1[0] ** 2 - p1[1] ** 2 - x ** 2 - y ** 2)
	current_min = 9e+99
	ang1 = angle(p1, (x, y), p3)
	ang2 = angle(p2, (x, y), p1)
	ang3 = angle(p3, (x, y), p2)
	ags = [ang1, ang2, ang3]
	for i in range(3, 101):
		poss_angle = 2 * math.pi / i
		found = True
		for elem in ags:
			val = elem / poss_angle
			if not math.isclose(val, round(val), rel_tol=1e-05):
				found = False
		if found:
			print(0.5 * i * R2 * math.sin(2 * math.pi / i))
			return
f()


import math
p1 = [float(i) for i in input().split()]
p2 = [float(i) for i in input().split()]
p3 = [float(i) for i in input().split()]
c12 = [(p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2]
c13 = [(p1[0] + p3[0]) / 2, (p1[1] + p3[1]) / 2]
(x3, y3) = p3
(x2, y2) = p2
(x1, y1) = p1
(x12, y12) = c12
(x13, y13) = c13
try:
	slopea = -(x2 - x1) / (y2 - y1)
	ca = y12 - slopea * x12
	slopeb = -(x3 - x1) / (y3 - y1)
	cb = y13 - slopeb * x13
	xcenter = (ca - cb) / (slopeb - slopea)
	ycenter = slopea * xcenter + ca
except:
	if y3 == y1:
		xcenter = x13
		y = slopea * xcenter + ca
	else:
		slopeb = -(x3 - x1) / (y3 - y1)
		cb = y13 - slopeb * x13
		xcenter = x12
		ycenter = slopeb * xcenter + cb
center = [xcenter, ycenter]
radius = ((center[0] - p1[0]) ** 2 + (center[1] - p1[1]) ** 2) ** 0.5

def findangle(point1, point2, center=center, radius=radius):
	P12 = ((point1[0] - point2[0]) ** 2 + (point1[1] - point2[1]) ** 2) ** 0.5
	return math.acos((2 * radius ** 2 - P12 ** 2) / (2 * radius ** 2))
a = [int(findangle(p1, p2) * 10000000), int(findangle(p1, p3) * 10000000), int(20000000 * math.pi)]

def MKD(a, b):
	if abs(a - b) < 5000 or a < 5000 or b < 5000:
		return max(a, b)
	if a > b:
		return MKD(a % b, b)
	return MKD(b % a, a)
tmp = MKD(MKD(a[0], a[1]), a[2])
n = a[2] // (tmp - 50)
area = 0.5 * n * radius ** 2 * math.sin(2 * math.pi / n)
print(round(area, 7))


import math
EPS = 1e-06

class Point:

	def __init__(self, x, y):
		self.x = x
		self.y = y

	def dist(self, p: 'Point'):
		return math.sqrt((self.x - p.x) ** 2 + (self.y - p.y) ** 2)

	def dist_square(self, p: 'Point'):
		return (self.x - p.x) ** 2 + (self.y - p.y) ** 2

def getAreafromPolygon(points):
	A = 0.0
	for (p1, p2) in zip(points[:-1], points[1:]):
		A += 0.5 * (p1.x * p2.y - p2.x * p1.y)
	A += 0.5 * (points[-1].x * points[0].y - points[0].x * points[-1].y)
	return abs(A)

def getRadiusCircleFromThreePoints(p1: 'Point', p2: 'Point', p3: 'Point'):
	triangle_area = getAreafromPolygon([p1, p2, p3])
	if triangle_area < EPS:
		raise Exception('three points are in the same line')
	r = p1.dist(p2) * p1.dist(p3) * p2.dist(p3) / 4.0 / triangle_area
	return r

def get_angle_from_cosine_law(l1: float, l2: float, length_opposite_angle: float):
	l3 = length_opposite_angle
	if l1 < EPS or l2 < EPS:
		raise Exception('side length must be positive real number')
	if abs(l1 - l2) < EPS and l3 < EPS:
		return 0
	if abs(l1 + l2 - l3) < EPS:
		return math.pi
	if l1 + l2 - l3 < -EPS:
		raise Exception('invalid input; length of three sides cannot form triangle')
	return math.acos((l1 ** 2 + l2 ** 2 - l3 ** 2) / (2 * l1 * l2))
points = []
for i in range(3):
	(x, y) = map(float, input().split(' '))
	points.append(Point(x, y))
radius = getRadiusCircleFromThreePoints(points[0], points[1], points[2])
l01 = points[0].dist(points[1])
l02 = points[0].dist(points[2])
angle_p0Op1 = get_angle_from_cosine_law(radius, radius, l01)
angle_p0Op2 = get_angle_from_cosine_law(radius, radius, l02)
i = 3
while i:
	angle_per_side = 2 * math.pi / i
	mod_angle_p0Op1 = math.fmod(angle_p0Op1, angle_per_side)
	mod_angle_p0Op2 = math.fmod(angle_p0Op2, angle_per_side)
	if (mod_angle_p0Op1 < EPS or mod_angle_p0Op1 > angle_per_side - EPS) and (mod_angle_p0Op2 < EPS or mod_angle_p0Op2 > angle_per_side - EPS):
		print(i * 0.5 * radius * radius * math.sin(angle_per_side))
		break
	i += 1


import math

def compute_triangle_side(p1, p2, p3):
	l1 = ((p2[0] - p3[0]) ** 2 + (p2[1] - p3[1]) ** 2) ** (1 / 2)
	l2 = ((p1[0] - p3[0]) ** 2 + (p1[1] - p3[1]) ** 2) ** (1 / 2)
	l3 = ((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2) ** (1 / 2)
	return (l1, l2, l3)

def compute_circumscribed_circle_radius(l1, l2, l3):
	p = (l1 + l2 + l3) / 2
	area = (p * (p - l1) * (p - l2) * (p - l3)) ** (1 / 2)
	radius = l1 * l2 * l3 / (4 * area)
	return radius

def round_float(float_value):
	return math.floor(float_value)

def compute_min_number_of_vertices(radius):
	for n in range(3, 101):
		area = 1 / 2 * n * radius * radius * math.sin(2 * math.pi / n)
		print(area)
		if area - round_area(area) <= 0.0001:
			print(n)
			return '{0:.6f}'.format(area)
	return 1 / 2 * 100 * radius * radius * math.sin(2 * math.pi / 100)

def compute_side_length(radius):
	min_area = -1
	for n in range(3, 101):
		side_length = 2 * radius * math.sin(math.pi / n)
		print(side_length)
		if side_length - round_float(side_length) <= 0.001:
			return n
	return 100

def compute_gcd(a1, a2):
	if a1 < a2:
		return compute_gcd(a2, a1)
	if abs(a2) < 0.001:
		return a1
	else:
		return compute_gcd(a2, a1 - math.floor(a1 / a2) * a2)

def find_min_n(radius, l1, l2, l3):
	angle1 = math.acos((l2 * l2 + l3 * l3 - l1 * l1) / (2 * l2 * l3))
	angle2 = math.acos((l1 * l1 + l3 * l3 - l2 * l2) / (2 * l1 * l3))
	angle3 = math.acos((l1 * l1 + l2 * l2 - l3 * l3) / (2 * l1 * l2))
	return round(math.pi / compute_gcd(angle2, compute_gcd(angle1, angle3)))

def compute_angles_to_O(R, l1, l2, l3):
	angle1 = math.acos((2 * R * R - l1 * l1) / (2 * R * R))
	angle2 = math.acos((2 * R * R - l2 * l2) / (2 * R * R))
	angle3 = math.acos((2 * R * R - l3 * l3) / (2 * R * R))
	return (angle1, angle2, angle3)
p1 = input().split(' ')
p1x = float(p1[0])
p1y = float(p1[1])
p2 = input().split(' ')
p2x = float(p2[0])
p2y = float(p2[1])
p3 = input().split(' ')
p3x = float(p3[0])
p3y = float(p3[1])
(l1, l2, l3) = compute_triangle_side((p1x, p1y), (p2x, p2y), (p3x, p3y))
radius = compute_circumscribed_circle_radius(l1, l2, l3)
min_n = find_min_n(radius, l1, l2, l3)
area = 1 / 2 * min_n * radius * radius * math.sin(2 * math.pi / min_n)
print(area)


from math import sqrt, sin, pi, cos, acos, asin, degrees, floor
sxy = list()
for c in range(3):
	sxy.append(input().split())
	sxy[c][0] = float(sxy[c][0])
	sxy[c][1] = float(sxy[c][1])
x1 = sxy[0][0]
y1 = sxy[0][1]
x2 = sxy[1][0]
y2 = sxy[1][1]
x3 = sxy[2][0]
y3 = sxy[2][1]
x0t = x1 * x1 * (y2 - y3) + x2 * x2 * (y3 - y1) + x3 * x3 * (y1 - y2) + y1 * y1 * (y2 - y3) + y2 * y2 * (y3 - y1) + y3 * y3 * (y1 - y2)
x0b = 2 * (x1 * (y2 - y3) + x2 * (y3 - y1) + x3 * (y1 - y2))
x0 = x0t / x0b
y0t = 2 * x0 * (x1 - x3) + x3 * x3 - x1 * x1 + y3 * y3 - y1 * y1
y0b = 2 * (y3 - y1)
y0 = y0t / y0b
r1 = sqrt((x0 - x1) * (x0 - x1) + (y0 - y1) * (y0 - y1))
f1x = acos((x1 - x0) / r1)
f1y = asin((y1 - y0) / r1)
for j in range(98):
	lx = list()
	ly = list()
	k = j + 3
	fx = f1x
	fy = f1y
	for q in range(k):
		lx.append(round(r1 * cos(fx) + x0, 8))
		ly.append(round(r1 * sin(fy) + y0, 8))
		fx += 2 * pi / k
		fy -= 2 * pi / k
	zc = 0
	for z in range(k):
		if x1 - 9e-06 < lx[z] < x1 + 9e-06 or x2 - 9e-06 < lx[z] < x2 + 9e-06 or x3 - 9e-06 < lx[z] < x3 + 9e-06:
			zc += 1
	if zc > 2:
		sss = 0.5 * k * r1 * r1 * sin(2 * pi / k)
		print(sss)
		break


import math
import logging
import random
logging.basicConfig(level=logging.INFO)
eps = 0.001

class Vector:

	def __init__(self, x=0, y=0):
		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(self.x * other, self.y * other)

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

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

	def input(self):
		tmp = tuple(map(lambda x: float(x), input().split()))
		self.x = tmp[0]
		self.y = tmp[1]

	def disp(self):
		print('({:.2f},{})'.format(self.x, self.y))

	def length(self):
		return (self.x ** 2 + self.y ** 2) ** 0.5

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

	def unit(self):
		return self / self.length()

	def angle(self):
		return math.atan2(self.y, self.x)
Point = Vector

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

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

class Line:

	def __init__(self, p, v):
		self.p = p
		self.v = v

	def angle(self):
		return self.v.angle()

	def point(self, t):
		return self.p + t * self.v

def intersect(a, b):
	ab = b.p - a.p
	return b.point(cross(ab, a.v) / cross(a.v, b.v))
import sys
a = Point()
a.input()
b = Point()
b.input()
c = Point()
c.input()
L1 = Line((a + b) / 2, (a - b).normal())
L2 = Line((b + c) / 2, (b - c).normal())
G = intersect(L1, L2)

def area(n, r):
	return r * r / 2 * n * math.sin(2 * math.pi / n)
angle1 = Line(G, a - G).angle() - Line(G, b - G).angle()
angle2 = Line(G, b - G).angle() - Line(G, c - G).angle()
for i in range(3, 101):
	theta = 2 * math.pi / i
	n1 = math.fabs(angle1 / theta)
	n2 = math.fabs(angle2 / theta)
	if math.fabs(n1 - round(n1)) < eps and math.fabs(n2 - round(n2)) < eps:
		print('%.7f' % area(i, (a - G).length()))
		break


import math
p = [[float(i) for i in input().split()] for a in range(3)]
l = [((p[0][0] - p[1][0]) ** 2 + (p[0][1] - p[1][1]) ** 2) ** (1 / 2), ((p[0][0] - p[2][0]) ** 2 + (p[0][1] - p[2][1]) ** 2) ** (1 / 2), ((p[1][0] - p[2][0]) ** 2 + (p[1][1] - p[2][1]) ** 2) ** (1 / 2)]
a = []
for i in range(3):
	a.append(math.acos((l[(i + 1) % 3] ** 2 + l[(i + 2) % 3] ** 2 - l[i % 3] ** 2) / (2 * l[(i + 1) % 3] * l[(i + 2) % 3])))
r = l[0] / (math.sin(a[0]) * 2)
a = [i / math.pi for i in a]
n = 1
while len([i for i in a if round(i * n, 3) % 1]):
	n += 1
c = math.sin(math.pi / n) * r * 2
altura = (r ** 2 - (c / 2) ** 2) ** (1 / 2)
print('{0:.10f}'.format(round(c * altura * n / 2, 11)))


import math

def SC(a, b):
	return a[0] * b[0] + a[1] * b[1]

def LN(a):
	d = math.sqrt(a[0] * a[0] + a[1] * a[1])
	return d

def AR(a, b):
	d = math.acos(SC(a, b) / LN(a) / LN(b))
	return d

def gcd(x, y):
	while y != 0:
		(x, y) = (y, x % y)
	return x

def lcm(x, y):
	return x * y / gcd(x, y)
_IsSquare = False
(x1, y1) = input().split()
(x1, y1) = (float(x1), float(y1))
(x2, y2) = input().split()
(x2, y2) = (float(x2), float(y2))
(x3, y3) = input().split()
(x3, y3) = (float(x3), float(y3))
a = [x3 - x1, y3 - y1]
b = [x2 - x1, y2 - y1]
A = AR(a, b)
if SC(a, b) == 0:
	_IsSquare = True
	print(LN(a) * LN(b))
a = [x3 - x2, y3 - y2]
b = [x1 - x2, y1 - y2]
B = AR(a, b)
if SC(a, b) == 0:
	_IsSquare = True
	print(LN(a) * LN(b))
a = [x1 - x3, y1 - y3]
b = [x2 - x3, y2 - y3]
C = AR(a, b)
if SC(a, b) == 0:
	_IsSquare = True
	print(LN(a) * LN(b))
if not _IsSquare:
	n1 = math.pi / A
	n2 = math.pi / B
	n3 = math.pi / C
	i = 2
	n = 0
	while not n and i <= 100:
		_1 = float(i) / n1
		_2 = float(i) / n2
		_3 = float(i) / n3
		if float(round(_1, 0) - 0.02) <= _1 <= float(round(_1, 0) + 0.02) and float(round(_2, 0) - 0.02) <= _2 <= float(round(_2, 0) + 0.02) and (float(round(_3, 0) - 0.02) <= _3 <= float(round(_3, 0) + 0.02)):
			n = i
		i += 1
	a = LN([x2 - x1, y2 - y1])
	b = LN([x3 - x2, y3 - y2])
	c = LN([x1 - x3, y1 - y3])
	p = (a + b + c) / 2
	S = math.sqrt(p * (p - a) * (p - b) * (p - c))
	R = a * b * c / (4 * S)
	if int(a) == int(b) == int(c):
		print(S)
	else:
		print(float(float(n) / 2) * R ** 2 * math.sin(2 * math.pi / n))


from math import *

def checkInt(f):
	if abs(int(f + 0.0001) - f) <= 0.001:
		return True
	else:
		return False
p1 = input()
(p1x, p1y) = p1.split(' ')
p2 = input()
(p2x, p2y) = p2.split(' ')
p3 = input()
(p3x, p3y) = p3.split(' ')
p1x = float(p1x)
p1y = float(p1y)
p2x = float(p2x)
p2y = float(p2y)
p3x = float(p3x)
p3y = float(p3y)
dis12 = sqrt((p1x - p2x) ** 2 + (p1y - p2y) ** 2)
dis23 = sqrt((p2x - p3x) ** 2 + (p2y - p3y) ** 2)
dis13 = sqrt((p1x - p3x) ** 2 + (p1y - p3y) ** 2)
cent12x = 0.5 * (p1x + p2x)
cent12y = 0.5 * (p1y + p2y)
cent13x = 0.5 * (p1x + p3x)
cent13y = 0.5 * (p1y + p3y)
cent23x = 0.5 * (p2x + p3x)
cent23y = 0.5 * (p2y + p3y)
k12 = (p2y - p1y + 1e-09) / (p2x - p1x + 1e-09)
k13 = (p3y - p1y + 1e-09) / (p3x - p1x + 1e-09)
k23 = (p2y - p3y + 1e-09) / (p2x - p3x + 1e-09)
k12op = -1 / k12
k13op = -1 / k13
k23op = -1 / k23
b12 = -k12op * cent12x + cent12y
b13 = -k13op * cent13x + cent13y
b23 = -k23op * cent23x + cent23y
centx = (b13 - b12) / (k12op - k13op)
centy = k12op * centx + b12
radius = sqrt((centx - p1x) ** 2 + (centy - p1y) ** 2)
if 0.5 * dis12 / radius > 1:
	theta1 = 2 * asin(1)
else:
	theta1 = 2 * asin(0.5 * dis12 / radius)
if 0.5 * dis13 / radius > 1:
	theta2 = 2 * asin(1)
else:
	theta2 = 2 * asin(0.5 * dis13 / radius)
if 0.5 * dis23 / radius > 1:
	theta3 = 2 * asin(1)
else:
	theta3 = 2 * asin(0.5 * dis23 / radius)
minimumside = 0
theta = 0
side = 2
while True:
	side += 1
	calctheta = 2 * pi / side
	if checkInt(theta1 / calctheta) and checkInt(theta2 / calctheta) and checkInt(theta3 / calctheta):
		minimumside = side
		theta = calctheta / 2
		break
halfsidel = sin(theta) * radius
h = cos(theta) * radius
s = minimumside * h * halfsidel
print(s)


import sys
import math
from decimal import *
getcontext().prec = 100

def gcd(a, b):
	if b > a:
		return gcd(b, a)
	elif math.fabs(b) > 0.0001:
		return gcd(b, a - math.floor(a / b) * b)
	else:
		return a

class Point(object):
	x = None
	y = None

	def __init__(self, *args):
		if len(args) == 1:
			(self.x, self.y) = args[0]
		else:
			(self.x, self.y) = args

	def dist(self, a):
		x = a.x - self.x
		y = a.y - self.y
		return math.sqrt(x * x + y * y)

	def cross(self, a):
		return self.x * a.y - a.x * self.y

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

	def area(self, a, b):
		p1 = a - self
		p2 = b - self
		return math.fabs(p1.cross(p2)) / 2.0

	def angle(self, left, right):
		b = self.dist(left)
		c = self.dist(right)
		a = left.dist(right)
		return math.acos((b * b + c * c - a * a) / (2.0 * b * c))

def process(fin):
	p1 = Point(list(map(Decimal, fin().split())))
	p2 = Point(list(map(Decimal, fin().split())))
	p3 = Point(list(map(Decimal, fin().split())))
	a = p2.dist(p3)
	b = p3.dist(p1)
	c = p1.dist(p2)
	S = p1.area(p2, p3)
	R = a * b * c / (4.0 * S)
	A = p1.angle(p2, p3) * 2.0
	B = p2.angle(p1, p3) * 2.0
	C = p3.angle(p1, p2) * 2.0
	g = gcd(A, gcd(B, C))
	n = 2.0 * math.pi / g
	result = n * R * R * math.sin(g) / 2.0
	print(result)
process(sys.stdin.readline)


from math import *

def mid_line(p1, p2):
	(x1, y1) = p1
	(x2, y2) = p2
	return (x2 - x1, y2 - y1, (x1 ** 2 - x2 ** 2 + y1 ** 2 - y2 ** 2) / 2.0)

def intersect(p1, p2):
	(a1, b1, c1) = p1
	(a2, b2, c2) = p2
	d = a1 * b2 - b1 * a2
	return ((b1 * c2 - b2 * c1) / d, (a2 * c1 - a1 * c2) / d)

def rot(p1, p2, a):
	(x, y) = p1
	(cx, cy) = p2
	(x, y, c, s) = (x - cx, y - cy, cos(a), sin(a))
	return (cx + x * c - y * s, cy + x * s + y * c)

def pt_in(p, pts):
	(x, y) = p
	return any([abs(x - a) + abs(y - b) < 0.0001 for (a, b) in pts])

def area(pts):
	return abs(sum([(x1 + x2) * (y2 - y1) / 2.0 for ((x1, y1), (x2, y2)) in zip(pts, pts[1:] + [pts[0]])]))
p1 = tuple(map(float, input().split()))
p2 = tuple(map(float, input().split()))
p3 = tuple(map(float, input().split()))
pc = intersect(mid_line(p1, p2), mid_line(p3, p2))
for n in range(3, 101):
	pts = [rot(p1, pc, i * 2.0 * pi / n) for i in range(n)]
	if pt_in(p1, pts) and pt_in(p2, pts) and pt_in(p3, pts):
		print(area(pts))
		break


import math
sqrt = lambda s: s ** 0.5
pi = math.pi

def distance(p1, p2):
	(x1, y1) = p1
	(x2, y2) = p2
	return sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)

def all_distances(p1, p2, p3):
	return [distance(p, q) for (p, q) in [(p1, p2), (p2, p3), (p3, p1)]]

def triangle_area(p1, p2, p3):
	(d1, d2, d3) = all_distances(p1, p2, p3)
	s = (d1 + d2 + d3) / 2
	area_sq = s * (s - d1) * (s - d2) * (s - d3)
	return sqrt(area_sq)

def circle_radius(p1, p2, p3):
	(d1, d2, d3) = all_distances(p1, p2, p3)
	area = triangle_area(p1, p2, p3)
	return d1 * d2 * d3 / (4 * area)

def circle_fraction(p1, p2, r):
	d = distance(p1, p2)
	ratio = d / 2 / r
	ratio = min(ratio, 1)
	ratio = max(ratio, -1)
	angle = 2 * math.asin(ratio)
	fraction = angle / (2 * pi)
	return fraction

def is_near_integer(x):
	return abs(round(x) - x) < 1e-05

def smallest_denominator(frac1, frac2):
	for denom in range(1, 101):
		num1 = denom * frac1
		num2 = denom * frac2
		if is_near_integer(num1) and is_near_integer(num2):
			return denom

def smallest_num_sides(p1, p2, p3):
	r = circle_radius(p1, p2, p3)
	frac1 = circle_fraction(p1, p2, r)
	frac2 = circle_fraction(p1, p3, r)
	denom = smallest_denominator(frac1, frac2)
	return denom

def polygon_area(num_sides, radius):
	n = num_sides
	r = radius
	slice_sin = math.sin(2 * pi / n)
	return 1 / 2 * n * r * r * slice_sin

def smallest_polygon_area(p1, p2, p3):
	n = smallest_num_sides(p1, p2, p3)
	r = circle_radius(p1, p2, p3)
	return polygon_area(n, r)
f = smallest_polygon_area
points = [(1, 0), (0, 0), (0, 1)]

def string_to_tuple(s):
	return tuple(map(eval, s.split()))

def read_tuple():
	s = input()
	return string_to_tuple(s)
p1 = read_tuple()
p2 = read_tuple()
p3 = read_tuple()
result = smallest_polygon_area(p1, p2, p3)
print(result)


from math import *

def gcd(x, y):
	return x if y < 0.001 else gcd(y, fmod(x, y))
p = [[float(i) for i in input().split()] for _ in range(3)]
(a, b, c) = [hypot(x1 - x2, y1 - y2) for ([x1, y1], [x2, y2]) in [(p[0], p[1]), (p[0], p[2]), (p[1], p[2])]]
(A, B, C) = [acos((y * y + z * z - x * x) / 2 / y / z) for (x, y, z) in [(a, b, c), (b, c, a), (c, a, b)]]
R = a / 2 / sin(A)
theta = 2 * gcd(A, gcd(B, C))
print(R * R * sin(theta) * pi / theta)


from math import sqrt, acos, pi, sin, cos
er = 10 ** (-3)

def dist1(x1, x2, y1, y2):
	return (x1 - x2) ** 2 + (y1 - y2) ** 2

def dist(x1, x2, y1, y2):
	return sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)

def calcA(r, s):
	return acos(1 - s ** 2 / (2 * r ** 2))

def calcS(a, s):
	return sqrt(s ** 2 / (2 - 2 * cos(a)))

def isInt(i):
	return abs(i - int(i)) < er or abs(i - int(i) - 1) < er

def findMin(t1, t2, t3, r):
	m = 10 ** 10
	t = 3 * t1 / t2
	for n2 in range(1, 101):
		if isInt(n2 * t1 / t2) and isInt(n2 * t3 / t2):
			n1 = int(n2 * t1 / t2 + 0.5)
			n3 = int(n2 * t3 / t2 + 0.5)
			a = sin(2 * pi / (n1 + n2 + n3)) * r / 2 * (n1 + n2 + n3)
			if abs(a) > er:
				m = min(m, a)
	return m

def gen(n, a):
	an = (n - 2) * pi / n
	return (s * cos(a * an) + 300, s * sin(a * an) + 300)

def ans(n, s):
	return n * sin(2 * pi / n) * s ** 2 / 2
(x1, y1) = map(float, input().split(' '))
(x2, y2) = map(float, input().split(' '))
(x3, y3) = map(float, input().split(' '))
a = 2 * (x2 - x1)
b = 2 * (y2 - y1)
c = x2 ** 2 - x1 ** 2 + y2 ** 2 - y1 ** 2
d = 2 * (x2 - x3)
e = 2 * (y2 - y3)
f = x2 ** 2 - x3 ** 2 + y2 ** 2 - y3 ** 2
y = (d * c - f * a) / (d * b - e * a)
if a != 0:
	x = (c - b * y) / a
else:
	x = (f - e * y) / d
r1 = (dist1(x2, x, y2, y) + dist1(x1, x, y1, y) + dist1(x3, x, y3, y)) / 3
r = (dist(x2, x, y2, y) + dist(x1, x, y1, y) + dist(x3, x, y3, y)) / 3
t1 = calcA(r, dist(x1, x2, y1, y2))
t2 = calcA(r, dist(x1, x3, y1, y3))
t3 = calcA(r, dist(x2, x3, y2, y3))
if abs(t1 + t2 + t3 - 2 * pi) < er:
	print('%.8f' % findMin(t1, t2, t3, r1))
else:
	t = sorted([t1, t2, t3])
	print('%.8f' % findMin(2 * pi - t[2], t[1], t[0], r1))


import math
s1 = input().split()
s2 = input().split()
s3 = input().split()
x1 = float(s1[0])
y1 = float(s1[1])
x2 = float(s2[0])
y2 = float(s2[1])
x3 = float(s3[0])
y3 = float(s3[1])

def center(x1, y1, x2, y2, x3, y3):
	x = ((y3 - y2) / 2 * (y2 - y1) * (y3 - y1) + (x1 + x2) / 2 * (x1 * y3 - x1 * y1 - x2 * y3 + x2 * y1) - (x1 + x3) / 2 * (x1 * y2 - x1 * y1 - x3 * y2 + x3 * y1)) / (x1 * y3 - x1 * y1 - x2 * y3 + x2 * y1 - x1 * y2 + x1 * y1 + x3 * y2 - x3 * y1)
	y = (x1 - x2) * (x - (x1 + x2) / 2) / (y2 - y1) + (y1 + y2) / 2
	r = math.sqrt((x1 - x) ** 2 + (y1 - y) ** 2)
	return (x, y, r)

def poligon(x0, y0, x1, y1, r, n):
	a = 2 * math.pi / n
	x = x1 - x0
	y = y1 - y0
	res = []
	for i in range(n):
		xn = x * math.cos(i * a) - y * math.sin(i * a) + x0
		yn = x * math.sin(i * a) + y * math.cos(i * a) + y0
		if '%.6f' % xn == '-0.000000':
			xn = 0
		if '%.6f' % yn == '-0.000000':
			yn = 0
		res.append((xn, yn))
	return res

def square(r, x, n):
	return math.sqrt(r ** 2 - x ** 2 / 4) * 0.5 * x * n
for i in range(3, 101):
	c = center(x1, y1, x2, y2, x3, y3)
	r = poligon(c[0], c[1], x1, y1, c[2], i)
	st = 0
	for x in [(x1, y1), (x2, y2), (x3, y3)]:
		for y in r:
			if math.fabs(x[0] - y[0]) <= 1e-05 and math.fabs(x[1] - y[1]) <= 1e-05:
				st += 1
	if st == 3:
		print('%.8f' % square(float(c[2]), math.sqrt((float(r[0][0]) - float(r[1][0])) ** 2 + (float(r[0][1]) - float(r[1][1])) ** 2), i))
		break


import collections
import re
import math

class coord:

	def __init__(self, x, y):
		self.x = float(x)
		self.y = float(y)

	def __eq__(self, other):
		return abs(self.x - other.x) <= 1e-05 and abs(self.y - other.y) <= 1e-05

	def length(self, other):
		return round(((self.x - other.x) ** 2 + (self.y - other.y) ** 2) ** 0.5, 6)

class polygon:

	def __init__(self):
		self.center = coord(0.0, 0.0)
		self.c = []
		self.Radius = 0
		self.Area = 0

	def addCoord(self, coord):
		self.c.append(coord)
		if len(self.c) == 1:
			pt1 = coord
		elif len(self.c) == 2:
			pt2 = coord
		elif len(self.c) == 3:
			pt3 = coord
			self.Radius = -1
			if not self.IsPerpendicular(1, 2, 3):
				self.CalcCircle(1, 2, 3)
			elif not self.IsPerpendicular(1, 3, 2):
				self.CalcCircle(1, 3, 2)
			elif not self.IsPerpendicular(2, 1, 3):
				self.CalcCircle(2, 1, 3)
			elif not self.IsPerpendicular(2, 3, 1):
				self.CalcCircle(2, 3, 1)
			elif not self.IsPerpendicular(3, 2, 1):
				self.CalcCircle(3, 2, 1)
			elif not self.IsPerpendicular(3, 1, 2):
				self.CalcCircle(3, 1, 2)
			else:
				self.Radius = -1

	def IsPerpendicular(self, n1, n2, n3):
		pt1 = self.c[n1 - 1]
		pt2 = self.c[n2 - 1]
		pt3 = self.c[n3 - 1]
		yDelta_a = pt2.y - pt1.y
		xDelta_a = pt2.x - pt1.x
		yDelta_b = pt3.y - pt2.y
		xDelta_b = pt3.x - pt2.x
		if abs(xDelta_a) == 0 and abs(yDelta_b) == 0:
			return False
		if abs(yDelta_a) == 0:
			return True
		elif abs(yDelta_b) == 0:
			return True
		elif abs(xDelta_a) == 0:
			return True
		elif abs(xDelta_b) == 0:
			return True
		else:
			return False

	def CalcCircle(self, n1, n2, n3):
		if len(self.c) >= 3:
			pt1 = self.c[n1 - 1]
			pt2 = self.c[n2 - 1]
			pt3 = self.c[n3 - 1]
			yDelta_a = pt2.y - pt1.y
			xDelta_a = pt2.x - pt1.x
			yDelta_b = pt3.y - pt2.y
			xDelta_b = pt3.x - pt2.x
			if abs(xDelta_a) == 0 and abs(yDelta_b) == 0:
				self.center = coord(0.5 * (pt2.x + pt3.x), 0.5 * (pt1.y + pt2.y))
				self.Radius = self.center.length(pt1)
				return self.Radius
			aSlope = yDelta_a / xDelta_a
			bSlope = yDelta_b / xDelta_b
			if abs(aSlope - bSlope) == 0:
				return -1
			self.center.x = (aSlope * bSlope * (pt1.y - pt3.y) + bSlope * (pt1.x + pt2.x) - aSlope * (pt2.x + pt3.x)) / (2 * (bSlope - aSlope))
			self.center.y = -1 * (self.center.x - (pt1.x + pt2.x) / 2) / aSlope + (pt1.y + pt2.y) / 2
			self.Radius = self.center.length(pt1)
			return self.Radius

	def coord_range(self, bordCount):
		for bordNumber in range(1, bordCount + 1, 1):
			sin0 = (self.c[0].y - self.center.y) / self.Radius
			cos0 = (self.c[0].x - self.center.x) / self.Radius
			x = self.center.x + (cos0 * math.cos(math.pi * 2 * (bordNumber - 1) / bordCount) - sin0 * math.sin(math.pi * 2 * (bordNumber - 1) / bordCount)) * self.Radius
			y = self.center.y + (sin0 * math.cos(math.pi * 2 * (bordNumber - 1) / bordCount) + cos0 * math.sin(math.pi * 2 * (bordNumber - 1) / bordCount)) * self.Radius
			point = coord(x, y)
			yield point

	def calcCent(self):
		if len(self.c) >= 3:
			for bordNumber in range(3, 101, 1):
				nRes = 0
				for coordFullIndex in self.coord_range(bordNumber):
					for coordIndex in self.c:
						if coordIndex == coordFullIndex:
							nRes = nRes + 1
				if nRes >= 3:
					self.Area = self.Radius ** 2 * bordNumber / 2 * math.sin(math.pi * 2 / bordNumber)
					break
coordinates = []
sstorage_path = 'params'
plg = polygon()
for line in range(1, 4, 1):
	line = input()
	match = re.findall('(\\S+)', line)
	rate1 = float(match[0])
	rate2 = float(match[1])
	coordinates.append(coord(match[0], match[1]))
	plg.addCoord(coord(match[0], match[1]))
plg.calcCent()
print(plg.Area)


from math import *

def length(xx, yy, i, j):
	return sqrt(pow(xx[i] - xx[j], 2) + pow(yy[i] - yy[j], 2))

def find_radius(xx, yy):
	a = length(xx, yy, 0, 1)
	b = length(xx, yy, 1, 2)
	c = length(xx, yy, 2, 0)
	p = (a + b + c) / 2
	return a * b * c / (4 * sqrt(p * (p - a) * (p - b) * (p - c)))

def angles(xx, yy):
	a = length(xx, yy, 0, 1)
	b = length(xx, yy, 1, 2)
	c = length(xx, yy, 2, 0)
	alpha = degrees(acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c)))
	beta = degrees(acos((a ** 2 + c ** 2 - b ** 2) / (2 * a * c)))
	return (alpha, beta, 180 - alpha - beta)

def find_angle(xx, yy):
	(a, b, c) = angles(xx, yy)
	return (a, b, c)

def _gcd(a, b):
	while abs(b) > 0.1:
		a %= b
		(a, b) = (b, a)
	return a

def gcd(a, b, c):
	return _gcd(_gcd(a, b), c)
xx = []
yy = []
for _ in range(3):
	(x, y) = map(float, input().split())
	xx.append(x)
	yy.append(y)
r = find_radius(xx, yy)
a = gcd(*find_angle(xx, yy))
n = 180 // a
print(n / 2 * r ** 2 * sin(2 * pi / n))


import math
(a1, a2) = input().split()
(b1, b2) = input().split()
(c1, c2) = input().split()
(a1, a2) = (float(a1), float(a2))
(b1, b2) = (float(b1), float(b2))
(c1, c2) = (float(c1), float(c2))
a = ((b1 - c1) ** 2 + (b2 - c2) ** 2) ** 0.5
b = ((a1 - c1) ** 2 + (a2 - c2) ** 2) ** 0.5
c = ((a1 - b1) ** 2 + (a2 - b2) ** 2) ** 0.5
cos_A = (b ** 2 + c ** 2 - a ** 2) / (2 * b * c)
sin_A = (1 - cos_A ** 2) ** 0.5
R = a / (2 * sin_A)
cos_a = (R ** 2 + R ** 2 - a ** 2) / (2 * R * R)
cos_b = (R ** 2 + R ** 2 - b ** 2) / (2 * R * R)
cos_c = (R ** 2 + R ** 2 - c ** 2) / (2 * R * R)
theta_a = math.acos(cos_a)
theta_b = math.acos(cos_b)
theta_c = math.acos(cos_c)

def is_gcd_theta(theta):
	for t in [theta_a, theta_b, theta_c]:
		div = t / theta
		if not round(div, 5) == round(div):
			return False
	return True
sides = 3
theta_regular = 2 * math.pi / sides
while not is_gcd_theta(theta_regular) and sides < 100:
	sides += 1
	theta_regular = 2 * math.pi / sides
tri_area = 1 / 2 * R * R * math.sin(theta_regular)
total_area = tri_area * sides
print(total_area)


import math

def truncate(f, n):
	s = '{}'.format(f)
	if 'e' in s or 'E' in s:
		return '{0:.{1}f}'.format(f, n)
	(i, p, d) = s.partition('.')
	return '.'.join([i, (d + '0' * n)[:n]])
(x1, y1) = map(float, input().split(' '))
(x2, y2) = map(float, input().split(' '))
(x3, y3) = map(float, input().split(' '))
h1 = 2 * x2 - 2 * x1
k1 = 2 * y2 - 2 * y1
n1 = x1 * x1 - x2 * x2 + (y1 * y1 - y2 * y2)
h2 = 2 * x3 - 2 * x1
k2 = 2 * y3 - 2 * y1
n2 = x1 * x1 - x3 * x3 + (y1 * y1 - y3 * y3)
h = (k2 * n1 / k1 - n2) / (h2 - k2 * h1 / k1)
k = (h2 * n1 / h1 - n2) / (k2 - h2 * k1 / h1)
r = math.sqrt((x1 - h) * (x1 - h) + (y1 - k) * (y1 - k))
perimeter = 2 * r * math.pi
dist1_2 = math.sqrt(math.pow(x1 - x2, 2) + math.pow(y1 - y2, 2))
dist1_2 = float(truncate(dist1_2, 10))
angle1_2 = math.acos((2 * math.pow(r, 2) - math.pow(dist1_2, 2)) / (2 * r * r))
dist2_3 = math.sqrt(math.pow(x2 - x3, 2) + math.pow(y2 - y3, 2))
dist2_3 = float(truncate(dist2_3, 10))
angle2_3 = math.acos((2 * math.pow(r, 2) - math.pow(dist2_3, 2)) / (2 * r * r))
dist3_1 = math.sqrt(math.pow(x3 - x1, 2) + math.pow(y3 - y1, 2))
dist3_1 = float(truncate(dist3_1, 10))
angle3_1 = math.acos((2 * math.pow(r, 2) - math.pow(dist3_1, 2)) / (2 * r * r))
for x in range(3, 101, 1):
	internal_angle = 2 * math.pi / x
	if float(truncate(angle1_2 % internal_angle, 4)) == 0 or float(truncate(angle1_2 % internal_angle, 4)) == float(truncate(internal_angle, 4)):
		if float(truncate(angle2_3 % internal_angle, 4)) == 0 or float(truncate(angle2_3 % internal_angle, 4)) == float(truncate(internal_angle, 4)):
			if float(truncate(angle3_1 % internal_angle, 4)) == 0 or float(truncate(angle3_1 % internal_angle, 4)) == float(truncate(internal_angle, 4)):
				area = x * math.pow(r, 2) * math.sin(internal_angle) / 2
				print(str(area))
				break


from math import hypot
from math import sqrt
from math import fabs
from math import atan2
from math import pi
from math import sin
coords = []
eps = 1e-06
sides = []
dists = []
angs = []
for i in range(3):
	coords.append([float(j) for j in input().split(' ')])
for i in range(3):
	sides.append(hypot(coords[(i + 1) % 3][0] - coords[(i + 2) % 3][0], coords[(i + 1) % 3][1] - coords[(i + 2) % 3][1]))
a = sides[0]
b = sides[1]
c = sides[2]
R = a * b * c / sqrt((a + b + c) * (b + c - a) * (c + a - b) * (a + b - c))
for i in range(3):
	if fabs(sides[i] / 2 - R) < eps:
		dists.append(0)
	else:
		dists.append(sqrt(R ** 2 - (sides[i] / 2) ** 2))
	angs.append(2 * atan2(sides[i] / 2, dists[i]))
N = 0
for i in range(3, 101):
	score = 0
	for j in range(1, i + 1):
		for k in range(3):
			if fabs(2 * pi * j / i - angs[k]) < eps:
				score += 1
	if score == 3:
		N = i
		break
area = N * 0.5 * R ** 2 * sin(2 * pi / N)
print(area)


import math
import fractions

def solve():
	rawin = []
	for i in range(3):
		a = input().split()
		rawin.append([float(a[0]), float(a[1])])
	a = distance(rawin[0], rawin[1])
	b = distance(rawin[1], rawin[2])
	c = distance(rawin[0], rawin[2])
	p = (a + b + c) / 2
	S = math.sqrt(p * (p - a) * (p - b) * (p - c))
	R = a * b * c / (4 * S)
	angle = []
	angle.append(2 * myasin(a / (2 * R)))
	angle.append(2 * myasin(b / (2 * R)))
	angle.append(2 * math.pi - angle[0] - angle[1])
	A = fgcd(angle[0], fgcd(angle[1], angle[2]))
	S_an = R * R * math.sin(A) * math.pi / A
	print('%.8lf\n' % S_an)

def distance(a, b):
	return math.sqrt(math.pow(a[0] - b[0], 2) + math.pow(a[1] - b[1], 2))

def feq(a, b):
	return math.fabs(a - b) < 0.001

def fgcd(a, b):
	if feq(a, 0):
		return b
	if feq(b, 0):
		return a
	return fgcd(b, math.fmod(a, b))

def myasin(a):
	if a > 1.0:
		return math.asin(1.0)
	elif a < -1.0:
		return math.asin(-1.0)
	else:
		return math.asin(a)
solve()


import math

class Point:

	def __init__(self, x, y):
		self.x = x
		self.y = y

	def distance(self, other):
		return math.sqrt(math.pow(self.x - other.x, 2) + math.pow(self.y - other.y, 2))

def gcd(x, y):
	assert x != 0 or y != 0
	(mini, maxi) = (min(x, y), max(x, y))
	r = 1
	while r > 0.001:
		(_, r) = divmod(maxi, mini)
		(maxi, mini) = (mini, r)
	return maxi

def min_area(p1, p2, p3):
	(a, b, c) = (p1.distance(p2), p2.distance(p3), p3.distance(p1))
	s = (a + b + c) / 2
	alt_area = math.sqrt(s * (s - a) * (s - b) * (s - c))
	radius = a * b * c / (4 * alt_area)
	(AOB, BOC, COA) = (2 * math.acos((-a ** 2 + b ** 2 + c ** 2) / (2 * b * c)), 2 * math.acos((-b ** 2 + c ** 2 + a ** 2) / (2 * c * a)), 2 * math.acos((-c ** 2 + a ** 2 + b ** 2) / (2 * a * b)))
	theta = gcd(gcd(AOB, BOC), COA)
	return math.pi * radius ** 2 * math.sin(theta) / theta
sides = []
for _ in range(3):
	sides.append(Point(*list(map(float, input().split()))))
print(min_area(*sides))


import math

def get_pair(pts):
	for i in range(len(pts)):
		if i != len(pts) - 1:
			yield (pts[i], pts[i + 1])
		else:
			yield (pts[i], pts[0])

class Line:

	def __init__(self, m, c):
		self.m = m
		self.c = c

	def intersection(self, other):
		if self.m is not None and other.m is not None:
			x = -1 * (self.c - other.c) / (self.m - other.m)
			y = self.m * x + self.c
		elif self.m is not None and other.m is None:
			x = other.c
			y = self.m * x + self.c
		elif self.m is None and other.m is not None:
			x = self.c
			y = other.m * x + other.c
		else:
			(x, y) = (None, None)
		return (x, y)

def find_angle(a, b, c):
	B2 = (a[0] - c[0]) ** 2 + (a[1] - c[1]) ** 2
	A2 = (b[0] - c[0]) ** 2 + (b[1] - c[1]) ** 2
	C2 = (a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2
	try:
		C = math.acos((A2 + B2 - C2) / (2 * math.sqrt(A2) * math.sqrt(B2)))
	except:
		_C = int((A2 + B2 - C2) / (2 * math.sqrt(A2) * math.sqrt(B2)))
		C = math.acos(_C)
	return C / (2 * math.pi) * 360
pts = [tuple([float(x) for x in input().split()]) for i in range(3)]
lines = []
for pair in get_pair(pts):
	(pt0, pt1) = (pair[0], pair[1])
	mid_pt = ((pt0[0] + pt1[0]) / 2, (pt0[1] + pt1[1]) / 2)
	if pt0[0] - pt1[0] == 0:
		x = pt0[0]
		_m = 0
	else:
		m = (pt0[1] - pt1[1]) / (pt0[0] - pt1[0])
		if m != 0:
			_m = -1 / m
		else:
			_m = None
	if _m is not None:
		_c = mid_pt[1] - _m * mid_pt[0]
	else:
		_c = mid_pt[0]
	lines.append(Line(_m, _c))
l1 = lines[0]
l2 = lines[1]
centre = l1.intersection(l2)
thres = 0.0001
for i in range(3, 101):
	check = 0
	unit_angle = 360 / i
	for pair in get_pair(pts):
		(pt0, pt1) = (pair[0], pair[1])
		angle = find_angle(pt0, pt1, centre)
		if abs(angle % unit_angle) < thres or abs(angle % unit_angle - unit_angle) < thres:
			check += 1
	if check == 3:
		side_sq = (pt0[0] - centre[0]) ** 2 + (pt0[1] - centre[1]) ** 2
		area = i * (0.5 * side_sq * math.sin(unit_angle / 360 * 2 * math.pi))
		print(round(area, 8))
		break


import math as m
s_c = []
for i in range(0, 3):
	s = input().split()
	s = [float(s[0]), float(s[1])]
	s_c.append(s)
n = 2
(oka, okb, okc) = (0, 0, 0)
(x1, y1) = (s_c[0][0], s_c[0][1])
(x2, y2) = (s_c[1][0], s_c[1][1])
(x3, y3) = (s_c[2][0], s_c[2][1])
a = m.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1))
b = m.sqrt((x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2))
c = m.sqrt((x3 - x1) * (x3 - x1) + (y3 - y1) * (y3 - y1))
cosc = (pow(a, 2) + pow(b, 2) - pow(c, 2)) / (2 * a * b)
sinc = m.sqrt(1 - cosc * cosc)
R = c / (sinc * 2)
cosy_c = (2 * R * R - c * c) / (2 * R * R)
y_c = m.acos(cosy_c)
cosy_a = (2 * R * R - a * a) / (2 * R * R)
y_a = m.acos(cosy_a)
cosy_b = (2 * R * R - b * b) / (2 * R * R)
y_b = m.acos(cosy_b)
fl = 1
while fl == 1:
	n = n + 1
	u = m.pi * 2 / n
	fl = 0
	s_out = y_c / u
	s_out = str(s_out)
	xfl = ''
	c = 0
	for t in range(s_out.find('.') + 1, len(s_out)):
		c += 1
		if t >= len(s_out) or c >= 5:
			break
		xfl += s_out[t]
	s_out = float(s_out)
	if xfl in '999999':
		s_out = m.trunc(s_out) + 1
	elif xfl in '000000':
		s_out = m.trunc(s_out)
	else:
		s_out = 0
	if s_out == 0:
		fl = 1
	s_out = y_a / u
	s_out = str(s_out)
	xfl = ''
	c = 0
	for t in range(s_out.find('.') + 1, len(s_out)):
		c += 1
		if t >= len(s_out) or c >= 5:
			break
		xfl += s_out[t]
	s_out = float(s_out)
	if xfl in '999999':
		s_out = m.trunc(s_out) + 1
	elif xfl in '000000':
		s_out = m.trunc(s_out)
	else:
		s_out = 0
	if s_out == 0:
		fl = 1
	s_out = y_b / u
	s_out = str(s_out)
	xfl = ''
	c = 0
	for t in range(s_out.find('.') + 1, len(s_out)):
		c += 1
		if t >= len(s_out) or c >= 5:
			break
		xfl += s_out[t]
	s_out = float(s_out)
	if xfl in '999999':
		s_out = m.trunc(s_out) + 1
	elif xfl in '000000':
		s_out = m.trunc(s_out)
	else:
		s_out = 0
	if s_out == 0:
		fl = 1
s = str(1 / 2 * R * R * n * m.sin(2 * m.pi / n))
print(s)


import math

def xyline(x1, y1, x2, y2):
	return (y1 - y2, x2 - x1, -((x2 - x1) * y1 + (y1 - y2) * x1))

def sujick(a, b, c, x, y):
	return (b, -a, a * y - b * x)

def kyojum(a1, b1, c1, a2, b2, c2):
	return (-(c1 * b2 - b1 * c2) / (a1 * b2 - b1 * a2), -(a1 * c2 - c1 * a2) / (a1 * b2 - b1 * a2))

def oishim(x1, y1, x2, y2, x3, y3):
	return kyojum(*sujick(*xyline(x1, y1, x2, y2), (x1 + x2) / 2, (y1 + y2) / 2), *sujick(*xyline(x1, y1, x3, y3), (x1 + x3) / 2, (y1 + y3) / 2))

def fgcd(a, b):
	while math.fabs(b) > math.pi / 100:
		(a, b) = (b, math.fmod(a, b))
	return a
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
(xoi, yoi) = oishim(x1, y1, x2, y2, x3, y3)
rad1 = math.atan2(y1 - yoi, x1 - xoi)
rad2 = math.atan2(y2 - yoi, x2 - xoi)
rad3 = math.atan2(y3 - yoi, x3 - xoi)
angle = math.fabs(fgcd(fgcd(rad1 - rad2, rad2 - rad3), rad3 - rad1))
n = math.pi * 2 / angle
newn = n
while math.fabs(newn - round(newn)) > 0.01:
	newn += n
n = newn
angle = math.pi * 2 / n
result = ((x1 - xoi) ** 2 + (y1 - yoi) ** 2) * math.sin(angle / 2) * math.cos(angle / 2) * n
print('%.6f' % result)


import math
(x1, y1) = list(map(float, input().split()))
(x2, y2) = list(map(float, input().split()))
(x3, y3) = list(map(float, input().split()))
a1 = x2 - x1
b1 = y2 - y1
c1 = (x2 ** 2 - x1 ** 2 + y2 ** 2 - y1 ** 2) / 2
a2 = x3 - x2
b2 = y3 - y2
c2 = (x3 ** 2 - x2 ** 2 + y3 ** 2 - y2 ** 2) / 2
r1 = (c1 * b2 - c2 * b1) / (a1 * b2 - a2 * b1)
r2 = (c1 * a2 - c2 * a1) / (b1 * a2 - b2 * a1)
r = ((r1 - x1) ** 2 + (r2 - y1) ** 2) ** 0.5
small = 0
for n in range(3, 101):
	test1 = False
	test2 = False
	for k in range(1, n):
		x4 = (x1 - r1) * math.cos(2 * math.pi * k / n) - (y1 - r2) * math.sin(2 * math.pi * k / n) + r1
		y4 = (y1 - r2) * math.cos(2 * math.pi * k / n) + (x1 - r1) * math.sin(2 * math.pi * k / n) + r2
		if (x4 - x2) ** 2 + (y4 - y2) ** 2 < 0.0001:
			test1 = True
		if (x4 - x3) ** 2 + (y4 - y3) ** 2 < 0.0001:
			test2 = True
	if test1 == True and test2 == True:
		small = n
		break
print(small * r ** 2 * math.sin(2 * math.pi / small) / 2)


import math
eps = 0.0001

def isInt(x):
	if math.fabs(x - int(x)) < eps or math.fabs(x - int(x) - 1) < eps:
		return True
	else:
		return False
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
a = math.hypot(x2 - x3, y2 - y3)
b = math.hypot(x1 - x3, y1 - y3)
c = math.hypot(x1 - x2, y1 - y2)
p = (a + b + c) / 2
S = math.sqrt(p * (p - a) * (p - b) * (p - c))
R = a * b * c / (4 * S)
A = math.acos((b * b + c * c - a * a) / (2 * b * c))
B = math.acos((a * a + c * c - b * b) / (2 * a * c))
C = math.acos((a * a + b * b - c * c) / (2 * a * b))
min_angle = min(A, B, C)
N = int(math.pi / min_angle)
while math.fabs(math.sin((A - B) * N)) >= eps or math.fabs(math.sin((B - C) * N)) >= eps or math.fabs(math.sin((A - C) * N)) >= eps or (not isInt(A * N / math.pi)) or (not isInt(A * N / math.pi)) or (not isInt(A * N / math.pi)):
	N += 1
s = N * R * R * math.sin(math.pi * 2 / N) / 2
print('%.8f' % s)


import math

def vec(u, v):
	return [u[i] - v[i] for i in range(len(u))]

def dis(u):
	return math.sqrt(u[0] ** 2 + u[1] ** 2)

def cross(u, v):
	return u[0] * v[1] - v[0] * u[1]

def dot(u, v):
	return u[0] * v[0] + u[1] * v[1]

def eq(a, b, eps=0.001):
	return math.fabs(a - b) < eps

def gcd(a, b):
	while not eq(b, 0):
		t = b
		b = a % b
		a = t
	return a
p = [[float(v) for v in input().split()] for _ in range(3)]
a = dis(vec(p[0], p[1]))
b = dis(vec(p[1], p[2]))
c = dis(vec(p[2], p[0]))
S = math.fabs(0.5 * cross(vec(p[1], p[0]), vec(p[2], p[0])))
R = a * b * c / (4 * S)
A = math.acos((R ** 2 - 0.5 * a ** 2) / R ** 2)
B = math.acos((R ** 2 - 0.5 * b ** 2) / R ** 2)
C = math.acos((R ** 2 - 0.5 * c ** 2) / R ** 2)
minAng = gcd(2 * math.pi, gcd(A, gcd(B, C)))
n = math.pi / minAng
print('{:.6f}'.format(n * R * R * math.sin(minAng)))


import math
(Ax, Ay) = map(float, input().split())
(Bx, By) = map(float, input().split())
(Cx, Cy) = map(float, input().split())
D = 2 * (Ax * (By - Cy) + Bx * (Cy - Ay) + Cx * (Ay - By))
DA = Ax * Ax + Ay * Ay
DB = Bx * Bx + By * By
DC = Cx * Cx + Cy * Cy
Ux = (DA * (By - Cy) + DB * (Cy - Ay) + DC * (Ay - By)) / D
Uy = (DA * (Cx - Bx) + DB * (Ax - Cx) + DC * (Bx - Ax)) / D
R2A = (Ax - Ux) * (Ax - Ux) + (Ay - Uy) * (Ay - Uy)
R2B = (Bx - Ux) * (Bx - Ux) + (By - Uy) * (By - Uy)
R2C = (Cx - Ux) * (Cx - Ux) + (Cy - Uy) * (Cy - Uy)
R2 = (R2A + R2B + R2C) / 3
phiA = math.atan2(Ay - Uy, Ax - Ux)
phiB = math.atan2(By - Uy, Bx - Ux)
phiC = math.atan2(Cy - Uy, Cx - Ux)
phiAB = phiA - phiB
phiBC = phiB - phiC
phiCA = phiC - phiA
eps = 1e-05
n = 3
while n <= 100:
	phi = 2.0 * math.pi / n
	nAB = phiAB / phi
	nBC = phiBC / phi
	nCA = phiCA / phi
	nAB -= round(nAB)
	nBC -= round(nBC)
	nCA -= round(nCA)
	if abs(nAB) < eps and abs(nBC) < eps and (abs(nCA) < eps):
		S = 0.5 * n * R2 * math.sin(2.0 * math.pi / n)
		print('%.8f' % S)
		break
	n += 1


from math import acos, pi, cos, sin, atan2, fabs, sqrt
__author__ = 'liraim'

def read_input():
	points = []
	for i in range(0, 3):
		strings = input().split()
		points.append({'x': float(strings[1]), 'y': float(strings[0])})
	return points

def solve(input_data):
	kx = {'12': -2 * input_data[0]['x'] + 2 * input_data[1]['x'], '13': -2 * input_data[0]['x'] + 2 * input_data[2]['x'], '23': -2 * input_data[1]['x'] + 2 * input_data[2]['x']}
	ky = {'12': -2 * input_data[0]['y'] + 2 * input_data[1]['y'], '13': -2 * input_data[0]['y'] + 2 * input_data[2]['y'], '23': -2 * input_data[1]['y'] + 2 * input_data[2]['y']}
	r = {'12': input_data[1]['x'] ** 2 + input_data[1]['y'] ** 2 - input_data[0]['x'] ** 2 - input_data[0]['y'] ** 2, '13': input_data[2]['x'] ** 2 + input_data[2]['y'] ** 2 - input_data[0]['x'] ** 2 - input_data[0]['y'] ** 2, '23': input_data[2]['x'] ** 2 + input_data[2]['y'] ** 2 - input_data[1]['x'] ** 2 - input_data[1]['y'] ** 2}
	center = dict()
	if kx['12'] == 0:
		center['y'] = r['12'] / ky['12']
		if kx['13'] != 0:
			center['x'] = (r['13'] - ky['13'] * center['y']) / kx['13']
		else:
			center['x'] = (r['23'] - ky['23'] * center['y']) / kx['23']
	if kx['13'] == 0:
		center['y'] = r['13'] / ky['13']
		if kx['12'] != 0:
			center['x'] = (r['12'] - ky['12'] * center['y']) / kx['12']
		else:
			center['x'] = (r['23'] - ky['23'] * center['y']) / kx['23']
	if kx['23'] == 0:
		center['y'] = r['23'] / ky['23']
		if kx['13'] != 0:
			center['x'] = (r['13'] - ky['13'] * center['y']) / kx['13']
		else:
			center['x'] = (r['12'] - ky['12'] * center['y']) / kx['12']
	if ky['12'] == 0:
		center['x'] = r['12'] / kx['12']
		if ky['13'] != 0:
			center['y'] = (r['13'] - kx['13'] * center['x']) / ky['13']
		else:
			center['y'] = (r['23'] - kx['23'] * center['x']) / ky['23']
	if ky['13'] == 0:
		center['x'] = r['13'] / kx['13']
		if ky['12'] != 0:
			center['y'] = (r['12'] - kx['12'] * center['x']) / ky['12']
		else:
			center['y'] = (r['23'] - kx['23'] * center['x']) / ky['23']
	if ky['23'] == 0:
		center['x'] = r['23'] / kx['23']
		if ky['13'] != 0:
			center['y'] = (r['13'] - kx['13'] * center['x']) / ky['13']
		else:
			center['y'] = (r['12'] - kx['12'] * center['x']) / ky['12']
	if center.get('x') is None:
		if kx['12'] * ky['13'] - kx['13'] * ky['12'] != 0:
			center['x'] = (r['12'] * ky['13'] - r['13'] * ky['12']) / (kx['12'] * ky['13'] - kx['13'] * ky['12'])
			center['y'] = (r['13'] - kx['13'] * center['x']) / ky['13']
		elif kx['12'] * ky['23'] - kx['23'] * ky['12'] != 0:
			center['x'] = (r['12'] * ky['23'] - r['23'] * ky['12']) / (kx['12'] * ky['23'] - kx['23'] * ky['12'])
			center['y'] = (r['23'] - kx['23'] * center['x']) / ky['23']
		elif kx['13'] * ky['23'] - kx['23'] * ky['13'] != 0:
			center['x'] = (r['13'] * ky['23'] - r['23'] * ky['13']) / (kx['13'] * ky['23'] - kx['23'] * ky['13'])
			center['y'] = (r['23'] - kx['23'] * center['x']) / ky['23']
	radius = sqrt((input_data[0]['x'] - center['x']) ** 2 + (input_data[0]['y'] - center['y']) ** 2)
	precision = 1e-05
	sector_count = 0
	for count in range(3, 101):
		check_func = lambda n, point1, point2: sin(n * (atan2(point1['y'] - center['y'], point1['x'] - center['x']) - atan2(point2['y'] - center['y'], point2['x'] - center['x'])) / 2)
		if fabs(check_func(count, input_data[0], input_data[1])) < precision and fabs(check_func(count, input_data[0], input_data[2])) < precision and (fabs(check_func(count, input_data[1], input_data[2])) < precision):
			sector_count = count
			break
	area = sector_count / 2 * radius ** 2 * sin(2 * pi / sector_count)
	return area

def print_answer(answer):
	print('%.6f' % answer)
print_answer(solve(read_input()))


import math
epsilon = 0.0001

def angle(ax, ay, bx, by):
	prod = ax * bx + ay * by
	a = math.hypot(ax, ay)
	b = math.hypot(bx, by)
	prod = prod / a / b
	if abs(prod) > 1:
		prod = float(int(prod))
	return math.acos(prod)

def test(a, b):
	for i in range(1, 51):
		if abs(i * b - a) < epsilon:
			return True
	return False
(Ax, Ay) = (float(i) for i in input().split())
(Bx, By) = (float(i) for i in input().split())
(Cx, Cy) = (float(i) for i in input().split())
Mx = (Ax + Bx) / 2
My = (Ay + By) / 2
Nx = (Bx + Cx) / 2
Ny = (By + Cy) / 2
ABx = Bx - Ax
ABy = By - Ay
BCx = Cx - Bx
BCy = Cy - By
m = ABx * Mx + ABy * My
n = BCx * Nx + BCy * Ny
x = (m * BCy - n * ABy) / (ABx * BCy - ABy * BCx)
if BCy != 0:
	y = (n - BCx * x) / BCy
elif ABy != 0:
	y = (m - ABx * x) / ABy
else:
	print('0')
r2 = (Ax - x) ** 2 + (Ay - y) ** 2
alpha = angle(Bx - x, By - y, Ax - x, Ay - y)
beta = angle(Cx - x, Cy - y, Ax - x, Ay - y)
n = 3
while n <= 100:
	if test(alpha, 2 * math.pi / n) and test(beta, 2 * math.pi / n):
		break
	n = n + 1
print(n * r2 * math.sin(2 * math.pi / n) / 2)


lst = input().split()
(ax, ay) = map(float, lst)
lst = input().split()
(bx, by) = map(float, lst)
lst = input().split()
(cx, cy) = map(float, lst)
import math
ab2 = (ax - bx) * (ax - bx) + (ay - by) * (ay - by)
bc2 = (bx - cx) * (bx - cx) + (by - cy) * (by - cy)
ca2 = (cx - ax) * (cx - ax) + (cy - ay) * (cy - ay)
ab = math.sqrt(ab2)
bc = math.sqrt(bc2)
ca = math.sqrt(ca2)
p = (ab + bc + ca) / 2
s = math.sqrt(p * (p - ab) * (p - bc) * (p - ca))
r = ab * bc * ca / (4 * s)
A = math.acos((ab2 + ca2 - bc2) / (2 * ab * ca))
B = math.acos((ab2 + bc2 - ca2) / (2 * ab * bc))
C = math.acos((bc2 + ca2 - ab2) / (2 * bc * ca))
d = 1e-05
count = 3
sinth = 0.0
minth = math.pi / 100 - d
for i in range(1, 100):
	th = A / i
	if th < minth:
		break
	if abs((B + d) // th * th - B) < d and abs((C + d) // th * th - C) < d:
		count = (math.pi + d) // th
		sinth = math.sin(th * 2)
		break
ss = 0.5 * r * r * sinth * count
print('%.6f' % ss)


import math

class Point(object):

	def __init__(self, x, y):
		self.x = x * 1.0
		self.y = y * 1.0

	def GetDistance(self, p2):
		dx = self.x - p2.x
		dy = self.y - p2.y
		return math.sqrt(dx * dx + dy * dy)

	def __str__(self):
		return '[' + str(self.x) + ',' + str(self.y) + ']'

class LineEquation(object):

	def __init__(self, p1, p2):
		self.type = 0
		self.p1 = p1
		self.p2 = p2
		if p1.x == p2.x:
			self.type = 1
			self.x = p1.x
		elif p1.y == p2.y:
			self.type = 2
			self.y = p1.y
		else:
			self.type = 0
			self.slope = (p2.y - p1.y) / (p2.x - p1.x)
			self.intercept = p2.y - self.slope * p2.x

	def GetMidperpendicular(self):
		result = None
		mid_x = (self.p1.x + self.p2.x) / 2
		mid_y = (self.p1.y + self.p2.y) / 2
		if self.type == 1:
			result = LineEquation(Point(0, mid_y), Point(1, mid_y))
		elif self.type == 2:
			result = LineEquation(Point(mid_x, 0), Point(mid_x, 1))
		else:
			slope = -1 / self.slope
			result = LineEquation(Point(mid_x, mid_y), Point(mid_x - 1, mid_y - slope))
		return result

	def GetCrossPoint(self, line):
		x = 0
		y = 0
		if self.type == 1 and line.type == 1 or (self.type == 2 and line.type == 2) or (self.type == 0 and line.type == 0 and (self.slope - line.slope < 1e-07)):
			return None
		if self.type == 1:
			x = self.x
			y = line.slope * x + line.intercept
		elif line.type == 1:
			return line.GetCrossPoint(self)
		elif self.type == 2:
			y = self.y
			x = (y - line.intercept) / line.slope
		elif line.type == 2:
			return line.GetCrossPoint(self)
		else:
			x = (line.intercept - self.intercept) / (self.slope - line.slope)
			y = line.slope * x + line.intercept
		return Point(x, y)

	def __str__(self):
		if self.type == 0:
			return 'y=' + str(self.slope) + '*x+' + str(self.intercept)
		elif self.type == 1:
			return 'x=' + str(self.x)
		else:
			return 'y=' + str(self.y)

def get_area_with_herons_formula(a, b, c):
	p = (a + b + c) / 2
	s = math.sqrt(p * (p - a) * (p - b) * (p - c))
	return s

def get_radius(a, b, c, s):
	return a * b * c / (4 * s)

def get_radian_of_triangle_with_low_of_cosines(a, b, c):
	r1 = math.acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c))
	r2 = math.acos((c ** 2 + a ** 2 - b ** 2) / (2 * c * a))
	r3 = math.acos((a ** 2 + b ** 2 - c ** 2) / (2 * b * a))
	return (r1, r2, r3)

def get_gcd(a, b):
	if b < math.pi / 100:
		return a
	return get_gcd(b, math.fmod(a, b))
coords = input().split()
p1 = Point(float(coords[0]), float(coords[1]))
coords = input().split()
p2 = Point(float(coords[0]), float(coords[1]))
coords = input().split()
p3 = Point(float(coords[0]), float(coords[1]))
a = p1.GetDistance(p2)
b = p2.GetDistance(p3)
c = p3.GetDistance(p1)
s = get_area_with_herons_formula(a, b, c)
r = get_radius(a, b, c, s)
(r1, r2, r3) = get_radian_of_triangle_with_low_of_cosines(a, b, c)
r = a / 2.0 / math.sin(r1)
rgcd = 2.0 * get_gcd(r1, get_gcd(r2, r3))
result = r * r * math.sin(rgcd) / 2 * (2 * math.pi / rgcd)
print('%.6f' % result)


from math import *
pi = 3.14159265359

def gcd(x, y):
	if abs(y) < 0.0001:
		return x
	else:
		return gcd(y, fmod(x, y))

def min_area_of_polygon(Ax, Ay, Bx, By, Cx, Cy):
	a = sqrt((Bx - Cx) * (Bx - Cx) + (By - Cy) * (By - Cy))
	b = sqrt((Ax - Cx) * (Ax - Cx) + (Ay - Cy) * (Ay - Cy))
	c = sqrt((Ax - Bx) * (Ax - Bx) + (Ay - By) * (Ay - By))
	semiperimeter = (a + b + c) / 2
	area_triangle = sqrt(semiperimeter * (semiperimeter - a) * (semiperimeter - b) * (semiperimeter - c))
	Radius = a * b * c / (4 * area_triangle)
	Angle_A = acos((b * b + c * c - a * a) / (2 * b * c))
	Angle_B = acos((a * a + c * c - b * b) / (2 * a * c))
	Angle_C = acos((b * b + a * a - c * c) / (2 * b * a))
	n = pi / gcd(gcd(Angle_A, Angle_B), Angle_C)
	area = n * Radius * Radius * sin(2 * pi / n) / 2
	return area
(Ax, Ay) = map(float, input().split())
(Bx, By) = map(float, input().split())
(Cx, Cy) = map(float, input().split())
print('{0:6f}'.format(min_area_of_polygon(Ax, Ay, Bx, By, Cx, Cy)))


__author__ = 'Darren'
from sys import stdin
import math

def solve():
	a = [float(v) for v in next(stdin).strip().split()]
	b = [float(v) for v in next(stdin).strip().split()]
	c = [float(v) for v in next(stdin).strip().split()]
	o = center_of_circumscribed_circle(a, b, c)
	angles = [math.atan2(x[1] - o[1], x[0] - o[0]) for x in (a, b, c)]
	angle_diff = [angles[i] - angles[i - 1] for i in range(3)]
	for n in range(3, 101):
		for angle in angle_diff:
			if math.fabs(math.sin(n * angle / 2)) > 1e-05:
				break
		else:
			radius = distance(o, a)
			print('%.8f' % (n * radius * radius * math.sin(2 * math.pi / n) / 2))
			return

def center_of_circumscribed_circle(a, b, c):
	oxu = (a[0] ** 2 - b[0] ** 2 + a[1] ** 2 - b[1] ** 2) * (a[1] - c[1]) - (a[0] ** 2 - c[0] ** 2 + a[1] ** 2 - c[1] ** 2) * (a[1] - b[1])
	oxd = 2 * (a[1] - c[1]) * (a[0] - b[0]) - 2 * (a[1] - b[1]) * (a[0] - c[0])
	oyu = (a[0] ** 2 - b[0] ** 2 + a[1] ** 2 - b[1] ** 2) * (a[0] - c[0]) - (a[0] ** 2 - c[0] ** 2 + a[1] ** 2 - c[1] ** 2) * (a[0] - b[0])
	oyd = 2 * (a[1] - b[1]) * (a[0] - c[0]) - 2 * (a[1] - c[1]) * (a[0] - b[0])
	return (oxu / oxd, oyu / oyd)

def distance(a, b):
	return ((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2) ** 0.5
solve()


from math import pi, acos, sqrt, sin
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
s1 = sqrt((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3))
s2 = sqrt((x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3))
s3 = sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
t1 = acos((s2 * s2 + s3 * s3 - s1 * s1) / (2 * s2 * s3)) / pi
t2 = acos((s1 * s1 + s3 * s3 - s2 * s2) / (2 * s1 * s3)) / pi
t3 = acos((s1 * s1 + s2 * s2 - s3 * s3) / (2 * s1 * s2)) / pi
s = 3
while True:
	err = 0
	for t in (t1, t2, t3):
		p = s * t
		err = max(err, abs(p - round(p)))
	if err < 0.0001:
		break
	s += 1
print(f'{s / 2 * sin(2 * pi / s) * s1 * s1 * s2 * s2 * s3 * s3 / ((s1 + s2 + s3) * (s1 + s2 - s3) * (s1 - s2 + s3) * (s3 + s2 - s1)):.10f}')


from math import sin, cos, pi, sqrt
p = []
for _ in range(3):
	(x, y) = input().split()
	p.append((float(x), float(y)))
p01 = ((p[1][0] + p[0][0]) / 2, (p[1][1] + p[0][1]) / 2)
m01 = -(p[1][0] - p[0][0]) / (p[1][1] - p[0][1])
p02 = ((p[2][0] + p[0][0]) / 2, (p[2][1] + p[0][1]) / 2)
m02 = -(p[2][0] - p[0][0]) / (p[2][1] - p[0][1])
cx = (m01 * p01[0] - m02 * p02[0] - p01[1] + p02[1]) / (m01 - m02)
cy = m01 * (cx - p01[0]) + p01[1]
p = [(x - cx, y - cy) for (x, y) in p]
for s in range(3, 101):
	score = 0
	for pp in p:
		match = False
		for i in range(s):
			a = float(i) / s * 2 * pi
			qx = cos(a) * p[0][0] - sin(a) * p[0][1]
			qy = sin(a) * p[0][0] + cos(a) * p[0][1]
			d = sqrt((qx - pp[0]) ** 2 + (qy - pp[1]) ** 2)
			if d < 0.0001:
				match = True
				break
		if match:
			score += 1
		else:
			break
	if score == 3:
		print(0.5 * s * (p[0][0] ** 2 + p[0][1] ** 2) * sin(2 * pi / s))
		break


__author__ = 'asmn'
from math import sqrt, atan2, pi, sin
from functools import reduce
(x, y) = ([0] * 3, [0] * 3)
for i in range(3):
	(x[i], y[i]) = tuple(map(float, input().split()))

def center(x, y, n):
	return (sum((x[i] * x[i] * (y[i - 1] - y[i - 2]) for i in range(3))) + (y[0] - y[1]) * (y[1] - y[2]) * (y[2] - y[0])) / sum((2 * x[i] * (y[i - 1] - y[i - 2]) for i in range(3)))
(cx, cy) = (center(x, y, 3), center(y, x, 3))
r = sqrt((x[1] - cx) ** 2 + (y[1] - cy) ** 2)
th = list(map(lambda x, y: atan2(y - cy, x - cx), x, y))

def check(na, a):
	k = na / a
	return abs(k - round(k)) < 0.0001
for n in range(3, 101):
	if check(th[2] - th[0], 2 * pi / n) and check(th[1] - th[0], 2 * pi / n):
		print(n * r * r * sin(2 * pi / n) / 2)
		break


import math

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

def angle_to_side(angle):
	return (2 - 2 * math.cos(angle)) ** 0.5
temp = input().split()
p1 = [float(x) for x in temp]
temp = input().split()
p2 = [float(x) for x in temp]
temp = input().split()
p3 = [float(x) for x in temp]
s = [round(dist(p1, p2), 7), round(dist(p1, p3), 7), round(dist(p3, p2), 7)]
s.sort(reverse=True)
nnn = 0
for n in range(3, 101):
	m = 0
	for i in range(n - 2, math.ceil(n / 3) - 1, -1):
		t = n - i
		for j in range(min(i, t - 1), math.ceil(t / 2) - 1, -1):
			k = n - i - j
			v = [min(i, n - i), j, k]
			sides = [angle_to_side(x * 2 * math.pi / n) for x in v]
			coeff = [round(sides[k] / s[k], 6) for k in range(3)]
			if coeff[1] == coeff[0] and coeff[2] == coeff[0]:
				print(round(math.sin(2 * math.pi / n) * n * s[0] * s[0] / (2 * sides[0] * sides[0]), 6))
				exit()
			m += 1
	nnn += m


import math

def dist(p1, p2):
	return math.hypot(p1[0] - p2[0], p1[1] - p2[1])

def getAngle(a, r):
	return math.acos((2 * r ** 2 - a ** 2) / (2 * r ** 2))

def gcd(a, b):
	if abs(a) < 0.001:
		return b
	else:
		return gcd(math.fmod(b, a), a)
p1 = list(map(float, input().split()))
p2 = list(map(float, input().split()))
p3 = list(map(float, input().split()))
a = dist(p1, p2)
b = dist(p2, p3)
c = dist(p1, p3)
p = (a + b + c) / 2
(A, B, C) = [math.acos((y * y + z * z - x * x) / 2 / z / y) for (x, y, z) in [(a, b, c), (b, c, a), (c, a, b)]]
r = a / 2 / math.sin(A)
angle1 = getAngle(a, r)
angle2 = getAngle(b, r)
angle3 = 2 * math.pi - angle1 - angle2
gcd = gcd(angle1, gcd(angle2, angle3))
area = 0.5 * math.sin(gcd) * r * r
res = area * (2 * math.pi / gcd)
print(res)


from math import sqrt, hypot, acos, pi, sin
(s1, s2, s3) = (input(), input(), input())
(str_x1, str_y1) = s1.split()
(str_x2, str_y2) = s2.split()
(str_x3, str_y3) = s3.split()
(x1, y1) = (float(str_x1), float(str_y1))
(x2, y2) = (float(str_x2), float(str_y2))
(x3, y3) = (float(str_x3), float(str_y3))
c = hypot(x1 - x2, y1 - y2)
b = hypot(x1 - x3, y1 - y3)
a = hypot(x2 - x3, y2 - y3)
angA = acos((b * b + c * c - a * a) / (2 * b * c))
angB = acos((a * a + c * c - b * b) / (2 * a * c))
angC = acos((b * b + a * a - c * c) / (2 * b * a))
S = sqrt((a + b + c) * (a + b - c) * (a + c - b) * (b + c - a)) / 4
R = a * b * c / (4 * S)

def isInt(x):
	xx = round(x)
	if abs(x - xx) < 1e-05:
		return 1
	else:
		return 0

def check(angA, angB, angC, n):
	if not isInt(angA * n / pi):
		return 0
	if not isInt(angB * n / pi):
		return 0
	if not isInt(angC * n / pi):
		return 1
	return 1

def area(R, n):
	ans = sin(2 * pi / n) * R * R * n / 2
	return ans
for i in range(3, 101):
	if check(angA, angB, angC, i):
		print('%.8f' % area(R, i))
		break


import math
from fractions import gcd

def distance(A, B):
	n = len(A)
	assert len(B) == n
	return sum(((A[i] - B[i]) ** 2 for i in range(n))) ** 0.5

def cosine(a, b, c):
	return (a * a + c * c - b * b) / (2 * a * c)

def circumradius(A, B, C):
	T = [A, B, C]
	L = [distance(T[i], T[(i + 1) % 3]) for i in range(3)]
	s = sum(L) / 2
	a = (s * (s - L[0]) * (s - L[1]) * (s - L[2])) ** 0.5
	return L[0] * L[1] * L[2] / (4 * a)

def hurdle(a):
	if a < -1:
		return -1
	elif a > 1:
		return 1
	else:
		return a

def gcd(x, y):
	if y > x:
		return gcd(y, x)
	if y == 0:
		return x
	return gcd(y, x % y)
T = [tuple((float(x) for x in input().split(' '))) for i in range(3)]
L = [distance(T[i], T[(i + 1) % 3]) for i in range(3)]
r = circumradius(T[0], T[1], T[2])
angles = [math.acos(hurdle(cosine(r, L[i], r))) for i in range(3)]
divs = [x / (2 * math.pi) for x in angles]
divs.sort()
if math.fabs(divs[0] + divs[1] - divs[2]) < 10 ** (-6):
	divs[2] = 1 - divs[2]
m = 0
for i in range(3, 101):
	i_divs = [x * i for x in divs]
	ind = 0
	for k in i_divs:
		if math.fabs(int(round(k)) - k) < 10 ** (-5):
			ind += 1
	if ind == 3:
		divs = [int(round(k)) for k in i_divs]
		break
n = sum(divs) / gcd(gcd(divs[0], divs[1]), divs[2])
area = n * r * r / 2 * math.sin(2 * math.pi / n)
print(area)


import math
pi = math.pi
eps = 0.0001

def find_r(x0, y0, x1, y1, x2, y2):
	x01 = x0 - x1
	x02 = x0 - x2
	y01 = y0 - y1
	y02 = y0 - y2
	y20 = y2 - y0
	y10 = y1 - y0
	x20 = x2 - x0
	x10 = x1 - x0
	sx02 = x0 ** 2 - x2 ** 2
	sy02 = y0 ** 2 - y2 ** 2
	sx10 = x1 ** 2 - x0 ** 2
	sy10 = y1 ** 2 - y0 ** 2
	f = (sx02 * x01 + sy02 * x01 + sx10 * x02 + sy10 * x02) / (2 * (y20 * x01 - y10 * x02))
	g = (sx02 * y01 + sy02 * y01 + sx10 * y02 + sy10 * y02) / (2 * (x20 * y01 - x10 * y02))
	c = -x0 ** 2 - y0 ** 2 - 2 * g * x0 - 2 * f * y0
	h = -g
	k = -f
	r = math.sqrt(h ** 2 + k ** 2 - c)
	return r

def distance(x0, y0, x1, y1):
	return math.sqrt((x1 - x0) ** 2 + (y1 - y0) ** 2)

def law_of_cos(a, b, c):
	angle = math.acos((a ** 2 + b ** 2 - c ** 2) / (2 * a * b))
	return angle

def max_angle(x0, y0, x1, y1, x2, y2):
	d01 = distance(x0, y0, x1, y1)
	d12 = distance(x1, y1, x2, y2)
	d02 = distance(x0, y0, x2, y2)
	a0 = law_of_cos(d01, d02, d12)
	a1 = law_of_cos(d01, d12, d02)
	a2 = law_of_cos(d12, d02, d01)
	return (a0, a1, a2)

def gcd(x, y):
	while abs(x) > eps and abs(y) > eps:
		if x > y:
			x -= math.floor(x / y) * y
		else:
			y -= math.floor(y / x) * x
	return x + y
(x0, y0) = map(float, input().split())
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
r = find_r(x0, y0, x1, y1, x2, y2)
(a0, a1, a2) = max_angle(x0, y0, x1, y1, x2, y2)
n = pi / gcd(gcd(a0, a1), a2)
a = 0.5 * n * r ** 2 * math.sin(2 * pi / n)
print('{:f}'.format(a))


from math import acos, sin, pi
d1 = list(map(float, input().split()))
d2 = list(map(float, input().split()))
d3 = list(map(float, input().split()))
d12 = ((d1[0] - d2[0]) ** 2 + (d1[1] - d2[1]) ** 2) ** 0.5
d13 = ((d1[0] - d3[0]) ** 2 + (d1[1] - d3[1]) ** 2) ** 0.5
d23 = ((d2[0] - d3[0]) ** 2 + (d2[1] - d3[1]) ** 2) ** 0.5
p = (d12 + d13 + d23) / 2
S = (p * (p - d12) * (p - d13) * (p - d23)) ** 0.5
R = d12 * d13 * d23 / (4 * S)
angle12 = acos(round(1 - d12 ** 2 / (2 * R ** 2), 9))
angle13 = acos(round(1 - d13 ** 2 / (2 * R ** 2), 9))
angle23 = 2 * pi - angle12 - angle13

def float_gcd(a1, a2):
	if abs(a1) < abs(a2):
		return float_gcd(a2, a1)
	if abs(a2) <= 1e-05:
		return abs(a1)
	return float_gcd(a2, a1 % a2)
min_angle = float_gcd(float_gcd(angle12, angle13), angle23)
n = 2 * pi / min_angle
S_ans = 0.5 * n * R ** 2 * sin(min_angle)
print('%.6f' % S_ans)


from math import sqrt, sin, acos, pi, floor
eps = 10 ** (-3)

def length(x, y):
	return sqrt(sum(((i - j) ** 2 for (i, j) in zip(x, y))))

def angle(a, b, c):
	return acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c))

def gcd(x, y):
	while abs(x) > eps and abs(y) > eps:
		if x > y:
			x -= floor(x / y) * y
		else:
			y -= floor(y / x) * x
	return x + y

def CF_1C():
	(x, y, z) = (tuple(map(float, input().split())) for i in range(3))
	(a, b, c) = (length(x, y), length(x, z), length(y, z))
	(A, B, C) = (angle(a, b, c), angle(b, c, a), angle(c, a, b))
	S = 0.5 * a * b * sin(C)
	R = a * b * c / (4 * S)
	n = pi / gcd(gcd(A, B), C)
	result = 0.5 * n * R ** 2 * sin(2 * pi / n)
	return round(result, 6)
print(CF_1C())


import math

def ag(Vx, Vy, R2):
	sc = Vx[0] * Vy[0] + Vx[1] * Vy[1]
	cosA = sc / R2
	Alfa = math.acos(round(cosA, 8))
	return Alfa
(x, y) = ([], [])
for i in range(3):
	s = input()
	a = s.split(' ')
	(ax, ay) = (float(a[0]), float(a[1]))
	x.append(ax)
	y.append(ay)
(Ax, Ay) = (x[2] - x[0], y[2] - y[0])
(Bx, By) = (x[1] - x[0], y[1] - y[0])
(xc1, yc1) = ((x[2] + x[0]) / 2, (y[2] + y[0]) / 2)
(xc2, yc2) = ((x[1] + x[0]) / 2, (y[1] + y[0]) / 2)
C1 = Ax * xc1 + Ay * yc1
C2 = Bx * xc2 + By * yc2
D = Ax * By - Ay * Bx
Dx = By * C1 - Ay * C2
Dy = Ax * C2 - Bx * C1
Xc = Dx / D
Yc = Dy / D
R2 = (x[2] - Xc) ** 2 + (y[2] - Yc) ** 2
A = ag([x[2] - Xc, y[2] - Yc], [x[0] - Xc, y[0] - Yc], R2)
B = ag([x[1] - Xc, y[1] - Yc], [x[0] - Xc, y[0] - Yc], R2)
N = 0
for i in range(3, 101):
	k = 2 * math.pi / i
	(da, dar) = (A / k, round(A / k))
	(db, dbr) = (B / k, round(B / k))
	if abs(da - dar) < 1e-05 and abs(db - dbr) < 1e-05 and (N == 0):
		N = i
		dS = R2 * math.sin(k) / 2
		S = N * dS
		break
print('%.8f' % S)


import math

def theatresquare(n, m, a):
	return ((n - 1) // a + 1) * ((m - 1) // a + 1)

def convert(x):
	s = ''
	while x > 0:
		a = x % 26
		x = x // 26
		if a == 0:
			a = 26
			x -= 1
		s = chr(a - 1 + ord('A')) + s
	return s

def convertindex(x):
	i = 0
	while x[i] <= 'Z' and x[i] >= 'A':
		i += 1
	j = i
	while j < len(x) and x[j] <= '9' and (x[j] >= '0'):
		j += 1
	if j == len(x):
		s = 0
		for j in range(i):
			s = ord(x[j]) - ord('A') + 1 + 26 * s
		return 'R' + x[i:] + 'C' + str(s)
	else:
		while x[i] <= '9' and x[i] >= '0':
			i += 1
		return convert(int(x[i + 1:])) + x[1:i]

def berlandcircus(A, B, C):
	a = (B[0] - C[0]) ** 2 + (B[1] - C[1]) ** 2
	b = (A[0] - C[0]) ** 2 + (A[1] - C[1]) ** 2
	c = (B[0] - A[0]) ** 2 + (B[1] - A[1]) ** 2
	la = math.acos(abs((b + c - a) / (2 * math.sqrt(b) * math.sqrt(c)))) / math.pi
	lb = math.acos(abs((c - b + a) / (2 * math.sqrt(a) * math.sqrt(c)))) / math.pi
	lc = math.acos(abs((b - c + a) / (2 * math.sqrt(a) * math.sqrt(b)))) / math.pi
	i = 3
	while i < 101:
		if abs(la * i - round(la * i)) < 1e-05:
			if abs(lb * i - round(lb * i)) < 1e-05:
				if abs(lb * i - round(lb * i)) < 1e-05:
					return round(i * 0.125 * a * math.sin(2 * math.pi / i) / math.sin(la * math.pi) ** 2, 6)
		i += 1
A = list(map(float, input().split()))
B = list(map(float, input().split()))
C = list(map(float, input().split()))
print(berlandcircus(A, B, C))


import cmath, math

def diff(arr):
	ans = 0
	for num in arr:
		ans += abs(num - round(num))
	return ans
x = [0] * 3
y = [0] * 3
z = [0] * 3
for i in range(3):
	(x[i], y[i]) = [float(s) for s in str.split(input(), sep=' ')]
	z[i] = x[i] + 1j * y[i]
D = 0
for i in range(3):
	D += z[i].conjugate() * (z[(i + 1) % 3] - z[(i + 2) % 3])
R = 1
for i in range(3):
	R *= z[(i + 1) % 3] - z[(i + 2) % 3]
R /= D
R = abs(R)
a = [0] * 3
for i in range(3):
	a[i] = abs(cmath.phase((z[(i + 1) % 3] - z[i]) / (z[(i + 2) % 3] - z[i])) / math.pi)
n = 0
ndiff = math.inf
for k in range(1, 101):
	if diff([k * el for el in a]) < ndiff:
		ndiff = diff([k * el for el in a])
		n = k
S = n * R ** 2 * math.sin(2 * math.pi / n) / 2
print('%0.6f' % S)


import sys
import math
N = 1000

def find_circle_center(p1, p2, p3):
	(x1, y1) = p1
	(x2, y2) = p2
	(x3, y3) = p3

	def average(a, b):
		return (a + b) / 2
	x_mid1 = average(x1, x2)
	y_mid1 = average(y1, y2)
	if y1 == y2:
		L1 = (1, 0, -x_mid1)
	else:
		A1 = x2 - x1
		B1 = y2 - y1
		C1 = B1 * y_mid1 + A1 * x_mid1
		L1 = (A1, B1, -C1)
	x_mid2 = average(x2, x3)
	y_mid2 = average(y2, y3)
	if y2 == y3:
		L2 = (1, 0, -x_mid2)
	else:
		A2 = x3 - x2
		B2 = y3 - y2
		C2 = B2 * y_mid2 + A2 * x_mid2
		L2 = (A2, B2, -C2)
	xp = intersection(L1, L2)
	if xp:
		return xp
	print('No single Intersection point detected.')
	return False

def intersection(L1, L2):
	D = L1[0] * L2[1] - L1[1] * L2[0]
	Dx = L1[2] * L2[1] - L1[1] * L2[2]
	Dy = L1[0] * L2[2] - L1[2] * L2[0]
	if D != 0:
		x = Dx / D
		y = Dy / D
		return (-x, -y)
	else:
		return False

def distance(p1, p2):
	return math.sqrt(pow(p2[0] - p1[0], 2) + pow(p2[1] - p1[1], 2))

def near_integer(num):
	u = math.ceil(num)
	l = math.floor(num)
	return math.isclose(u, num, rel_tol=0.0001) or math.isclose(l, num, rel_tol=0.0001)

def main():
	ps = []
	for line in sys.stdin:
		(a, b) = line.split(' ')
		ps.append((float(a), float(b)))
	center = find_circle_center(ps[0], ps[1], ps[2])
	R = distance(center, ps[0])

	def center_angle(line):
		(p1, p2) = line
		return 2 * math.asin(distance(p1, p2) / R * 0.5) / math.pi
	Theta = list(map(center_angle, [(ps[0], ps[1]), (ps[1], ps[2]), (ps[2], ps[0])]))
	n = 0
	for n in range(3, N + 1):
		div_result = [x * n / 2 for x in Theta]
		if all([near_integer(x) for x in div_result]):
			break
		else:
			continue
	if n == 0:
		print('Error: input invalid.')
		return
	area = 1 / 2 * n * R * R * math.sin(2 * math.pi / n)
	print('%.6f' % area)
	return area

def test():
	p1 = (0.0, 0.0)
	p2 = (0.5, 0.5 * math.sqrt(3))
	p3 = (1.0, 0.0)
	p4 = (1.0, 1.0)
	p5 = (71.756151, 7.532275)
	p6 = (-48.634784, 100.159986)
	p7 = (91.778633, 158.107739)
main()


from math import acos
from math import pi
from math import sin
from math import cos

def angle(a, b, c):
	cs = (a ** 2 + b ** 2 - c ** 2) / (2 * a * b)
	if cs > 1:
		cs = 1
	if cs < -1:
		cs = -1
	return acos(cs)

def length(xs, ys):
	return ((xs[0] - xs[1]) ** 2 + (ys[0] - ys[1]) ** 2) ** 0.5
xs = []
ys = []
for i in range(0, 3):
	(x, y) = [float(x) for x in input().split()]
	xs.append(x)
	ys.append(y)
abc = [length((xs[i], xs[(i + 1) % 3]), (ys[i], ys[(i + 1) % 3])) for i in range(3)]
angles = [angle(abc[i], abc[(i + 1) % 3], abc[(i + 2) % 3]) for i in range(3)]
for i in range(3, 101):
	est_angle = pi / i
	flag = True
	for angle in angles:
		d = round(angle / est_angle)
		if d == 0 or abs(est_angle * d - angle) / est_angle > 1e-05:
			flag = False
			break
	if flag:
		break
print(i * sin(2 * pi / i) * abc[2] ** 2 / sin(angles[0]) ** 2 / 8)


from sys import stdin
from math import *
from functools import lru_cache, reduce
input = stdin.readline
dist = lambda a, b: sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)
dgcd = lambda a, b: a if b < 0.0001 else dgcd(b, a) if a < b else dgcd(b, a - a // b * b)
dege = lambda a, b, c: acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c))
(ap, bp, cp) = map(tuple, map(lambda i: map(float, input().split()), range(3)))
(a, b, c) = map(dist, [bp, cp, ap], [cp, ap, bp])
(A, B, C) = map(dege, [a, b, c], [b, c, a], [c, a, b])
p = (a + b + c) / 2
S = sqrt(p * (p - a) * (p - b) * (p - c))
R = a * b * c / (4 * S)
n = round(pi / reduce(dgcd, [A, B, C]))
Res = n / 2 * R * R * sin(pi * 2 / n)
print(f'{Res:.6f}')


import math

def mod(a, b):
	return a - int(a / b) * b

def gcd(x, y):
	if y <= 0.0001:
		return x
	return gcd(y, mod(x, y))
(x, y) = map(float, input().split())
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
c = math.sqrt((x - x1) * (x - x1) + (y - y1) * (y - y1))
b = math.sqrt((x - x2) * (x - x2) + (y - y2) * (y - y2))
a = math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
p = (a + b + c) / 2
r = a * b * c / (4 * math.sqrt(p * (p - a) * (p - b) * (p - c)))
angle1 = math.acos((b * b + c * c - a * a) / (2 * b * c))
angle2 = math.acos((a * a + c * c - b * b) / (2 * a * c))
angle3 = math.pi - angle1 - angle2
angle = round(math.pi / gcd(angle2, gcd(angle1, angle3)))
s = r * r * math.sin(2 * math.pi / angle) * angle / 2
print('{0:.6f}'.format(s))


import itertools
import math

def get_x(p):
	return p[0]

def get_y(p):
	return p[1]

def circumcenter(a, b, c):
	(a_x, a_y) = (get_x(a), get_y(a))
	(b_x, b_y) = (get_x(b), get_y(b))
	(c_x, c_y) = (get_x(c), get_y(c))
	d = 2 * (a_x * (b_y - c_y) + b_x * (c_y - a_y) + c_x * (a_y - b_y))
	u_x = ((a_x ** 2 + a_y ** 2) * (b_y - c_y) + (b_x ** 2 + b_y ** 2) * (c_y - a_y) + (c_x ** 2 + c_y ** 2) * (a_y - b_y)) / d
	u_y = ((a_x ** 2 + a_y ** 2) * (c_x - b_x) + (b_x ** 2 + b_y ** 2) * (a_x - c_x) + (c_x ** 2 + c_y ** 2) * (b_x - a_x)) / d
	return (u_x, u_y)

def distance(a, b):
	return math.sqrt((get_x(a) - get_x(b)) ** 2 + (get_y(a) - get_y(b)) ** 2)

def angle(center, p1, p2):
	a = (get_x(p1) - get_x(center), get_y(p1) - get_y(center))
	b = (get_x(p2) - get_x(center), get_y(p2) - get_y(center))
	try:
		return math.acos((get_x(a) * get_x(b) + get_y(a) * get_y(b)) / (distance(center, p1) * distance(center, p2)))
	except ValueError:
		acos_parameter = (get_x(a) * get_x(b) + get_y(a) * get_y(b)) / (distance(center, p1) * distance(center, p2))
		if acos_parameter < -1:
			return math.acos(-1)
		elif acos_parameter > 1:
			return math.acos(1)
		else:
			print('Center: {0}'.format(center))
			print('p1: {0}'.format(p1))
			print('p2: {0}'.format(p2))
			print('Denominator: {0}'.format(distance(center, p1) * distance(center, p2)))
			print('acos parameter: {0}'.format((get_x(a) * get_x(b) + get_y(a) * get_y(b)) / (distance(center, p1) * distance(center, p2))))
			exit()

def regular_polygon_area(num_sides, circumcircle_radius):
	return 0.5 * num_sides * circumcircle_radius ** 2 * math.sin(2 * math.pi / num_sides)

def is_near_integer(x):
	return abs(round(x) - x) < 0.001

def solution(p1, p2, p3):
	center = circumcenter(p1, p2, p3)
	angles = [angle(center, *points) for points in itertools.combinations([p1, p2, p3], 2)]
	min_area = float('inf')
	for num_sides in range(3, 101):
		radius_angle = 2 * math.pi / num_sides
		is_valid = True
		for center_point_angle in angles:
			if not is_near_integer(center_point_angle / radius_angle):
				is_valid = False
		if is_valid:
			min_area = min(min_area, regular_polygon_area(num_sides, distance(center, p1)))
	return min_area
points = [tuple(map(lambda x: float(x), input().split(' '))) for i in range(3)]
print(solution(*points))


import sys
import math
from functools import reduce
from math import sqrt

def float_gcd(a, b, rtol=1e-05, atol=1e-08):
	t = min(abs(a), abs(b))
	while abs(b) > rtol * t + atol:
		(a, b) = (b, a % b)
	return a

def side_length(p1, p2):
	return math.hypot(p2[0] - p1[0], p2[1] - p1[1])

def get_num_sides(p1, p2, p3):
	sides = {}
	sides[side_length(p1, p2)] = [p1, p2]
	sides[side_length(p2, p3)] = [p2, p3]
	sides[side_length(p3, p1)] = [p3, p1]
	s = list(sorted(sides.keys()))
	cAng = [math.acos(1 - ms * ms / (2 * radius * radius)) for ms in s]
	cAngDegF = [round(x * 360 / (2 * math.pi), 3) for x in cAng]
	for c in range(3, 365):
		cAF = 360 / c
		err = sum([abs(x / cAF - round(x / cAF)) for x in cAngDegF])
		if err < 0.001:
			break
	return c
	cAngGCDF = 360 // side_count
	print('regular angle={}, sides={}'.format(cAngGCDF, side_count), file=sys.stderr)
	return side_count

def define_circle(p1, p2, p3):
	temp = p2[0] * p2[0] + p2[1] * p2[1]
	bc = (p1[0] * p1[0] + p1[1] * p1[1] - temp) / 2
	cd = (temp - p3[0] * p3[0] - p3[1] * p3[1]) / 2
	det = (p1[0] - p2[0]) * (p2[1] - p3[1]) - (p2[0] - p3[0]) * (p1[1] - p2[1])
	if abs(det) < 1e-06:
		return (None, math.inf)
	cx = (bc * (p2[1] - p3[1]) - cd * (p1[1] - p2[1])) / det
	cy = ((p1[0] - p2[0]) * cd - (p2[0] - p3[0]) * bc) / det
	radius = math.sqrt((cx - p1[0]) ** 2 + (cy - p1[1]) ** 2)
	return ((cx, cy), radius)
pts = []
for _ in range(3):
	(x, y) = list(map(float, input().split()))
	pts = pts + [[x, y]]
(center, radius) = define_circle(pts[0], pts[1], pts[2])
sidecount = get_num_sides(pts[0], pts[1], pts[2])
cAng = 2 * math.pi / sidecount
area = 0.5 * radius * radius * math.sin(math.pi - cAng) * sidecount
print('{:.6f}'.format(area))
if False:
	if center is not None:
		plt.figure(figsize=(4, 4))
		circle = plt.Circle(center, radius)
		plt.gcf().gca().add_artist(circle)
		plt.show()


from math import *
m = [list(map(float, input().split())) for i in range(3)]
(a, b, c) = [hypot(m[i][0] - m[(i + 1) % 3][0], m[i][1] - m[(i + 1) % 3][1]) for i in range(3)]
(A, B, C) = [acos((y * y + z * z - x * x) / (2 * y * z)) for (x, y, z) in [(a, b, c), (b, c, a), (c, a, b)]]
R = a / sin(A) * 0.5

def g(x, y):
	return x if y < 0.001 else g(y, fmod(x, y))
u = 2 * g(pi, g(A, g(B, C)))
print(R * R * sin(u) * pi / u)


import math
EPS = 1e-05

def l(p1, p2):
	x = (p1[0] + p2[0]) / 2.0
	y = (p1[1] + p2[1]) / 2.0
	m = (p2[0] - p1[0]) / (p1[1] - p2[1])
	return (m, y - m * x)

def dint(d, n):
	x = d / (2 * math.pi / n)
	return abs(int(x + EPS) - x) <= EPS
p = [list(map(float, input().split())) for i in range(3)]
(m1, b1) = l(p[0], p[1] if p[0][1] != p[1][1] else p[2])
(m2, b2) = l(p[2], p[1] if p[2][1] != p[1][1] else p[0])
xc = (b2 - b1) / (m1 - m2)
yc = m1 * xc + b1
r = ((p[0][0] - xc) ** 2 + (p[0][1] - yc) ** 2) ** 0.5
a = [math.atan2(pi[0] - xc, pi[1] - yc) for pi in p]
(d1, d2) = (abs(a[1] - a[0]), abs(a[2] - a[1]))
for i in range(3, 101):
	if dint(d1, i) and dint(d2, i):
		print(0.5 * i * r ** 2 * math.sin(2 * math.pi / i))
		break


import math
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
c1 = (x2 ** 2 - x1 ** 2 + y2 ** 2 - y1 ** 2) / 2
c2 = (x3 ** 2 - x2 ** 2 + y3 ** 2 - y2 ** 2) / 2
r1 = (c1 * (y3 - y2) - c2 * (y2 - y1)) / ((x2 - x1) * (y3 - y2) - (x3 - x2) * (y2 - y1))
r2 = (c1 * (x3 - x2) - c2 * (x2 - x1)) / ((y2 - y1) * (x3 - x2) - (y3 - y2) * (x2 - x1))
r = ((r1 - x1) ** 2 + (r2 - y1) ** 2) ** 0.5
foobar = 0
for i in range(3, 101):
	foo = False
	bar = False
	for ii in range(1, i):
		x4 = (x1 - r1) * math.cos(2 * math.pi * ii / i) - math.sin(2 * math.pi * ii / i) * (y1 - r2) + r1
		y4 = (y1 - r2) * math.cos(2 * math.pi * ii / i) + math.sin(2 * math.pi * ii / i) * (x1 - r1) + r2
		if (x4 - x2) ** 2 + (y4 - y2) ** 2 < 1e-05:
			foo = True
		if (x4 - x3) ** 2 + (y4 - y3) ** 2 < 1e-05:
			bar = True
	if foo and bar:
		foobar = i
		break
print(foobar * r ** 2 * math.sin(2 * math.pi / foobar) / 2)


from math import pi, sin, cos, sqrt

class R2:

	def __init__(self, x, y):
		self.x = x
		self.y = y

	def __add__(self, v):
		return R2(self.x + v.x, self.y + v.y)

	def __sub__(self, v):
		return R2(self.x - v.x, self.y - v.y)

	def __mul__(self, c):
		return R2(c * self.x, c * self.y)

	def __rmul__(self, c):
		return R2(c * self.x, c * self.y)

	def __truediv__(self, c):
		return R2(self.x / c, self.y / c)

	def __str__(self):
		return '({},{}) vector in R2'.format(self.x, self.y)

	def __abs__(self):
		return sqrt(self.x * self.x + self.y * self.y)

	def unit(self):
		return self / abs(self)

	def get(self):
		return (self.x, self.y)

	def rotate(self, theta):
		return R2(self.x * cos(theta) - self.y * sin(theta), self.x * sin(theta) + self.y * cos(theta))

def area(n, r):
	return 0.5 * n * r * r * sin(2 * pi / n)

def find_circle(a, b, c):
	dir1 = (b - a).unit().rotate(pi / 2)
	dir2 = (c - b).unit().rotate(pi / 2)
	half1 = a + (b - a) / 2
	half2 = b + (c - b) / 2
	(x1, y1) = dir1.get()
	(x2, y2) = dir2.get()
	(r1, s1) = half1.get()
	(r2, s2) = half2.get()
	x = (s1 - s2 + r2 * (y2 / x2) - r1 * (y1 / x1)) / (y2 / x2 - y1 / x1)
	y = (x - r1) * (y1 / x1) + s1
	center = R2(x, y)
	radius = abs(center - a)
	return (center, radius)

def find_polygon(a, b, c, error=1e-05):
	(center, r) = find_circle(a, b, c)
	init_arm = a - center
	for n in range(3, 101):
		theta = 2 * pi / n
		b_found = False
		c_found = False
		for i in range(1, n):
			arm = init_arm.rotate(i * theta)
			v = center + arm
			if abs(v - b) < error:
				b_found = True
			elif abs(v - c) < error:
				c_found = True
		if b_found and c_found:
			return (n, r)
a = [float(i) for i in input().split()]
b = [float(i) for i in input().split()]
c = [float(i) for i in input().split()]
a = R2(a[0], a[1])
b = R2(b[0], b[1])
c = R2(c[0], c[1])
(n, r) = find_polygon(a, b, c)
print(area(n, r))


import math

def ToEdgePt(p):
	l1 = ((p[1][0] - p[0][0]) ** 2 + (p[1][1] - p[0][1]) ** 2) ** (1 / 2)
	l2 = ((p[2][0] - p[1][0]) ** 2 + (p[2][1] - p[1][1]) ** 2) ** (1 / 2)
	l3 = ((p[2][0] - p[0][0]) ** 2 + (p[2][1] - p[0][1]) ** 2) ** (1 / 2)
	return [l1, l2, l3]

def angles(e):
	a1 = math.acos((e[1] ** 2 + e[2] ** 2 - e[0] ** 2) / (2 * e[1] * e[2]))
	a2 = math.acos((e[0] ** 2 + e[2] ** 2 - e[1] ** 2) / (2 * e[0] * e[2]))
	a3 = math.acos((e[0] ** 2 + e[1] ** 2 - e[2] ** 2) / (2 * e[0] * e[1]))
	return [a1, a2, a3]

def Area(e, a):
	return e[0] * e[1] * math.sin(a[2]) / 2

def Raza(e, area):
	return e[0] * e[1] * e[2] / (4 * area)

def MinPiloni(a):
	return math.pi / float_gcd(float_gcd(a[0], a[1]), a[2])

def FinalArea(nr, raza):
	return nr / 2 * raza ** 2 * math.sin(2 * math.pi / nr)

def float_gcd(a, b):
	if a < b:
		return float_gcd(b, a)
	if abs(b) < 0.001:
		return a
	else:
		return float_gcd(b, a - math.floor(a / b) * b)
points = []
for i in range(3):
	points.append(list(map(float, input().split())))
e = ToEdgePt(points)
a = angles(e)
A = Area(e, a)
R = Raza(e, A)
piloni = MinPiloni(a)
print('%.8f' % FinalArea(piloni, R))


import math
epsilon = 0.01

def gcd(x, y):
	while abs(x) > epsilon and abs(y) > epsilon:
		if x > y:
			x -= math.floor(x / y) * y
		else:
			y -= math.floor(y / x) * x
	return x + y
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
a = math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
b = math.sqrt((x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3))
c = math.sqrt((x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3))
p = (a + b + c) / 2
S = math.sqrt(p * (p - a) * (p - b) * (p - c))
R = a * b * c / 4 / S
alpha = math.acos((b * b + c * c - a * a) / (2 * b * c))
beta = math.acos((a * a + c * c - b * b) / (2 * a * c))
gama = math.acos((b * b + a * a - c * c) / (2 * b * a))
n = math.pi / gcd(gcd(alpha, beta), gama)
area = n / 2 * R * R * math.sin(2 * math.pi / n)
print(area)


from math import acos, sin, fmod, degrees, radians, pi
A = [float(i) for i in input().split(' ')]
B = [float(i) for i in input().split(' ')]
C = [float(i) for i in input().split(' ')]

def g(x, y):
	return x if y < 0.001 else g(y, fmod(x, y))

def angles(A, B, C):
	AB = (A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2
	BC = (C[0] - B[0]) ** 2 + (C[1] - B[1]) ** 2
	AC = (A[0] - C[0]) ** 2 + (A[1] - C[1]) ** 2
	alpha = 2 * degrees(acos((AC + AB - BC) / (2 * (AC * AB) ** 0.5)))
	betta = 2 * degrees(acos((BC + AB - AC) / (2 * (BC * AB) ** 0.5)))
	tetta = 2 * degrees(acos((BC + AC - AB) / (2 * (BC * AC) ** 0.5)))
	R = BC ** 0.5 / 2 / sin(radians(alpha / 2))
	n = 360 / g(g(alpha, betta), tetta)
	S = n / 2 * R ** 2 * sin(2 * pi / n)
	return S
print(angles(A, B, C))


from math import acos, pi, cos, sin

def angle(A, B, C):
	a = (A[0] - B[0], A[1] - B[1])
	b = (C[0] - B[0], C[1] - B[1])
	prod = a[0] * b[0] + a[1] * b[1]
	return acos(prod / ((a[0] ** 2 + a[1] ** 2) * (b[0] ** 2 + b[1] ** 2)) ** 0.5)
points = [tuple(map(float, input().split())) for _ in range(3)]
parts = []
for i in range(3):
	parts.append(angle(points[i - 1], points[i], points[(i + 1) % 3]) / pi)
for n in range(3, 101):
	if max((abs(x * n - round(x * n)) for x in parts)) < 0.001:
		a = ((points[0][0] - points[1][0]) ** 2 + (points[0][1] - points[1][1]) ** 2) ** 0.5
		R = a / (2 * sin(angle(points[1], points[2], points[0])))
		print(n * R ** 2 * sin(pi / n) * cos(pi / n))
		break


import math
import sys

def read_input():
	[input_1, input_2, input_3] = sys.stdin.readlines()
	(x1, y1) = input_1.strip().split()
	(x2, y2) = input_2.strip().split()
	(x3, y3) = input_3.strip().split()
	x1 = float(x1)
	x2 = float(x2)
	x3 = float(x3)
	y1 = float(y1)
	y2 = float(y2)
	y3 = float(y3)
	return (x1, x2, x3, y1, y2, y3)

def outer_center(x1, x2, x3, y1, y2, y3):
	A1 = 2 * (x2 - x1)
	B1 = 2 * (y2 - y1)
	C1 = x2 * x2 + y2 * y2 - x1 * x1 - y1 * y1
	A2 = 2 * (x3 - x2)
	B2 = 2 * (y3 - y2)
	C2 = x3 * x3 + y3 * y3 - x2 * x2 - y2 * y2
	x = (C1 * B2 - C2 * B1) / (A1 * B2 - A2 * B1)
	y = (A1 * C2 - A2 * C1) / (A1 * B2 - A2 * B1)
	return (x, y)

def get_degree(x1, x2, x3, y1, y2, y3):
	A = math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2))
	B = math.sqrt((x3 - x2) * (x3 - x2) + (y3 - y2) * (y3 - y2))
	C = math.sqrt((x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3))
	c = math.acos((A ** 2 + B ** 2 - C ** 2) / (2 * A * B)) * 180 / math.pi
	b = math.acos((A ** 2 + C ** 2 - B ** 2) / (2 * A * C)) * 180 / math.pi
	a = math.acos((B ** 2 + C ** 2 - A ** 2) / (2 * C * B)) * 180 / math.pi
	return (a, b, c)

def find_gcd(a, b, c):
	a = int(round(a))
	b = int(round(b))
	c = int(round(c))
	temp1 = math.gcd(a, b)
	temp2 = math.gcd(temp1, c)
	return temp2

def determine_angles(gcd):
	return int(180 / gcd)

def get_radius(x0, y0, x1, y1):
	return math.sqrt((x0 - x1) ** 2 + (y0 - y1) ** 2)
eps = 0.001
DEBUG = 0
(x1, x2, x3, y1, y2, y3) = read_input()
if DEBUG == 1:
	print('success!')
(x, y) = outer_center(x1, x2, x3, y1, y2, y3)
if DEBUG == 1:
	print('x=', x, 'y=', y)
(a, b, c) = get_degree(x1, x2, x3, y1, y2, y3)
if DEBUG == 1:
	print('angle A=', a, 'angle B=', b, 'angle C=', c)
r = get_radius(x, y, x1, y1)
if DEBUG == 1:
	print('r=', r)
if abs(a - round(a)) > eps or abs(b - round(b)) > eps or abs(c - round(c)) > eps:
	smallest = min(a, min(b, c))
	largest = max(a, max(b, c))
	N = 0
	for i in range(1, 2000):
		if abs(smallest * i - round(smallest * i)) < eps and smallest * i - 180 > -eps:
			if abs(smallest * i / 180 - round(smallest * i / 180)) < eps:
				gcd_angle = math.gcd(int(round(largest * i)), int(round(smallest * i)))
				if DEBUG == 1:
					print('gcd_angle=', gcd_angle)
				if gcd_angle == int(round(smallest * i)):
					N = i
					if DEBUG == 1:
						print('hit')
					break
				else:
					t = 180 / gcd_angle * i
					if DEBUG == 1:
						print('miss', 180 / gcd_angle * i)
					for j in range(1, 20):
						if abs(t * j - round(t * j)) < eps:
							N = int(t * j)
							break
					break
	if N == 0:
		N = 46
	if DEBUG == 1:
		print('Using alternative method, N =', N)
else:
	gcd = find_gcd(a, b, c)
	if DEBUG == 1:
		print('gcd=', gcd)
	N = determine_angles(gcd)
	if DEBUG == 1:
		print('N=', N)
area = 0.5 * N * r * r * math.sin(2 / N * math.pi)
print('%.6f' % area)


from time import *
from math import *

def dist(x1, y1, x2, y2):
	return ((x1 - x2) ** 2 + (y1 - y2) ** 2) ** 0.5

def isInteger(x):
	return abs(x - round(x)) < 0.01

def area(x1, y1, x2, y2, x3, y3):
	a = dist(x1, y1, x2, y2)
	b = dist(x3, y3, x2, y2)
	c = dist(x1, y1, x3, y3)
	d = (a + b + c) / 2
	return (d * (d - a) * (d - b) * (d - c)) ** 0.5

def radiusOuter(x1, y1, x2, y2, x3, y3):
	return a * b * c / area(x1, y1, x2, y2, x3, y3) / 4

def linePass2Point(x1, y1, x2, y2):
	a = y2 - y1
	b = x1 - x2
	c = -a * x1 - b * y1
	return (a, b, c)

def intersect(a1, b1, c1, a2, b2, c2):
	y = -(a2 * c1 - a1 * c2) / (a2 * b1 - a1 * b2)
	x = -(b2 * c1 - b1 * c2) / (b2 * a1 - b1 * a2)
	return (x, y)

def midLine(x1, y1, x2, y2):
	(a1, b1, c1) = linePass2Point(x1, y1, x2, y2)
	(a2, b2) = (-b1, a1)
	(x, y) = ((x1 + x2) / 2, (y1 + y2) / 2)
	c2 = -(a2 * x + b2 * y)
	return (a2, b2, c2)

def centerOfOuterTriangle(x1, y1, x2, y2, x3, y3):
	(a1, b1, c1) = midLine(x1, y1, x2, y2)
	(a2, b2, c2) = midLine(x1, y1, x3, y3)
	(x, y) = intersect(a1, b1, c1, a2, b2, c2)
	return (x, y, dist(x, y, x1, y1))

def angle(x1, y1, x2, y2, x3, y3):
	c = dist(x1, y1, x2, y2)
	b = dist(x3, y3, x2, y2)
	a = dist(x1, y1, x3, y3)
	tg = (a * a + b * b - c * c) / (2 * a * b)
	if tg <= -1:
		tg += 1e-05
	elif tg >= 1:
		tg -= 1e-05
	return acos(tg)

def areaByRadius(r, n):
	return r * r * n * sin(2 * pi / n) / 2
(x1, y1) = [float(i) for i in input().split()]
(x2, y2) = [float(i) for i in input().split()]
(x3, y3) = [float(i) for i in input().split()]

def check(n):
	global x, y, r
	a = 2 * pi / n
	return isInteger(a1 / a) and isInteger(a2 / a) and isInteger(a3 / a)
(x, y, r) = centerOfOuterTriangle(x1, y1, x2, y2, x3, y3)
a1 = angle(x1, y1, x2, y2, x, y)
a2 = angle(x3, y3, x2, y2, x, y)
a3 = angle(x1, y1, x3, y3, x, y)
for i in range(3, 101):
	a = 2 * pi / i
	t1 = int(isInteger(a1 / a))
	t2 = int(isInteger(a2 / a))
	t3 = int(isInteger(a3 / a))
	if t1 + t2 + t3 >= 2:
		print(round(areaByRadius(r, i), 9))
		break


import math

def getEgde(x1, y1, x2, y2):
	ans = math.sqrt(pow(x1 - x2, 2) + pow(y1 - y2, 2))
	return ans

def gcd(x, y):
	if x < esp:
		return y
	if y < esp:
		return x
	return gcd(y, math.fmod(x, y))
x = [0] * 3
y = [0] * 3
esp = 0.01
for i in range(0, 3):
	cord = input().split()
	x[i] = float(cord[0])
	y[i] = float(cord[1])
a = getEgde(x[0], y[0], x[1], y[1])
b = getEgde(x[0], y[0], x[2], y[2])
c = getEgde(x[2], y[2], x[1], y[1])
p = (a + b + c) / 2
s = math.sqrt(p * (p - a) * (p - b) * (p - c))
r = a * b * c / (4 * s)
angle = [0] * 3
a = float('%.9f' % a)
b = float('%.9f' % b)
c = float('%.9f' % c)
r = float('%.9f' % r)
angle[0] = 2 * math.asin(a / (2 * r))
angle[1] = 2 * math.asin(b / (2 * r))
angle[2] = 2 * math.pi - angle[0] - angle[1]
aver = angle[0]
i = 1
for i in range(0, 3):
	aver = gcd(aver, angle[i])
n = 2 * math.pi / aver
area = r * r * math.sin(aver) / 2
print('%.8f' % (n * area))


import math
P = [tuple(map(float, input().split())) for i in range(3)]

def get_per(v):
	return [v[1], -v[0]]

def get_mid(a, b):
	return ([(u + v) / 2.0 for (u, v) in zip(a, b)], get_per([v - u for (u, v) in zip(a, b)]))
eps = 1e-06

def cross(a, b):
	return a[0] * b[1] - a[1] * b[0]

def get_intersection(a, u, b, v):
	nv = [-x for x in v]
	d = cross(u, nv)
	if abs(d) < eps:
		return None
	L = cross([y - x for (x, y) in zip(a, b)], nv) / d
	return (a[0] + L * u[0], a[1] + L * u[1])

def length(A):
	return math.sqrt(A[0] ** 2 + A[1] ** 2)

def getsAngle(A):
	(dx, dy) = A
	t = math.atan2(dy, dx)
	if abs(t) < eps:
		return 0
	if t < 0:
		t += 2 * math.pi
	return t

def getAngle(A, B):
	t = getsAngle(B) - getsAngle(A)
	if abs(t) < eps:
		return 0
	if t < 0:
		t += 2 * math.pi
	return t
ans = 1e+18
for _ in range(3):
	P.append(P.pop(0))
	(a, u) = get_mid(P[0], P[1])
	(b, v) = get_mid(P[1], P[2])
	O = get_intersection(a, u, b, v)
	if O is None:
		continue
	r2 = length([O[0] - P[1][0], O[1] - P[1][1]]) ** 2
	Q = []
	for (x, y) in P:
		Q.append((x - O[0], y - O[1]))
	Q = [(getsAngle(p), p) for p in Q]
	Q.sort()
	T = [getAngle(Q[i][1], Q[(i + 1) % 3][1]) for i in range(3)]
	for n in range(3, 200):
		dt = 2 * math.pi / n
		delta = [abs(t - dt * round(t / dt)) for t in T]
		if sum(delta) < 3 * eps:
			area = n * 0.5 * r2 * math.sin(dt)
			ans = min(ans, area)
print('%.10f' % ans)


import math
import time
A = list(map(float, input().split()))
B = list(map(float, input().split()))
C = list(map(float, input().split()))
m = [((A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2) ** 0.5, ((C[0] - B[0]) ** 2 + (C[1] - B[1]) ** 2) ** 0.5, ((A[0] - C[0]) ** 2 + (A[1] - C[1]) ** 2) ** 0.5]
gamma = math.acos((m[0] ** 2 + m[1] ** 2 - m[2] ** 2) / (2 * m[0] * m[1]))
R = 0.5 * m[2] / math.sin(gamma)
l = [math.pi / math.asin(0.5 * m[1] / R), math.pi / math.asin(0.5 * m[0] / R), math.pi / gamma]
x = 3
while True:
	if round(x / l[0], 2) == round(x / l[0], 0) and round(x / l[1], 2) == round(x / l[1], 0) and (round(x / l[2], 2) == round(x / l[2], 0)):
		y = x
		break
	x += 1
print(y * 0.5 * R ** 2 * math.sin(2 * math.pi / y))


import sys
import math

def eucl(x1, x2):
	return math.sqrt((x1[0] - x2[0]) ** 2 + (x1[1] - x2[1]) ** 2)

def area_tri(dist):
	S = sum(dist) / 2
	ss = [S - d for d in dist]
	ret = S
	for sss in ss:
		ret *= sss
	ret = math.sqrt(ret)
	return ret

def gcd_float(x, y, eps=0.0001):
	while abs(x) > eps and abs(y) > eps:
		if x > y:
			x -= int(x / y) * y
		else:
			y -= int(y / x) * x
	return x + y
pts = []
for i in range(3):
	(x, y) = map(float, input().split())
	pts.append((x, y))
dist = [eucl(pts[i], pts[(i + 1) % 3]) for i in range(3)]
S = area_tri(dist)
num = 1
for d in dist:
	num *= d
R = num / (4 * S)
d_squares = [d ** 2 for d in dist]
angles = [math.acos((d_squares[(i + 1) % 3] + d_squares[(i + 2) % 3] - d_squares[i]) / (2 * dist[(i + 1) % 3] * dist[(i + 2) % 3])) for i in range(3)]
G = gcd_float(angles[0], gcd_float(angles[1], angles[2]))
n = math.pi / G
area = 0.5 * n * R * R * math.sin(2 * math.pi / n)
print(area)


s1 = input().split()
s2 = input().split()
s3 = input().split()
ax = float(s1[0])
ay = float(s1[1])
bx = float(s2[0])
by = float(s2[1])
cx = float(s3[0])
cy = float(s3[1])
det = (bx - ax) * (cy - ay) - (by - ay) * (cx - ax)
det_x = (by - ay) * (ax * ax + ay * ay - cx * cx - cy * cy) - (cy - ay) * (ax * ax + ay * ay - bx * bx - by * by)
det_y = (cx - ax) * (ax * ax + ay * ay - bx * bx - by * by) - (bx - ax) * (ax * ax + ay * ay - cx * cx - cy * cy)
ox = det_x / det / 2.0
oy = det_y / det / 2.0

def shortest(x, y, pts):
	d2_min = None
	for pt in pts:
		dx = pt[0] - x
		dy = pt[1] - y
		d2 = dx * dx + dy * dy
		if d2_min is None or d2 < d2_min:
			d2_min = d2
	return d2_min
import math
d_min = None
num_min = None
oax = ax - ox
oay = ay - oy
r = math.sqrt(oax * oax + oay * oay)
if abs(oax) < 1e-08:
	alpha = math.pi / 2 if oay > 0 else -math.pi / 2
else:
	alpha = math.atan(oay / oax) if oax > 0 else math.pi + math.atan(oay / oax)
for num in range(3, 101):
	pts = []
	for i in range(1, num):
		rad = i * 2 * math.pi / num
		pts.append((ox + r * math.cos(rad + alpha), oy + r * math.sin(rad + alpha)))
	s2 = shortest(bx, by, pts)
	s3 = shortest(cx, cy, pts)
	s = s2 + s3
	if d_min is None or s < d_min - 1e-08:
		d_min = s
		num_min = num
beta = 2 * math.pi / num_min
area = num_min * r * r * math.sin(beta) / 2.0
print(f'{area:.8f}')


import math

def angle():
	for i in range(3, 101):
		a = math.pi * (1.0 - 2.0 / i)
		yield a

def central_angle():
	for i in range(3, 101):
		a = 2.0 * math.pi / i
		yield a

def dist(x1, x2):
	return math.sqrt((x1[0] - x2[0]) ** 2 + (x1[1] - x2[1]) ** 2)

def dist2(x1, x2):
	return (x1[0] - x2[0]) ** 2 + (x1[1] - x2[1]) ** 2

def dot(a, b):
	return a[0] * b[1] - a[1] * b[0]

def prod(a, b):
	return a[0] * b[0] + a[1] * b[1]

def isint(x):
	if x - math.floor(x) < 1e-05:
		return True
	if math.ceil(x) - x < 1e-05:
		return True
	return False

def lineInt(line1, line2):
	a = line1[0]
	b = line1[1]
	c = line2[0]
	d = line2[1]
	s = (a[1] - c[1] + (b[1] - a[1]) * (c[0] - a[0]) / (b[0] - a[0])) / (d[1] - c[1] - (b[1] - a[1]) * (d[0] - c[0]) / (b[0] - a[0]))
	x = c[0] + (d[0] - c[0]) * s
	y = c[1] + (d[1] - c[1]) * s
	return (x, y)

def findCentre(a, b, c):
	m1 = [(a[0] + b[0]) * 0.5, (a[1] + b[1]) * 0.5]
	m2 = [(c[0] + b[0]) * 0.5, (c[1] + b[1]) * 0.5]
	line1 = (m1, [m1[0] + b[1] - a[1], m1[1] + a[0] - b[0]])
	line2 = (m2, [m2[0] + b[1] - c[1], m2[1] + c[0] - b[0]])
	return lineInt(line1, line2)
a = list(map(float, input().split()))
b = list(map(float, input().split()))
c = list(map(float, input().split()))
x = findCentre(a, b, c)
r = dist(a, x)
r2 = dist2(a, x)
alpha = math.acos(prod([a[0] - x[0], a[1] - x[1]], [b[0] - x[0], b[1] - x[1]]) / (r * r))
beta = math.acos(prod([b[0] - x[0], b[1] - x[1]], [c[0] - x[0], c[1] - x[1]]) / (r * r))
n = 2.0
for theta in central_angle():
	n = n + 1.0
	k1 = alpha / theta
	k2 = beta / theta
	if isint(k1) and isint(k2):
		print(n / 2.0 * r2 * math.sin(theta))
		break


import sys
import math
debug = len(sys.argv) >= 2 and sys.argv[1] == '--debug'

def debug_print(message):
	if debug:
		print(message)

def read_int():
	return int(input())

def read_array(constructor):
	return [constructor(x) for x in input().split()]

def read_int_array():
	return read_array(int)

def angle(a, b, c):
	return math.acos((a ** 2 + b ** 2 - c ** 2) / (2 * a * b))

def near_2nPi(angle):
	diff = angle % (2 * math.pi)
	debug_print(diff)
	return math.isclose(diff, 0, abs_tol=0.01) or math.isclose(diff, 2 * math.pi, rel_tol=0.01)
p = read_array(float)
q = read_array(float)
r = read_array(float)
pq = math.hypot(q[0] - p[0], q[1] - p[1])
pr = math.hypot(r[0] - p[0], r[1] - p[1])
qr = math.hypot(r[0] - q[0], r[1] - q[1])
angle_qpr = angle(pq, pr, qr)
angle_pqr = angle(pq, qr, pr)
angle_prq = angle(qr, pr, pq)
radius = qr / (2 * math.sin(angle_qpr))
num_angle = 0
for n in range(1, 101):
	if near_2nPi(angle_qpr * 2 * n) and near_2nPi(angle_pqr * 2 * n) and near_2nPi(angle_prq * 2 * n):
		num_angle = n
		break
else:
	debug_print('ERROR: n={0}, num_angle={1}'.format(n, num_angle))
angle = 2 * math.pi / num_angle
area = radius ** 2 * math.sin(angle) * num_angle / 2
print('{0:f}'.format(area))


import sys, math

def slope(point1, point2):
	if point2[0] - point1[0] != 0:
		return (point2[1] - point1[1]) / (point2[0] - point1[0])
	word = 'undef'
	return word

def dist(point1, point2):
	return math.sqrt((point2[1] - point1[1]) ** 2 + (point2[0] - point1[0]) ** 2)

def gcd(x, y):
	eps = 10 ** (-4)
	while abs(x) > eps and abs(y) > eps:
		if x > y:
			x -= math.floor(x / y) * y
		else:
			y -= math.floor(y / x) * x
	return x + y
lines = sys.stdin.readlines()
A_point = lines[0].split()
B_point = lines[1].split()
C_point = lines[2].split()
A_pt_x = float(A_point[0])
A_pt_y = float(A_point[1])
B_pt_x = float(B_point[0])
B_pt_y = float(B_point[1])
C_pt_x = float(C_point[0])
C_pt_y = float(C_point[1])
A = [A_pt_x, A_pt_y]
B = [B_pt_x, B_pt_y]
C = [C_pt_x, C_pt_y]
slope_start = [slope(A, B), slope(B, C), slope(C, A)]
slopes = []
for f in slope_start:
	if f == 'undef':
		slopes.append(0)
	elif f == 0:
		slopes.append('undef')
	else:
		slopes.append(-1 * (1 / f))
AB_perp_point = [(A_pt_x + B_pt_x) / 2, (A_pt_y + B_pt_y) / 2]
BC_perp_point = [(B_pt_x + C_pt_x) / 2, (B_pt_y + C_pt_y) / 2]
AC_perp_point = [(A_pt_x + C_pt_x) / 2, (A_pt_y + C_pt_y) / 2]
perp_points = [AB_perp_point, BC_perp_point, AC_perp_point]
perp_b = []
for f in range(len(slopes)):
	if slopes[f] == 'undef':
		perp_b.append('none')
	else:
		perp_b.append(-1 * slopes[f] * perp_points[f][0] + perp_points[f][1])
perp = []
for f in range(len(slopes)):
	if slopes[f] != 'undef':
		perp.append([slopes[f], perp_b[f]])
perp_1 = perp[0]
perp_2 = perp[1]
x_circ = (perp_2[1] - perp_1[1]) / (perp_1[0] - perp_2[0])
y_circ = perp_1[0] * x_circ + perp_1[1]
circ = [x_circ, y_circ]
c_seg = dist(A, B)
a_seg = dist(B, C)
b_seg = dist(A, C)
A_ang = math.acos((b_seg ** 2 + c_seg ** 2 - a_seg ** 2) / (2 * b_seg * c_seg))
B_ang = math.acos((a_seg ** 2 + c_seg ** 2 - b_seg ** 2) / (2 * a_seg * c_seg))
C_ang = math.acos((a_seg ** 2 + b_seg ** 2 - c_seg ** 2) / (2 * a_seg * b_seg))
angles = [A_ang, B_ang, C_ang]
gcd = gcd(angles[0], gcd(angles[1], angles[2]))
gcd
n = math.ceil(math.pi / gcd)
R = dist(circ, A)
area = n / 2 * R ** 2 * math.sin(2 * math.pi / n)
print(area)


import math

def simultaneous_equation(a, b, c, d, u, v):
	return [(u * d - b * v) / (a * d - b * c), (a * v - u * c) / (a * d - b * c)]

def hcf(x, y):
	while y:
		if x % y < 0.01:
			(x, y) = (y, 0)
		else:
			(x, y) = (y, x % y)
	return x
pt1 = list(map(float, input().split()))
pt2 = list(map(float, input().split()))
pt3 = list(map(float, input().split()))
center = simultaneous_equation(2 * (pt1[0] - pt2[0]), 2 * (pt1[1] - pt2[1]), 2 * (pt2[0] - pt3[0]), 2 * (pt2[1] - pt3[1]), pt1[0] ** 2 + pt1[1] ** 2 - pt2[0] ** 2 - pt2[1] ** 2, pt2[0] ** 2 + pt2[1] ** 2 - pt3[0] ** 2 - pt3[1] ** 2)
pt1_pt2 = math.sqrt((pt1[0] - pt2[0]) ** 2 + (pt1[1] - pt2[1]) ** 2)
pt2_pt3 = math.sqrt((pt2[0] - pt3[0]) ** 2 + (pt2[1] - pt3[1]) ** 2)
pt_center = math.sqrt((pt1[0] - center[0]) ** 2 + (pt1[1] - center[1]) ** 2)
angle1c2 = math.acos((2 * pt_center ** 2 - pt1_pt2 ** 2) / 2 / pt_center ** 2)
angle2c3 = math.acos((2 * pt_center ** 2 - pt2_pt3 ** 2) / 2 / pt_center ** 2)
area = pt_center ** 2 * math.sin(hcf(hcf(angle1c2, angle2c3), 2 * math.pi)) * math.pi / hcf(hcf(angle1c2, angle2c3), 2 * math.pi)
print('%.6f' % area)


import math
pi = math.pi
eps = 0.0001

def gcd(x, y):
	if x < y:
		return gcd(y, x)
	if abs(y) < eps:
		return x
	else:
		return gcd(y, x - x // y * y)

def circle(x1, y1, x2, y2, x3, y3):
	x12 = x1 - x2
	x13 = x1 - x3
	y12 = y1 - y2
	y13 = y1 - y3
	y31 = y3 - y1
	y21 = y2 - y1
	x31 = x3 - x1
	x21 = x2 - x1
	sx13 = x1 ** 2 - x3 ** 2
	sy13 = y1 ** 2 - y3 ** 2
	sx21 = x2 ** 2 - x1 ** 2
	sy21 = y2 ** 2 - y1 ** 2
	f = (sx13 * x12 + sy13 * x12 + sx21 * x13 + sy21 * x13) / (2 * (y31 * x12 - y21 * x13))
	g = (sx13 * y12 + sy13 * y12 + sx21 * y13 + sy21 * y13) / (2 * (x31 * y12 - x21 * y13))
	c = -x1 ** 2 - y1 ** 2 - 2 * g * x1 - 2 * f * y1
	h = -g
	k = -f
	r = math.sqrt(h ** 2 + k ** 2 - c)
	return r

def dis(x1, y1, x2, y2):
	return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)

def cos_law(a, b, c):
	return math.acos((a ** 2 + b ** 2 - c ** 2) / (2 * a * b))

def angles(x1, y1, x2, y2, x3, y3):
	d12 = dis(x1, y1, x2, y2)
	d13 = dis(x1, y1, x3, y3)
	d23 = dis(x2, y2, x3, y3)
	a1 = cos_law(d12, d13, d23)
	a2 = cos_law(d12, d23, d13)
	a3 = cos_law(d13, d23, d12)
	return (a1, a2, a3)
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
r = circle(x1, y1, x2, y2, x3, y3)
(a1, a2, a3) = angles(x1, y1, x2, y2, x3, y3)
n = int(pi / gcd(gcd(a1, a2), a3))
a = 1 / 2 * n * r ** 2 * math.sin(2 * pi / n)
print('{:f}'.format(a))


from math import *
a = list(map(float, input().split()))
b = list(map(float, input().split()))
c = list(map(float, input().split()))
da = atan2(b[1] - a[1], b[0] - a[0]) - atan2(c[1] - a[1], c[0] - a[0])
db = atan2(a[1] - b[1], a[0] - b[0]) - atan2(c[1] - b[1], c[0] - b[0])
dc = atan2(b[1] - c[1], b[0] - c[0]) - atan2(a[1] - c[1], a[0] - c[0])
da = abs(da)
db = abs(db)
dc = abs(dc)
if da > pi:
	da = 2 * pi - da
if db > pi:
	db = 2 * pi - db
if dc > pi:
	dc = 2 * pi - dc
bc = (c[0] - b[0]) ** 2 + (c[1] - b[1]) ** 2
for i in range(3, 101):
	x = pi / i
	f = 3 * [0]
	for j in range(1, i - 1):
		if abs(x * j - da) < 0.0001:
			f[0] = 1
		if abs(x * j - db) < 0.0001:
			f[1] = 1
		if abs(x * j - dc) < 0.0001:
			f[2] = 1
	if f == 3 * [1]:
		o = round(da / x) - 1
		t = i * [1]
		for j in range(1, i - 1):
			t[j] = t[j - 1] * cos(x) + cos(x * j)
		print(i * bc / t[o] / t[o] * cos(x) / sin(x) / 4)
		break


from math import *

def gcd_new(p, q):
	if q < 0.0001:
		return p
	return gcd_new(q, fmod(p, q))
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
a = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
b = sqrt((x2 - x3) ** 2 + (y2 - y3) ** 2)
c = sqrt((x3 - x1) ** 2 + (y3 - y1) ** 2)
s = float(a + b + c) / 2
L = sqrt(s * (s - a) * (s - b) * (s - c))
r = float(a * b * c) / float(4 * L)
aa = float(acos(float(b ** 2 + c ** 2 - a ** 2) / float(2 * b * c)))
bb = float(acos(float(c ** 2 + a ** 2 - b ** 2) / float(2 * c * a)))
cc = float(acos(float(a ** 2 + b ** 2 - c ** 2) / float(2 * a * b)))
n = pi / gcd_new(aa, gcd_new(bb, cc))
ans = float(n * r * r * sin(float(2 * pi) / n)) / 2
print(ans)


import math
dx = 10 ** (-6)

def equal(x, y):
	if abs(x - y) <= x * dx:
		return 1
	return 0
l = input().split()
x1 = float(l[0])
y1 = float(l[1])
l = input().split()
x2 = float(l[0])
y2 = float(l[1])
l = input().split()
x3 = float(l[0])
y3 = float(l[1])
d1 = math.sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) ** 2)
d2 = math.sqrt((x1 - x3) * (x1 - x3) + (y1 - y3) ** 2)
d3 = math.sqrt((x3 - x2) * (x3 - x2) + (y3 - y2) ** 2)
ans = 10 ** 18
for n in range(105):
	for a in range(1, n):
		for b in range(1, n):
			if a + b >= n:
				continue
			c = n - (a + b)
			theta = 360 / n
			R = d1 / (2 * math.sin(math.radians(theta * a / 2)))
			z = d2 / (2 * math.sin(math.radians(theta * b / 2)))
			y = d3 / (2 * math.sin(math.radians(theta * c / 2)))
			if equal(R, y) and equal(y, z):
				ans = min(ans, n * R * R * math.sin(math.radians(theta)) / 2)
print(ans)


import math
A = input().split()
B = input().split()
C = input().split()
A = (float(A[0]), float(A[1]))
B = (float(B[0]), float(B[1]))
C = (float(C[0]), float(C[1]))
A1 = 2 * (B[0] - A[0])
B1 = 2 * (B[1] - A[1])
C1 = B[0] ** 2 + B[1] ** 2 - A[0] ** 2 - A[1] ** 2
A2 = 2 * (C[0] - B[0])
B2 = 2 * (C[1] - B[1])
C2 = C[0] ** 2 + C[1] ** 2 - B[0] ** 2 - B[1] ** 2
x = (C1 * B2 - C2 * B1) / (A1 * B2 - A2 * B1)
y = (A1 * C2 - A2 * C1) / (A1 * B2 - A2 * B1)
O = (x, y)
OA = (A[0] - x, A[1] - y)
OB = (B[0] - x, B[1] - y)
OC = (C[0] - x, C[1] - y)
r = math.sqrt(OA[0] ** 2 + OA[1] ** 2)
ag1 = math.acos((OA[0] * OB[0] + OA[1] * OB[1]) / (r * r))
ag2 = math.acos((OA[0] * OC[0] + OA[1] * OC[1]) / (r * r))
ag3 = math.acos((OC[0] * OB[0] + OC[1] * OB[1]) / (r * r))
for i in range(3, 101):
	th = 2 * math.pi / i
	aa = abs(ag1 / th - round(ag1 / th, 0))
	bb = abs(ag2 / th - round(ag2 / th, 0))
	cc = abs(ag3 / th - round(ag3 / th, 0))
	if aa <= 10 ** (-4) and bb <= 10 ** (-4) and (cc <= 10 ** (-4)):
		break
sq = i * 0.5 * r * r * math.sin(th)
print('%.8f' % sq)


from math import acos, sin
from re import split

def dis(a, b):
	return ((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2) ** 0.5

def ang(a, d, b):
	if (dis(a, d) ** 2 + dis(b, d) ** 2 - dis(a, b) ** 2) / (2 * dis(a, d) * dis(b, d)) > 1:
		return acos(1)
	elif (dis(a, d) ** 2 + dis(b, d) ** 2 - dis(a, b) ** 2) / (2 * dis(a, d) * dis(b, d)) < -1:
		return acos(-1)
	else:
		return acos((dis(a, d) ** 2 + dis(b, d) ** 2 - dis(a, b) ** 2) / (2 * dis(a, d) * dis(b, d)))
a = [float(x) for x in input().split()]
b = [float(x) for x in input().split()]
c = [float(x) for x in input().split()]
A1 = 2 * (b[0] - a[0])
B1 = 2 * (b[1] - a[1])
C1 = b[0] ** 2 + b[1] ** 2 - a[0] ** 2 - a[1] ** 2
A2 = 2 * (c[0] - b[0])
B2 = 2 * (c[1] - b[1])
C2 = c[0] ** 2 + c[1] ** 2 - b[0] ** 2 - b[1] ** 2
d = []
d.append((C1 * B2 - C2 * B1) / (A1 * B2 - A2 * B1))
d.append((A1 * C2 - A2 * C1) / (A1 * B2 - A2 * B1))
for i in range(101):
	if i:
		ang_min = 2 * acos(-1) / i
		k1 = ang(a, d, b) / ang_min
		k2 = ang(b, d, c) / ang_min
		k3 = ang(a, d, c) / ang_min
		if abs(round(k1) - k1) <= 0.0001 and abs(round(k2) - k2) <= 0.0001 and (abs(round(k3) - k3) <= 0.0001):
			n = i
			break
s = 1 / 2 * dis(a, d) * dis(a, d) * sin(2 * acos(-1) / n) * n
print('%.8f' % s)


from math import sqrt, sin, pi, acos, floor
EPS = 0.0001

def gcd(a, b):
	while abs(a) > EPS and abs(b) > EPS:
		if a > b:
			a -= floor(a / b) * b
		else:
			b -= floor(b / a) * a
	return a + b

def dist(a, b):
	return sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)

def area(a, b, c):
	return abs(a[0] * (b[1] - c[1]) + b[0] * (c[1] - a[1]) + c[0] * (a[1] - b[1])) / 2
I = lambda : tuple(map(float, input().split()))
a = I()
b = I()
c = I()
AB = dist(a, b)
AC = dist(a, c)
BC = dist(b, c)
r = AB * AC * BC / (4 * area(a, b, c))
A = acos((AC ** 2 + BC ** 2 - AB ** 2) / (2 * AC * BC))
B = acos((AB ** 2 + BC ** 2 - AC ** 2) / (2 * AB * BC))
C = acos((AB ** 2 + AC ** 2 - BC ** 2) / (2 * AB * AC))
d = gcd(gcd(A, B), C)
n = pi / d
print(n / 2 * r ** 2 * sin(2 * pi / n))


from math import pi, sin, acos
(xe1, ye1) = input().split()
(xe2, ye2) = input().split()
(xe3, ye3) = input().split()
(x1, y1) = (float(xe1), float(ye1))
(x2, y2) = (float(xe2), float(ye2))
(x3, y3) = (float(xe3), float(ye3))
mod = []
for i in range(3, 101):
	mod.append(2 * pi / i)

def vecdis(x):
	return (x[0] ** 2 + x[1] ** 2) ** 0.5

def vecangle(x, y, z):
	alpha = acos(abs((x[0] ** 2 + x[1] ** 2 + y[0] ** 2 + y[1] ** 2 - (z[0] ** 2 + z[1] ** 2)) / (2 * (x[0] ** 2 + x[1] ** 2) ** 0.5 * (y[0] ** 2 + y[1] ** 2) ** 0.5)))
	return alpha

def f(x, y):
	for i in range(len(mod)):
		a1 = x / mod[i]
		a2 = y / mod[i]
		if abs(round(a1) - a1) < 0.01 and abs(round(a2) - a2) < 0.01:
			i += 3
			return i
			break
		else:
			continue
ca = [x1 - x3, y1 - y3]
cb = [x2 - x3, y2 - y3]
ab = [x2 - x1, y2 - y1]
alpha1 = 2 * vecangle(ca, cb, ab)
alpha2 = 2 * vecangle(ca, ab, cb)
N = f(alpha1, alpha2)
dis = vecdis(ab)
r = dis / (2 * sin(alpha1 / 2))
s = N * (0.5 * r ** 2 * sin(2 * pi / N))
print('%.7f' % s)


import math

def mcd(a, b):
	if a < b:
		return mcd(b, a)
	if abs(b) < 0.001:
		return a
	else:
		return mcd(b, a - math.floor(a / b) * b)
(a1, b1) = map(float, input().split())
(a2, b2) = map(float, input().split())
(a3, b3) = map(float, input().split())
a = math.sqrt((a2 - a3) ** 2 + (b2 - b3) ** 2)
b = math.sqrt((a1 - a3) ** 2 + (b1 - b3) ** 2)
c = math.sqrt((a1 - a2) ** 2 + (b1 - b2) ** 2)
p = (a + b + c) / 2
S = math.sqrt(p * (p - a) * (p - b) * (p - c))
R = a * b * c / (4 * S)
al = math.acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c))
be = math.acos((a ** 2 + c ** 2 - b ** 2) / (2 * a * c))
ga = math.pi - al - be
n = round(math.pi / mcd(be, mcd(al, ga)))
print('{0:.6f}'.format(R * R * math.sin(2 * math.pi / n) * n / 2))


from math import atan2, sin, pi
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
A = x1 * (y2 - y3) - y1 * (x2 - x3) + x2 * y3 - x3 * y2
B = (x1 ** 2 + y1 ** 2) * (y3 - y2) + (x2 ** 2 + y2 ** 2) * (y1 - y3) + (x3 ** 2 + y3 ** 2) * (y2 - y1)
C = (x1 ** 2 + y1 ** 2) * (x2 - x3) + (x2 ** 2 + y2 ** 2) * (x3 - x1) + (x3 ** 2 + y3 ** 2) * (x1 - x2)
x_O = -B / (2 * A)
y_O = -C / (2 * A)
a1 = atan2(y1 - y_O, x1 - x_O)
a2 = atan2(y2 - y_O, x2 - x_O)
a3 = atan2(y3 - y_O, x3 - x_O)
eps = 1e-05
N = 3
while True:
	if abs(sin(N * (a2 - a1) / 2)) < eps and abs(sin(N * (a3 - a1) / 2)) < eps and (abs(sin(N * (a3 - a2) / 2)) < eps):
		break
	N += 1
radius = ((x1 - x_O) ** 2 + (y1 - y_O) ** 2) ** 0.5
print(N * radius ** 2 * sin(2 * pi / N) / 2)


from math import pi, tan, sin, cos, sqrt

def cot(x):
	return 1 / tan(x)

def area(n, r):
	return 0.5 * n * r * r * sin(2 * pi / n)

def rotate(v, theta):
	return (v[0] * cos(theta) - v[1] * sin(theta), v[0] * sin(theta) + v[1] * cos(theta))

def add(v1, v2):
	return (v1[0] + v2[0], v1[1] + v2[1])

def sub(v1, v2):
	return (v1[0] - v2[0], v1[1] - v2[1])

def mult(v, f):
	return (f * v[0], f * v[1])

def norm(v):
	return sqrt(v[0] ** 2 + v[1] ** 2)

def find_circle(a, b, c):
	dir1 = mult(sub(b, a), 1 / norm(sub(b, a)))
	dir1 = rotate(dir1, pi / 2)
	half1 = add(a, mult(sub(b, a), 1 / 2))
	(a1, b1) = (dir1[0], dir1[1])
	(r1, s1) = (half1[0], half1[1])
	dir2 = mult(sub(c, b), 1 / norm(sub(c, b)))
	dir2 = rotate(dir2, pi / 2)
	half2 = add(b, mult(sub(c, b), 1 / 2))
	(a2, b2) = (dir2[0], dir2[1])
	(r2, s2) = (half2[0], half2[1])
	x = (s1 - s2 + r2 * (b2 / a2) - r1 * (b1 / a1)) / (b2 / a2 - b1 / a1)
	y = (x - r1) * (b1 / a1) + s1
	center = (x, y)
	radius = norm(sub(center, a))
	return (center, radius)

def find_polygon(a, b, c):
	(center, r) = find_circle(a, b, c)
	v0 = sub(a, center)
	for n in range(3, 101):
		theta = 2 * pi / n
		vertices = [a]
		b_found = False
		c_found = False
		for i in range(n):
			vi = rotate(v0, i * theta)
			g = add(center, vi)
			vertices.append(g)
			if norm(sub(g, b)) < 0.0001:
				b_found = True
			elif norm(sub(g, c)) < 0.0001:
				c_found = True
		if b_found and c_found:
			return (n, r)
a = [float(i) for i in input().split()]
b = [float(i) for i in input().split()]
c = [float(i) for i in input().split()]
(n, r) = find_polygon(a, b, c)
print(area(n, r))


import math
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
A = x1 * (y2 - y3) - y1 * (x2 - x3) + x2 * y3 - x3 * y2
B = (x1 ** 2 + y1 ** 2) * (y3 - y2) + (x2 ** 2 + y2 ** 2) * (y1 - y3) + (x3 ** 2 + y3 ** 2) * (y2 - y1)
C = (x1 ** 2 + y1 ** 2) * (x2 - x3) + (x2 ** 2 + y2 ** 2) * (x3 - x1) + (x3 ** 2 + y3 ** 2) * (x1 - x2)
x = -B / (2 * A)
y = -C / (2 * A)
R = math.sqrt((x - x1) ** 2 + (y - y1) ** 2)
V = [(x1 - x, y1 - y), (x2 - x, y2 - y), (x3 - x, y3 - y)]
V = [math.atan2(y, x) / (2 * math.pi) for (x, y) in V]
C = [V[1] - V[0], V[2] - V[1], V[0] - V[2] + 1]
for i in range(1, 101):
	if all([math.isclose(x * i - round(x * i), 0, abs_tol=1e-05) for x in C]):
		print(i * R ** 2 * math.sin(math.pi / i) * math.cos(math.pi / i))
		break


from decimal import Decimal
from math import atan2, pi, sin
EPS = Decimal(1e-05)
pi = Decimal(pi)

class Vector:

	def __init__(self, x=0, y=0):
		self.x = x
		self.y = y

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

	def __xor__(self, v2):
		return Decimal(abs(atan2(self | v2, self & v2)))

	def __and__(self, v2):
		return self.x * v2.x + self.y * v2.y

	def __or__(self, v2):
		return self.x * v2.y - self.y * v2.x
p = [list(map(Decimal, input().split())) for x in range(3)]
(ca, ab, bc) = [Vector(p[i][0] - p[i - 1][0], p[i][1] - p[i - 1][1]) for i in range(3)]
angles = [-ca ^ ab, -ab ^ bc, -bc ^ ca]
R_sq = (ab.x ** Decimal(2) + ab.y ** Decimal(2)) / Decimal(sin(angles[2])) ** Decimal(2) / Decimal(4)
n = Decimal(3)
while n < 101 and any((k for k in (angle * n / pi for angle in angles) if abs(k - int(k + EPS)) >= EPS)):
	n += 1
print(n * R_sq * Decimal(sin(Decimal(2) * pi / n)) / Decimal(2))


import sys
import math

def gcd(a, b):
	if a < b:
		(a, b) = (b, a)
	while b > 1:
		(a, b) = (b, a % b)
	return a

def square(arr):
	a = math.sqrt((arr[2][0] - arr[1][0]) ** 2 + (arr[2][1] - arr[1][1]) ** 2)
	b = math.sqrt((arr[2][0] - arr[0][0]) ** 2 + (arr[2][1] - arr[0][1]) ** 2)
	c = math.sqrt((arr[1][0] - arr[0][0]) ** 2 + (arr[1][1] - arr[0][1]) ** 2)
	p = 0.5 * (a + b + c)
	R = a * b * c / (4 * math.sqrt(p * (p - a) * (p - b) * (p - c)))
	alpha = math.acos(round((2 * R ** 2 - c ** 2) / (2 * R ** 2), 9)) * 180 / math.pi
	beta = math.acos(round((2 * R ** 2 - a ** 2) / (2 * R ** 2), 9)) * 180 / math.pi
	gamma = math.acos(round((2 * R ** 2 - b ** 2) / (2 * R ** 2), 9)) * 180 / math.pi
	delta = gcd(alpha, gcd(beta, gamma))
	n = 360 / delta
	i = 2
	while abs(round(n) - n) > 0.1:
		delta_loop = delta / i
		n = 360 / delta_loop
		i += 1
	n = round(n)
	s = n / 2 * R ** 2 * math.sin(2 * math.pi / n)
	return s

def main():
	arr = []
	for i in range(3):
		l = sys.stdin.readline()
		(x, y) = [float(t) for t in l.split()]
		arr.insert(i - 1, (x, y))
	s = square(arr)
	print('%.6f' % s)
main()


import os
import sys
from io import BytesIO, IOBase
BUFSIZE = 8192

class FastIO(IOBase):
	newlines = 0

	def __init__(self, file):
		self._fd = file.fileno()
		self.buffer = BytesIO()
		self.writable = 'x' in file.mode or 'r' not in file.mode
		self.write = self.buffer.write if self.writable else None

	def read(self):
		while True:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			if not b:
				break
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines = 0
		return self.buffer.read()

	def readline(self):
		while self.newlines == 0:
			b = os.read(self._fd, max(os.fstat(self._fd).st_size, BUFSIZE))
			self.newlines = b.count(b'\n') + (not b)
			ptr = self.buffer.tell()
			(self.buffer.seek(0, 2), self.buffer.write(b), self.buffer.seek(ptr))
		self.newlines -= 1
		return self.buffer.readline()

	def flush(self):
		if self.writable:
			os.write(self._fd, self.buffer.getvalue())
			(self.buffer.truncate(0), self.buffer.seek(0))

class IOWrapper(IOBase):

	def __init__(self, file):
		self.buffer = FastIO(file)
		self.flush = self.buffer.flush
		self.writable = self.buffer.writable
		self.write = lambda s: self.buffer.write(s.encode('ascii'))
		self.read = lambda : self.buffer.read().decode('ascii')
		self.readline = lambda : self.buffer.readline().decode('ascii')
(sys.stdin, sys.stdout) = (IOWrapper(sys.stdin), IOWrapper(sys.stdout))
input = lambda : sys.stdin.readline().rstrip('\r\n')
from math import *
(*p1,) = map(float, input().split())
(*p2,) = map(float, input().split())
(*p3,) = map(float, input().split())

def cmp(p, q, eps=1e-09):
	return abs(p - q) < eps

def is_int_fraction(a, b, eps=1e-07):
	x = a / b
	return cmp(x, round(x), eps)

def mid_line(p, q):
	A = p[0] - q[0]
	B = p[1] - q[1]
	x = (p[0] + q[0]) / 2
	y = (p[1] + q[1]) / 2
	C = A * x + B * y
	return (A, B, C)

def inter(p, q):
	(A1, B1, C1) = p
	(A2, B2, C2) = q
	t = A2 * B1 - A1 * B2
	if cmp(t, 0):
		return (0, 0)
	cy = (A2 * C1 - A1 * C2) / t
	cx = (B2 * C1 - B1 * C2) / -t
	return (cx, cy)
(cx, cy) = inter(mid_line(p1, p2), mid_line(p2, p3))
p1[0] -= cx
p2[0] -= cx
p3[0] -= cx
p1[1] -= cy
p2[1] -= cy
p3[1] -= cy
r2 = p1[0] * p1[0] + p1[1] * p1[1]
cos_a = (p1[0] * p2[0] + p1[1] * p2[1]) / r2
cos_b = (p1[0] * p3[0] + p1[1] * p3[1]) / r2
cos_c = (p2[0] * p3[0] + p2[1] * p3[1]) / r2
cos_a = max(-1, min(1, cos_a))
cos_b = max(-1, min(1, cos_b))
cos_c = max(-1, min(1, cos_c))
a = acos(cos_a)
b = acos(cos_b)
c = acos(cos_c)
m = min(a, b, c)
for i in range(1, 101):
	angle = m / i
	if is_int_fraction(a, angle, 0.0001) and is_int_fraction(b, angle, 0.0001) and is_int_fraction(c, angle, 0.0001) and is_int_fraction(2 * pi, angle, 0.0001):
		n = round(2 * pi / angle)
		print(n * r2 / 2 * sin(2 * pi / n))
		break


from math import *
pi = 3.14159265359

def gcd(x, y):
	if abs(y) < 0.0001:
		return x
	else:
		return gcd(y, fmod(x, y))
(x1, y1) = list(map(float, input().split(' ')))
(x2, y2) = list(map(float, input().split(' ')))
(x3, y3) = list(map(float, input().split(' ')))
a = sqrt((x2 - x3) ** 2 + (y2 - y3) ** 2)
b = sqrt((x3 - x1) ** 2 + (y3 - y1) ** 2)
c = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
s = (a + b + c) / 2
area = sqrt(s * (s - a) * (s - b) * (s - c))
r = a * b * c / (4 * area)
A = acos((b * b + c * c - a * a) / (2 * b * c))
B = acos((a * a + c * c - b * b) / (2 * a * c))
C = acos((b * b + a * a - c * c) / (2 * b * a))
n = pi / gcd(gcd(A, B), C)
area = n * r * r * sin(2 * pi / n) / 2
print(area)


import math

class Point:

	def __init__(self, x, y):
		self.x = x
		self.y = y

def circle(p1, p2, p3):
	x21 = p2.x - p1.x
	x31 = p3.x - p1.x
	y21 = p2.y - p1.y
	y31 = p3.y - p1.y
	M1 = p1.x ** 2 + p1.y ** 2 - p2.x ** 2 - p2.y ** 2
	M2 = p1.x ** 2 + p1.y ** 2 - p3.x ** 2 - p3.y ** 2
	x = (y21 * M2 - y31 * M1) / 2 / (y31 * x21 - y21 * x31)
	y = (x21 * M2 - x31 * M1) / 2 / (x31 * y21 - x21 * y31)
	return (x, y)

def calAngle(center, p1, p2):
	va = Point(p1.x - center.x, p1.y - center.y)
	vb = Point(p2.x - center.x, p2.y - center.y)
	la = (va.x ** 2 + va.y ** 2) ** 0.5
	lb = (vb.x ** 2 + vb.y ** 2) ** 0.5
	cosAngle = round((va.x * vb.x + va.y * vb.y) / (la * lb), 6)
	angle = math.acos(cosAngle) * 180 / math.pi
	return angle

def isMultiple(a, b):
	c = a / b
	return abs(c - round(c)) < 0.001

def solve(p1, p2, p3):
	center = Point(*circle(p1, p2, p3))
	a1 = calAngle(center, p1, p2)
	a2 = calAngle(center, p1, p3)
	a3 = calAngle(center, p2, p3)
	for n in range(3, 101):
		angle = 360 / n
		if all((isMultiple(a, angle) for a in (a1, a2, a3))):
			break
	v1 = Point(center.x - p1.x, center.y - p1.y)
	radius = (v1.x ** 2 + v1.y ** 2) ** 0.5
	area = 0.5 * radius * radius * math.sin(angle * math.pi / 180)
	area *= n
	return area
p1 = Point(*map(float, input().split()))
p2 = Point(*map(float, input().split()))
p3 = Point(*map(float, input().split()))
print(solve(p1, p2, p3))


import math
import collections
import bisect
import heapq
import time
import random
import itertools
import sys
from typing import List
import math

def gcd(a, b):
	if a < b:
		return gcd(b, a)
	if abs(b) < 0.001:
		return a
	else:
		return gcd(b, a - math.floor(a / b) * b)

def dist(a, b):
	return math.sqrt((a[0] - b[0]) ** 2 + (a[1] - b[1]) ** 2)
(ax, ay) = map(float, input().split())
(bx, by) = map(float, input().split())
(cx, cy) = map(float, input().split())
a = dist((ax, ay), (bx, by))
b = dist((bx, by), (cx, cy))
c = dist((ax, ay), (cx, cy))
p = (a + b + c) / 2
area = math.sqrt(p * (p - a) * (p - b) * (p - c))
radius = a * b * c / 4 / area
angleA = math.acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c))
angleB = math.acos((a ** 2 + c ** 2 - b ** 2) / (2 * a * c))
angleC = math.acos((b ** 2 + a ** 2 - c ** 2) / (2 * a * b))
N = int(math.pi / gcd(gcd(angleA, angleB), angleC))
areaNgon = N / 2 * radius ** 2 * math.sin(2 * math.pi / N)
print(areaNgon)


import math
from sys import stdin
from decimal import Decimal

def get_length(p1, p2):
	return Decimal.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)

def get_angle(p1, p2, p3):
	a = (p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2
	b = (p2[0] - p3[0]) ** 2 + (p2[1] - p3[1]) ** 2
	c = (p1[0] - p3[0]) ** 2 + (p1[1] - p3[1]) ** 2
	return math.acos((a + c - b) / (2 * get_length(p1, p2) * get_length(p1, p3)))

def get_radius(p1, p2, p3):
	(a, b, c) = (get_length(p1, p2), get_length(p2, p3), get_length(p1, p3))
	s = (a + b + c) / 2
	area = Decimal.sqrt(s * (s - a) * (s - b) * (s - c))
	return a * b * c / 4 / area

def gcd(x, y):
	while abs(y) > 0.01 and abs(x) > 0.01:
		if x > y:
			x -= Decimal.from_float(math.floor(x / y)) * y
		else:
			y -= Decimal.from_float(math.floor(y / x)) * x
	return x + y

def main():
	(x1, y1) = map(Decimal.from_float, map(float, stdin.readline().strip().split()))
	p1 = (x1, y1)
	(x2, y2) = map(Decimal.from_float, map(float, stdin.readline().strip().split()))
	p2 = (x2, y2)
	(x3, y3) = map(Decimal.from_float, map(float, stdin.readline().strip().split()))
	p3 = (x3, y3)
	A = Decimal.from_float(get_angle(p1, p2, p3))
	B = Decimal.from_float(get_angle(p2, p3, p1))
	C = Decimal.from_float(get_angle(p3, p2, p1))
	radius = get_radius(p1, p2, p3)
	n = Decimal.from_float(round(Decimal.from_float(math.pi) / gcd(gcd(A, B), C)))
	area = n / 2 * radius ** 2 * Decimal.from_float(math.sin(2 * Decimal.from_float(math.pi) / n))
	print(area)
main()


from math import sqrt, fmod, acos, sin, pi

def dist(x1, y1, x2, y2):
	return (x1 - x2) ** 2 + (y1 - y2) ** 2

def angle(a, b, c):
	return acos(0.5 * (b + c - a) / sqrt(b * c))

def fgcd(u, v, eps=pi / 100.0):
	while v > eps:
		(u, v) = (v, fmod(u, v))
	return u

def area(x1, y1, x2, y2, x3, y3):
	a = dist(x1, y1, x2, y2)
	b = dist(x2, y2, x3, y3)
	c = dist(x3, y3, x1, y1)
	u = angle(a, b, c)
	v = angle(b, a, c)
	w = angle(c, a, b)
	t = 2.0 * fgcd(u, fgcd(v, w))
	r = (sqrt(a) / sin(u) + sqrt(b) / sin(v) + sqrt(c) / sin(w)) / 6.0
	return pi * r * r * sin(t) / t

def main():
	(x1, y1) = map(float, input().split())
	(x2, y2) = map(float, input().split())
	(x3, y3) = map(float, input().split())
	print('{:.8f}'.format(area(x1, y1, x2, y2, x3, y3)))
main()


import math
from math import pi
p1 = [float(_) for _ in input().split()]
p2 = [float(_) for _ in input().split()]
p3 = [float(_) for _ in input().split()]

def get_line(p1, p2):
	(x1, y1) = p1
	(x2, y2) = p2
	if x1 * y2 == x2 * y1:
		c = 0
		a = 1
		if y1 != 0:
			b = -x1 / y1
		else:
			b = -x2 / y2
		return (a, b, c)
	else:
		c = 1
		a = (y1 - y2) / (x1 * y2 - x2 * y1)
		b = (x1 - x2) / (x2 * y1 - x1 * y2)
		return (a, b, c)

def get_line2(p, a, b, c):
	return (b, -a, a * p[1] - b * p[0])
(a1, b1, c1) = get_line(p1, p2)
(a2, b2, c2) = get_line(p1, p3)
mid1 = ((p1[0] + p2[0]) / 2, (p1[1] + p2[1]) / 2)
mid2 = ((p1[0] + p3[0]) / 2, (p1[1] + p3[1]) / 2)
(a3, b3, c3) = get_line2(mid1, a1, b1, c1)
(a4, b4, c4) = get_line2(mid2, a2, b2, c2)
xx = (b3 * c4 - c3 * b4) / (a3 * b4 - a4 * b3)
yy = (a3 * c4 - c3 * a4) / (b3 * a4 - a3 * b4)

def get_angle(p1, p2, p3):
	v1 = (p2[0] - p1[0], p2[1] - p1[1])
	v2 = (p3[0] - p1[0], p3[1] - p1[1])
	dot_prod = v1[0] * v2[0] + v1[1] * v2[1]
	l1 = math.sqrt(v1[0] ** 2 + v1[1] ** 2)
	l2 = math.sqrt(v2[0] ** 2 + v2[1] ** 2)
	angle = math.acos(dot_prod / (l1 * l2))
	return (angle, l1, l2)
center = (xx, yy)
(ang1, l11, l12) = get_angle(center, p1, p2)
(ang2, l21, l22) = get_angle(center, p2, p3)
(ang3, l31, l32) = get_angle(center, p1, p3)
n = 1
while True:
	piece = 2 * pi / n
	if abs(round(ang1 / piece) - ang1 / piece) < 0.01 and abs(round(ang2 / piece) - ang2 / piece) < 0.01 and (abs(round(ang3 / piece) - ang3 / piece) < 0.01):
		break
	n += 1
theta = 2 * pi / n
area = n * 1 / 2 * l11 * l11 * math.sin(theta)
print(area)


import math
from fractions import Fraction
line = input()
data = line.split()
(x1, y1) = (float(data[0]), float(data[1]))
line = input()
data = line.split()
(x2, y2) = (float(data[0]), float(data[1]))
line = input()
data = line.split()
(x3, y3) = (float(data[0]), float(data[1]))
dis12 = (x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)
dis23 = (x2 - x3) * (x2 - x3) + (y2 - y3) * (y2 - y3)
dis13 = (x1 - x3) * (x1 - x3) + (y1 - y3) * (y1 - y3)
cos1 = (dis13 + dis12 - dis23) / (2 * math.sqrt(dis12 * dis13))
cos2 = (dis23 + dis12 - dis13) / (2 * math.sqrt(dis23 * dis12))
cos3 = (dis13 + dis23 - dis12) / (2 * math.sqrt(dis13 * dis23))
angle1 = math.acos(cos1) * 2
angle2 = math.acos(cos2) * 2
angle3 = math.acos(cos3) * 2
number1 = Fraction.from_float(angle1 / angle2).limit_denominator(101)
l1 = angle1 / number1.numerator
n1 = 2 * math.pi / l1
n1_int = int(n1 + 0.5)
number2 = Fraction.from_float(angle1 / angle3).limit_denominator(101)
l2 = angle1 / number2.numerator
n2 = 2 * math.pi / l2
n2_int = int(n2 + 0.5)
if abs(n1_int - n1) < abs(n2_int - n2):
	n = n1_int
else:
	n = n2_int
sin1 = math.sqrt(1 - cos1 * cos1)
r = math.sqrt(dis23) / (2 * sin1)
area = 1 / 2 * n * math.sin(2 * math.pi / n) * r * r
print('%.6f' % area)


from math import *

def eucDist(x1, y1, x2, y2):
	d = pow(x1 - x2, 2) + pow(y1 - y2, 2)
	return sqrt(d)

def findAngle(a, b, c):
	return acos((b * b + c * c - a * a) / (2 * b * c))

def fgcd(a, b):
	return a if b < pi / 100 else fgcd(b, fmod(a, b))
u = input
r = range
(X, Y, A, G) = [[0 for i in r(3)] for j in r(4)]
for i in r(3):
	(X[i], Y[i]) = map(float, u().split())
for i in r(3):
	A[i] = eucDist(X[i % 3], Y[i % 3], X[(i + 1) % 3], Y[(i + 1) % 3])
for i in r(3):
	G[i] = findAngle(A[i % 3], A[(i + 1) % 3], A[(i + 2) % 3])
n = pi / fgcd(fgcd(G[0], G[1]), G[2])
R = A[0] / (2 * sin(G[0]))
print(0.5 * R * R * n * sin(2 * pi / n))


import math
[x1, y1] = map(float, input().split())
[x2, y2] = map(float, input().split())
[x3, y3] = map(float, input().split())
ma = (y2 - y1) / (x2 - x1)
mb = (y3 - y2) / (x3 - x2)
cx = (ma * mb * (y1 - y3) + mb * (x1 + x2) - ma * (x2 + x3)) / (2 * (mb - ma))
cy = -(1 / ma) * (cx - (x1 + x2) / 2) + (y1 + y2) / 2
r = math.hypot(cx - x1, cy - y1)
c1 = math.hypot(x1 - x2, y1 - y2) / 2
c2 = math.hypot(x1 - x3, y1 - y3) / 2
c3 = math.hypot(x2 - x3, y2 - y3) / 2
a1 = 2 * math.asin(c1 / r)
a2 = 2 * math.asin(c2 / r)
a3 = 2 * math.asin(c3 / r)
a = 0
for i in range(3, 101):
	d = math.pi * 2 / i
	if round(a1 / d, 3).is_integer() and round(a2 / d, 3).is_integer() and round(a3 / d, 3).is_integer():
		a = d
		break
l = 2 * r * math.sin(a / 2)
s = i * l * l / (4 * math.tan(math.radians(180 / i)))
print(s)


import itertools
import math
EPS = 0.001

def get_vector(first, second):
	return tuple((y - x for (x, y) in zip(first, second)))

def get_mid_perpendicular(first, second):
	vector = get_vector(first, second)
	mid = tuple(((x + y) / 2 for (x, y) in zip(first, second)))
	return (vector[0], vector[1], vector[0] * mid[0] + vector[1] * mid[1])

def find_intersection(first, second):
	det = first[0] * second[1] - first[1] * second[0]
	inv = ((second[1] / det, -first[1] / det), (-second[0] / det, first[0] / det))
	return (inv[0][0] * first[2] + inv[0][1] * second[2], inv[1][0] * first[2] + inv[1][1] * second[2])

def get_angle(first, second):
	return abs(math.atan2(first[1], first[0]) - math.atan2(second[1], second[0]))

def compute_min_area(points):
	mid_perpendicular1 = get_mid_perpendicular(points[0], points[1])
	mid_perpendicular2 = get_mid_perpendicular(points[1], points[2])
	intersection = find_intersection(mid_perpendicular1, mid_perpendicular2)
	vectors = [get_vector(intersection, p) for p in points]
	angles = [get_angle(vectors[i], vectors[j]) for i in range(3) for j in range(3) if i < j]
	for n in itertools.count(3):
		if all((abs(math.sin(a * n / 2)) < EPS for a in angles)):
			v = vectors[0]
			return n * (v[0] ** 2 + v[1] ** 2) * math.sin(2 * math.pi / n) / 2
points = []
for _ in range(3):
	(x, y) = map(float, input().split())
	points.append((x, y))
result = compute_min_area(points)
print(f'{result:.8f}')


import math
grad = [360 / k for k in range(3, 101)]

def opr_seredini(fir, sec):
	return [(fir[0] + sec[0]) / 2, (fir[1] + sec[1]) / 2]

def k_perpend(fir, sec):
	if fir[0] == sec[0]:
		return 0
	elif fir[1] == sec[1]:
		return 'Вертикаль'
	else:
		return -1 / ((fir[1] - sec[1]) / (fir[0] - sec[0]))

def opr_c(k, tch):
	if k == 'Вертикаль':
		return tch[0]
	else:
		return tch[1] - k * tch[0]

def center(pryamaya_1, pryamaya_2):
	if pryamaya_1[0] == 'Вертикаль':
		return [pryamaya_1[1], pryamaya_2[0] * pryamaya_1[1] + pryamaya_2[1]]
	elif pryamaya_2[0] == 'Вертикаль':
		return [pryamaya_2[1], pryamaya_1[0] * pryamaya_2[1] + pryamaya_1[1]]
	else:
		x = (pryamaya_2[1] - pryamaya_1[1]) / (pryamaya_1[0] - pryamaya_2[0])
		y = pryamaya_1[0] * x + pryamaya_1[1]
		return [x, y]

def ugol(cen, u1, u2):
	a = 0
	v1 = [u1[0] - cen[0], u1[1] - cen[1]]
	v2 = [u2[0] - cen[0], u2[1] - cen[1]]
	dl1 = math.sqrt(v1[0] ** 2 + v1[1] ** 2)
	dl2 = math.sqrt(v2[0] ** 2 + v2[1] ** 2)
	try:
		ug = math.degrees(math.acos((v1[0] * v2[0] + v1[1] * v2[1]) / (dl1 * dl2)))
		return [ug, dl1]
	except:
		return [180.0, dl1]

def plosh(ug, dlin, kolvo_ug):
	return round(0.5 * dlin * dlin * math.sin(math.radians(ug)) * kolvo_ug, 6)
first = input().split()
first = list(map(float, first))
second = input().split()
second = list(map(float, second))
third = input().split()
third = list(map(float, third))
ser1 = opr_seredini(first, second)
ser2 = opr_seredini(second, third)
k1 = k_perpend(first, second)
k2 = k_perpend(second, third)
c1 = opr_c(k1, ser1)
c2 = opr_c(k2, ser2)
cent = center([k1, c1], [k2, c2])
ug = ugol(cent, first, second)
dl = ug[1]
ugo1 = ug[0]
ugo2 = ugol(cent, second, third)[0]
ugo3 = ugol(cent, first, third)[0]
for k in range(98):
	if round(ugo1 / grad[k], 5).is_integer() and round(ugo2 / grad[k], 5).is_integer() and round(ugo3 / grad[k], 5).is_integer():
		print('%.6f' % plosh(grad[k], dl, k + 3))
		break


from math import sqrt, sin, acos, pi
dist_sq = lambda A, B: (A[0] - B[0]) ** 2 + (A[1] - B[1]) ** 2

def angle(R, A, B):
	c = dist_sq(A, B)
	a = dist_sq(R, B)
	b = dist_sq(R, A)
	cosine = round((a + b - c) / sqrt(4 * a * b), 8)
	return acos(cosine)

def circumcentre(A, B, C):
	a = dist_sq(B, C)
	b = dist_sq(A, C)
	c = dist_sq(A, B)
	bary = (a * (b + c - a), b * (c + a - b), c * (a + b - c))
	x = (bary[0] * A[0] + bary[1] * B[0] + bary[2] * C[0]) / sum(bary)
	y = (bary[0] * A[1] + bary[1] * B[1] + bary[2] * C[1]) / sum(bary)
	return (x, y)

def div(m, n):
	(m, n) = (max(m, n), min(m, n))
	return abs(round(m / n) - m / n) < 10 ** (-4)

def gcd(a, b):
	(a, b) = (max(a, b), min(a, b))
	if div(a, b):
		return b
	else:
		return gcd(b, a - b)
A = tuple(map(float, input().split()))
B = tuple(map(float, input().split()))
C = tuple(map(float, input().split()))
cir = circumcentre(A, B, C)
R = dist_sq(cir, A)
angles = sorted([angle(cir, A, B), angle(cir, B, C), angle(cir, C, A)])
gamma = gcd(angles[0], angles[1])
for i in range(1, 51):
	if div(2 * pi * i, gamma):
		gamma /= i
		break
print(pi * R * sin(gamma) / gamma)


from math import *

def gd(x, y):
	if x < 0.001:
		return y
	return gd(fmod(y, x), x)
(x1, y1) = [float(x) for x in input().split()]
(x2, y2) = [float(x) for x in input().split()]
(x3, y3) = [float(x) for x in input().split()]
a = sqrt((x2 - x3) ** 2 + (y2 - y3) ** 2)
b = sqrt((x1 - x3) ** 2 + (y1 - y3) ** 2)
c = sqrt((x1 - x2) ** 2 + (y1 - y2) ** 2)
A = acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c))
B = acos((a ** 2 + c ** 2 - b ** 2) / (2 * a * c))
C = acos((a ** 2 + b ** 2 - c ** 2) / (2 * a * b))
r = 0.5 * a / sin(A)
n = int(pi / gd(gd(A, B), C))
print(round(0.5 * n * r * r * sin(2 * pi / n), 6))


import math

def distance(p1, p2):
	return math.sqrt((p1[0] - p2[0]) ** 2 + (p1[1] - p2[1]) ** 2)

def gcd(a, b):
	if a < b:
		return gcd(b, a)
	if abs(b) < 0.001:
		return a
	else:
		return gcd(b, a - math.floor(a / b) * b)
points = []
for i in range(3):
	(x, y) = [float(x) for x in input().split()]
	point = (x, y)
	points.append(point)
a = distance(points[0], points[1])
b = distance(points[1], points[2])
c = distance(points[2], points[0])
s = (a + b + c) / 2
R = a * b * c / (4 * math.sqrt(s * (a + b - s) * (a + c - s) * (b + c - s)))
A = math.acos((b * b + c * c - a * a) / (2 * b * c))
B = math.acos((a * a + c * c - b * b) / (2 * a * c))
C = math.acos((b * b + a * a - c * c) / (2 * b * a))
n = math.pi / gcd(A, gcd(B, C))
area = n * R * R * math.sin(2 * math.pi / n) / 2
print(area)


import math

def mod(v):
	return math.sqrt(v[0] ** 2 + v[1] ** 2)

def cal_angle(ax1, ay1, bx1, by1, cx1, cy1):
	vab = [bx1 - ax1, by1 - ay1]
	vac = [cx1 - ax1, cy1 - ay1]
	vbc = [cx1 - bx1, cy1 - by1]
	x = round((mod(vab) ** 2 + mod(vac) ** 2 - mod(vbc) ** 2) / (2 * mod(vab) * mod(vac)), 9)
	return math.acos(x)

def gcd_float(a, b):
	if abs(b) < 0.0001:
		return a
	if abs(a) < 0.0001:
		return b
	return gcd_float(b, a % b)
(x1, y1) = map(float, input().split())
(x2, y2) = map(float, input().split())
(x3, y3) = map(float, input().split())
a = ((y2 - y1) * (y3 * y3 - y1 * y1 + x3 * x3 - x1 * x1) - (y3 - y1) * (y2 * y2 - y1 * y1 + x2 * x2 - x1 * x1)) / (2.0 * ((x3 - x1) * (y2 - y1) - (x2 - x1) * (y3 - y1)))
b = ((x2 - x1) * (x3 * x3 - x1 * x1 + y3 * y3 - y1 * y1) - (x3 - x1) * (x2 * x2 - x1 * x1 + y2 * y2 - y1 * y1)) / (2.0 * ((y3 - y1) * (x2 - x1) - (y2 - y1) * (x3 - x1)))
r = mod([a - x1, b - y1]) ** 2
(angle1, angle2) = (cal_angle(a, b, x1, y1, x2, y2), cal_angle(a, b, x2, y2, x3, y3))
angle3 = 2 * math.pi - angle1 - angle2
angle = gcd_float(gcd_float(angle1, angle2), angle3)
cnt = 2 * math.pi / angle
s = math.sin(angle) * r / 2
print('%.8f' % (s * cnt))


from math import sqrt, acos, pi, floor, fabs, sin

def gcd(x, y, eps):
	while fabs(x) > eps and fabs(y) > eps:
		if x > y:
			x -= floor(x / y) * y
		else:
			y -= floor(y / x) * x
	return x + y
abc = []
for _ in range(3):
	(x, y) = map(float, input().split())
	abc.append((x, y))
a = sqrt((abc[1][0] - abc[2][0]) ** 2 + (abc[1][1] - abc[2][1]) ** 2)
b = sqrt((abc[0][0] - abc[2][0]) ** 2 + (abc[0][1] - abc[2][1]) ** 2)
c = sqrt((abc[1][0] - abc[0][0]) ** 2 + (abc[1][1] - abc[0][1]) ** 2)
s = (a + b + c) / 2
area = sqrt(s * (s - a) * (s - b) * (s - c))
rad = a * b * c / (4 * area)
angle_a = acos((b ** 2 + c ** 2 - a ** 2) / (2 * b * c))
angle_b = acos((a ** 2 + c ** 2 - b ** 2) / (2 * a * c))
angle_c = acos((a ** 2 + b ** 2 - c ** 2) / (2 * a * b))
n = pi / gcd(angle_a, gcd(angle_b, angle_c, 0.0001), 0.0001)
res = n * rad ** 2 * sin(2 * pi / n) / 2
print('{0:.6f}'.format(res))


from math import *

def rt(x, y):
	return sum(((i - j) ** 2 for (i, j) in zip(x, y)))

def tr(a, b, c):
	return acos((b + c - a) / (2 * (b * c) ** 0.5)) / pi

def trt(x, n):
	return 0.01 < x * n % 1 < 0.99
(x, y, z) = (tuple(map(float, input().split())) for i in range(3))
(a, b, c) = (rt(x, y), rt(x, z), rt(y, z))
(t, s) = (tr(a, b, c), tr(b, a, c))
(r, n) = (a / (8 * sin(t * pi) ** 2), 3)
while trt(t, n) or trt(s, n):
	n += 1
print(n * r * sin(2 * pi / n))


import math
import sys
eps = 0.0001

def getABC(x1, y1, x2, y2):
	A = x2 - x1
	B = y2 - y1
	C = (x1 * x1 - x2 * x2 + y1 * y1 - y2 * y2) / 2
	return (A, B, C)

def getIntersection(a1, b1, c1, a2, b2, c2):
	x = (c2 * b1 - c1 * b2) / (a1 * b2 - a2 * b1)
	y = (a1 * c2 - a2 * c1) / (a2 * b1 - a1 * b2)
	return (x, y)

def getAngel(x1, y1, x2, y2):
	return math.acos((x1 * x2 + y1 * y2) / (math.sqrt(x1 * x1 + y1 * y1) * math.sqrt(x2 * x2 + y2 * y2)))

def check(num):
	return abs(num - int(num + eps)) < eps
x = []
y = []
for line in sys.stdin.readlines():
	t = line.strip().split()
	x.append(float(t[0]))
	y.append(float(t[1]))
(A1, B1, C1) = getABC(x[0], y[0], x[1], y[1])
(A2, B2, C2) = getABC(x[2], y[2], x[1], y[1])
(x0, y0) = getIntersection(A1, B1, C1, A2, B2, C2)
an = []
an.append(getAngel(x[0] - x0, y[0] - y0, x[1] - x0, y[1] - y0))
an.append(getAngel(x[0] - x0, y[0] - y0, x[2] - x0, y[2] - y0))
an.append(getAngel(x[2] - x0, y[2] - y0, x[1] - x0, y[1] - y0))
total = 2 * math.pi
for i in range(3, 101):
	flag = True
	angel = total / i
	for j in range(0, 3):
		if not check(an[j] / angel):
			flag = False
			break
	if flag:
		break
n = i
m = total / n
ans = ((x[0] - x0) * (x[0] - x0) + (y[0] - y0) * (y[0] - y0)) * math.sin(m) * n / 2
print('%.6f' % ans)


import math
(a1, b1) = input().split()
(a2, b2) = input().split()
(a3, b3) = input().split()
a1 = float(a1)
a2 = float(a2)
a3 = float(a3)
b1 = float(b1)
b2 = float(b2)
b3 = float(b3)
x = ((b2 - b1) * (a3 * a3 - a1 * a1 + b3 * b3 - b1 * b1) - (b3 - b1) * (a2 * a2 - a1 * a1 + b2 * b2 - b1 * b1)) / (2 * ((a3 - a1) * (b2 - b1) - (a2 - a1) * (b3 - b1)))
y = -(a3 - a1) * x / (b3 - b1) + (a3 * a3 - a1 * a1 + b3 * b3 - b1 * b1) / 2 / (b3 - b1)
r2 = (a1 - x) ** 2 + (b1 - y) ** 2
r = r2 ** 0.5
d212 = (a1 - a2) ** 2 + (b1 - b2) ** 2
d213 = (a1 - a3) ** 2 + (b1 - b3) ** 2
al1 = math.acos((2 * r2 - d212) / (2 * r2)) / math.pi * 180
al2 = math.acos((2 * r2 - d213) / (2 * r2)) / math.pi * 180
i = 3
z = 0
while z == 0 and i <= 100:
	if round(al1 * i) % 360 == 0 and round(al2 * i) % 360 == 0:
		z = i
	else:
		i += 1
be = 180 / z
s = z * r2 * math.sin(be / 180 * math.pi) * math.cos(be / 180 * math.pi)
print(s)


import sys, math

def sidelengths(points):
	sides = []
	for i in range(0, len(points)):
		pt0 = points[i]
		pt1 = points[(i + 1) % len(points)]
		x = pt0[0] - pt1[0]
		y = pt0[1] - pt1[1]
		sides.append(math.sqrt(math.pow(x, 2) + math.pow(y, 2)))
	return sides

def area(triangle):
	a = triangle[0]
	b = triangle[1]
	c = triangle[2]
	s = (a + b + c) / 2
	return math.sqrt(s * (s - a) * (s - b) * (s - c))

def circumradius(triangle):
	a = triangle[0]
	b = triangle[1]
	c = triangle[2]
	A = area(triangle)
	return a * b * c / (4 * A)

def angle(s, s1, s2):
	return math.acos((math.pow(s1, 2) + math.pow(s2, 2) - math.pow(s, 2)) / (2 * s1 * s2))

def angle_denom(angle, max_n=100, tolerance=1e-05):
	r = angle / math.pi
	for n in range(1, max_n + 1):
		if abs(r * n - round(r * n)) < tolerance:
			return n
	return max_n

def lcm(a, b):
	return a * b // math.gcd(a, b)
points = []
for i in range(0, 3):
	points.append(list(map(float, sys.stdin.readline().split())))
sides = sidelengths(points)
c = circumradius(sides)
angle1 = angle(sides[0], sides[1], sides[2])
angle2 = angle(sides[1], sides[2], sides[0])
angle3 = angle(sides[2], sides[0], sides[1])
n1 = angle_denom(angle1)
n2 = angle_denom(angle2)
n3 = angle_denom(angle3)
n = lcm(n1, lcm(n2, n3))
a = 0.5 * n * math.pow(c, 2) * math.sin(2 * math.pi / n)
print(str(a))


import math
length = [0] * 3

def getXY(a1, a2, b1, b2, c1, c2):
	return ((c1 * b2 - c2 * b1) / (a1 * b2 - a2 * b1), (c1 * a2 - c2 * a1) / (b1 * a2 - b2 * a1))

def getAB(x1, x2, x3, y1, y2, y3):
	return getXY(2 * (x2 - x1), 2 * (x3 - x2), 2 * (y2 - y1), 2 * (y3 - y2), x2 * x2 - x1 * x1 + y2 * y2 - y1 * y1, x3 * x3 - x2 * x2 + y3 * y3 - y2 * y2)
(X, Y) = ([0] * 3, [0] * 3)
for i in range(3):
	(X[i], Y[i]) = map(float, input().split())
Vis = [0] * 3
length[0] = (X[0] - X[1]) * (X[0] - X[1]) + (Y[0] - Y[1]) * (Y[0] - Y[1])
length[1] = (X[1] - X[2]) * (X[1] - X[2]) + (Y[1] - Y[2]) * (Y[1] - Y[2])
length[2] = (X[2] - X[0]) * (X[2] - X[0]) + (Y[2] - Y[0]) * (Y[2] - Y[0])
O = getAB(X[0], X[1], X[2], Y[0], Y[1], Y[2])
LEN = (X[0] - O[0]) * (X[0] - O[0]) + (Y[0] - O[1]) * (Y[0] - O[1])
N = 0
for i in range(3, 101):
	theta = math.pi / i
	for j in range(1, i // 2 + 1):
		leng = 4 * LEN * math.sin(theta * j) * math.sin(theta * j)
		for k in range(3):
			if abs(leng - length[k]) < 0.01:
				Vis[k] = j
	flag = True
	for k in Vis:
		if k == 0:
			flag = False
	if flag:
		flag = False
		if Vis[0] + Vis[1] + Vis[2] == i or Vis[0] + Vis[1] == Vis[2] or Vis[1] + Vis[2] == Vis[0] or (Vis[0] + Vis[2] == Vis[1]):
			flag = True
	if flag:
		N = i
		break
area = N * 0.5 * LEN * math.sin(math.pi * 2 / N)
print('%.8f' % area)