Problem: 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

Solution (in PYTHON3):

Solution:
# Python3 program to find minimum area of  
# polygon of number of sides more than three 
# with given three points.  
  
# from math lib import every function 
from math import *
  
# assigning pi value to variable  
pi = 3.14159265359
  
# calculating gcd value of two double values .  
def gcd(x, y) : 
  
    if abs(y) < 1e-4 : 
        return x 
    else : 
        return gcd(y, fmod(x, y)) 
  
  
# Calculating minimum area of polygon  
# through this function .  
def min_area_of_polygon(Ax, Ay, Bx,  
                        By, Cx, Cy) : 
  
    # calculating the length of the sides of  
    # the triangle formed from given points  
    # a, b, c represents the length of different 
    # sides of triangle 
    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))  
  
    # here we have calculated the semiperimeter  
    # of a triangle .  
    semiperimeter = (a + b + c) / 2
  
    # Now from the semiperimeter area of triangle  
    # is derived through the heron's formula  
    area_triangle = sqrt(semiperimeter * 
                        (semiperimeter - a) * 
                        (semiperimeter - b) * 
                        (semiperimeter - c)) 
  
    # thus circumradius of the triangle is derived  
    # from the sides and area of the triangle calculated 
    Radius = (a * b * c) / (4 * area_triangle) 
  
    # Now each angle of the triangle is derived  
    # from the sides of the 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)) 
  
    # Now n is calculated such that area is  
    # minimum for the regular n-gon  
    n = pi / gcd(gcd(Angle_A, Angle_B), Angle_C) 
  
    # calculating area of regular n-gon through  
    # the circumradius of the triangle 
    area = (n * Radius * Radius * 
            sin((2 * pi) / n)) / 2
  
    return area 
  
# Driver Code 
if __name__ == "__main__" : 
  
    # three points are given as input .  
    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))) )