#include <bits/stdc++.h>
using namespace std;
const int INF = 1000 * 1000 * 1000 + 7;
const double EPS = 3e-5;
int bit_count(int first) {
  return first == 0 ? 0 : 1 + bit_count(first & (first - 1));
}
inline int last_bit(int first) { return first & -first; }
inline int sign(double first) {
  return first < -EPS ? -1 : first > EPS ? 1 : 0;
}
inline int sign(int first) { return (first > 0) - (first < 0); }
int nextComb(int first) {
  int smallest = first & -first;
  int ripple = first + smallest;
  int ones = first ^ ripple;
  ones = (ones >> 2) / smallest;
  return ripple | ones;
}
int gcd(int a, int b) {
  while (b) {
    int r = a % b;
    a = b;
    b = r;
  }
  return a;
}
int lcm(int a, int b) { return a / gcd(a, b) * b; }
struct UnionFind {
  vector<int> P, S, R;
  UnionFind(int n)
      : P(vector<int>(n)), S(vector<int>(n, 1)), R(vector<int>(n, 1)) {
    for (int i = (int)0; i < (int)n; ++i) P[i] = i;
  }
  int findP(int first) {
    if (P[first] != first) P[first] = findP(P[first]);
    return P[first];
  }
  inline int operator[](const int first) { return findP(first); }
  int merge(int a, int b) {
    int pa = findP(a), push_back = findP(b);
    if (pa == push_back) return 0;
    if (R[pa] < R[push_back]) {
      P[pa] = push_back;
      S[push_back] += S[pa];
    } else {
      P[push_back] = pa;
      S[pa] += S[push_back];
    }
    if (R[pa] == R[push_back]) ++R[pa];
    return 1;
  }
};
const int BUF_SIZE = 201;
char buf[BUF_SIZE];
inline string getToken() {
  scanf("%s", buf);
  return buf;
}
inline string getLine() {
  fgets(buf, BUF_SIZE, stdin);
  return buf;
}
inline int getInt() {
  int a;
  scanf("%d", &a);
  return a;
}
inline double getDouble() {
  double a;
  scanf("%lf", &a);
  return a;
}
inline int stoi(string first) {
  stringstream ss;
  int ret;
  ss << first;
  ss >> ret;
  return ret;
}
inline vector<string> split(string &s) {
  stringstream ss;
  ss << s;
  string t;
  vector<string> ret;
  while (ss >> t) ret.push_back(t);
  return ret;
}
template <class K, class V>
vector<K> getKeys(map<K, V> m) {
  vector<K> keys;
  for (typeof((m).begin()) it = (m).begin(); it != (m).end(); ++it)
    keys.push_back(it->first);
  return keys;
}
inline double myRand() {
  return ((double)rand() / RAND_MAX) + ((double)rand() / RAND_MAX / RAND_MAX);
}
const double PI = 2.0 * acos(0.0);
struct Seg;
inline pair<double, double> operator|(pair<double, double> a, Seg s);
inline pair<double, double> operator||(pair<double, double> a, Seg s);
inline pair<double, double> operator-(pair<double, double> a,
                                      pair<double, double> b) {
  return pair<double, double>(a.first - b.first, a.second - b.second);
}
inline pair<double, double> operator+(pair<double, double> a,
                                      pair<double, double> b) {
  return pair<double, double>(a.first + b.first, a.second + b.second);
}
inline double operator*(pair<double, double> a, pair<double, double> b) {
  return a.first * b.first + a.second * b.second;
}
inline double operator^(pair<double, double> a, pair<double, double> b) {
  return a.first * b.second - a.second * b.first;
}
inline double operator!(pair<double, double> a) {
  return sqrt((double)(((a.first) * (a.first)) + ((a.second) * (a.second))));
}
inline pair<double, double> operator*(double first, pair<double, double> a) {
  return pair<double, double>(a.first * first, a.second * first);
}
inline pair<double, double> operator/(pair<double, double> a, double first) {
  return pair<double, double>(a.first / first, a.second / first);
}
inline pair<double, double> operator|(pair<double, double> a,
                                      pair<double, double> b) {
  return ((a * b) / (b * b)) * b;
}
inline pair<double, double> operator~(pair<double, double> a) { return a / !a; }
inline pair<double, double> operator&(pair<double, double> a) {
  return pair<double, double>(a.second, -a.first);
}
inline bool operator==(pair<double, double> a, pair<double, double> b) {
  return !(a - b) < EPS;
}
inline int ccw(pair<double, double> a, pair<double, double> b,
               pair<double, double> c) {
  return sign((b - a) ^ (c - a));
}
struct Seg {
  pair<double, double> a, b;
  Seg(pair<double, double> aa, pair<double, double> bb) : a(aa), b(bb) {}
  inline double operator!() { return !(a - b); }
  inline int onSeg(pair<double, double> p) {
    return !(a - b) + EPS > !(p - a) + !(p - b) && !(p - (p | (*this))) < EPS;
  }
  inline int onLine(pair<double, double> p) { return ccw(p, a, b) == 0; }
  inline double PLDist(pair<double, double> p) {
    return ((b - a) ^ (p - a)) / !(*this);
  }
  inline double PSDist(pair<double, double> p) {
    return onSeg(p | (*this)) ? PLDist(p) : min(!(p - a), !(p - b));
  }
  inline pair<double, double> *LLIntersect(Seg s) {
    pair<double, double> c = s.a, d = s.b;
    if (sign((b - a) ^ (d - c)) == 0) {
      return NULL;
    }
    double t = ((c - a) ^ (d - c)) / ((b - a) ^ (d - c));
    return new pair<double, double>(a + (t * (b - a)));
  }
  inline pair<double, double> *LSIntersect(Seg s) {
    return (ccw(s.a, a, b) * ccw(s.b, b, a) == 1) ? NULL : LLIntersect(s);
  }
  inline pair<double, double> *SSIntersect(Seg s) {
    pair<double, double> c = s.a, d = s.b;
    if (ccw(s.a, a, b) * ccw(s.b, b, a) == 1) return NULL;
    if (a == b) return s.onSeg(a) ? new pair<double, double>(a) : NULL;
    if (s.a == s.b) return onSeg(s.a) ? new pair<double, double>(s.a) : NULL;
    if (max(a.first, b.first) < min(c.first, d.first) - EPS) return NULL;
    if (min(a.first, b.first) > max(c.first, d.first) + EPS) return NULL;
    if (max(a.second, b.second) < min(c.second, d.second) - EPS) return NULL;
    if (min(a.second, b.second) > max(c.second, d.second) + EPS) return NULL;
    return LLIntersect(s);
  }
};
inline pair<double, double> operator|(pair<double, double> a, Seg s) {
  return a | (s.b - s.a);
}
inline pair<double, double> operator||(pair<double, double> a, Seg s) {
  pair<double, double> onLine = a | s;
  return onLine + (onLine - a);
}
struct Circle {
  pair<double, double> c;
  double r;
  Circle(pair<double, double> cc, double rr) : c(cc), r(rr) {}
  Circle(pair<double, double> a, pair<double, double> b,
         pair<double, double> c) {
    Seg bisAB((a + b) / 2, (a + b) / 2 + &(b - a));
    Seg bisBC((b + c) / 2, (b + c) / 2 + &(c - b));
    this->c = *(bisAB.LLIntersect(bisBC));
    r = !(a - this->c);
  }
  pair<pair<double, double>, pair<double, double> > *CCIntersect(Circle o) {
    double R = !(c - o.c);
    if (r + o.r < R - EPS || r + R < o.r - EPS || o.r + R < r - EPS)
      return NULL;
    double dsq = (c - o.c) * (c - o.c);
    pair<double, double> m =
        c + ((((r) * (r)) + dsq - ((o.r) * (o.r))) / (2 * dsq)) * (o.c - c);
    double h = sqrt(r * r - (m - c) * (m - c));
    pair<double, double> perp = &(~(o.c - c));
    return new pair<pair<double, double>, pair<double, double> >(
        make_pair(m + h * perp, m - h * perp));
  }
};
void myCode() {
  vector<pair<double, double> > pts;
  for (int i = (int)0; i < (int)3; ++i) {
    double first = getDouble(), second = getDouble();
    pts.push_back(pair<double, double>(first, second));
  }
  Circle circle(pts[0], pts[1], pts[2]);
  pair<double, double> t3 = circle.c;
  double r = circle.r;
  vector<double> thetas;
  for (int i = (int)0; i < (int)3; ++i)
    thetas.push_back(atan2(pts[i].second - t3.second, pts[i].first - t3.first));
  double a1 = thetas[0] - thetas[1] - 2 * PI;
  while (a1 < 0) a1 += 2 * PI;
  double a2 = thetas[1] - thetas[2] - 2 * PI;
  while (a2 < 0) a2 += 2 * PI;
  for (int i = 3; i <= 100; ++i) {
    double angle = 2 * PI / i;
    double t1 = a1;
    while (t1 + EPS > angle) t1 -= angle;
    double t2 = a2;
    while (t2 + EPS > angle) t2 -= angle;
    if (fabs(t1) < 2 * EPS && fabs(t2) < 2 * EPS) {
      pair<double, double> n1(r, 0);
      pair<double, double> n2(r * cos(angle), r * sin(angle));
      printf("%.8lf\n", (n1 ^ n2) / 2 * i);
      break;
    }
  }
}
int main() {
  srand(0);
  myCode();
  return 0;
}
