#include <bits/stdc++.h>
using namespace std;
inline int cmp(long double x, long double y = 0, long double tol = 1e-5) {
  return (x <= y + tol) ? (x + tol < y) ? -1 : 0 : 1;
}
struct ponto {
  double x, y;
  ponto() : x(0), y(0) {}
  ponto(double x, double y) : x(x), y(y) {}
  bool operator<(const ponto outro) const {
    if (fabs(x - outro.x) > 1e-5) return x < outro.x;
    return y < outro.y;
  }
  bool operator==(const ponto outro) const {
    return (fabs(x - outro.x) < 1e-5 && (fabs(y - outro.y)) < 1e-5);
  }
};
ponto rotate(ponto p, double theta) {
  double rad = (2 * acos(0) * theta / 180.0);
  return ponto(p.x * cos(rad) - p.y * sin(rad),
               p.x * sin(rad) + p.y * cos(rad));
}
double dist(ponto p1, ponto p2) { return hypot(p1.x - p2.x, p1.y - p2.y); }
struct linha {
  double a, b, c;
};
void FazLinha(ponto p1, ponto p2, linha &l) {
  if (fabs(p1.x - p2.x) < 1e-5) {
    l.a = 1.0;
    l.b = 0.0;
    l.c = -p1.x;
  } else {
    l.a = -(double)(p1.y - p2.y) / (p1.x - p2.x);
    l.b = 1.0;
    l.c = -(double)(l.a * p1.x) - p1.y;
  }
}
bool Paralelas(linha l1, linha l2) {
  return (fabs(l1.a - l2.a) < 1e-5) && fabs(l1.b - l2.b) < 1e-5;
}
bool Iguais(linha l1, linha l2) {
  return Paralelas(l1, l2) && (fabs(l1.c - l2.c) < 1e-5);
}
bool Intersecao(linha l1, linha l2, ponto &p) {
  if (Paralelas(l1, l2)) return false;
  p.x = (l2.b * l1.c - l1.b * l2.c) / (l2.a * l1.b - l1.a * l2.b);
  if (fabs(l1.b) > 1e-5)
    p.y = -(l1.a * p.x + l1.c);
  else
    p.y = -(l2.a * p.x + l2.c);
  return true;
}
struct vetor {
  double x, y;
  vetor(double x, double y) : x(x), y(y) {}
};
vetor FazVetor(ponto a, ponto b) { return vetor(b.x - a.x, b.y - a.y); }
vetor scale(vetor v, double s) { return vetor(v.x * s, v.y * s); }
ponto translate(ponto p, vetor v) { return ponto(p.x + v.x, p.y + v.y); }
double dot(vetor a, vetor b) { return (a.x * b.x + a.y * b.y); }
double ModuloVetor_semRaiz(vetor v) { return v.x * v.x + v.y * v.y; }
double distToline(ponto p, ponto a, ponto b, ponto &c) {
  vetor ap = FazVetor(a, p);
  vetor ab = FazVetor(a, b);
  double u = dot(ap, ab) / ModuloVetor_semRaiz(ab);
  c = translate(a, scale(ab, u));
  return dist(p, c);
}
double distTolineSegment(ponto p, ponto a, ponto b, ponto &c) {
  vetor ap = FazVetor(a, p);
  vetor ab = FazVetor(a, b);
  double u = dot(ap, ab) / ModuloVetor_semRaiz(ab);
  if (u < 0.0) {
    c = ponto(a.x, a.y);
    return dist(p, a);
  }
  if (u > 1.0) {
    c = ponto(b.x, b.y);
    return dist(p, b);
  }
  return distToline(p, a, b, c);
}
double angle(ponto a, ponto o, ponto b) {
  vetor oa = FazVetor(o, a);
  vetor ob = FazVetor(o, b);
  return acos(dot(oa, ob) /
              sqrt(ModuloVetor_semRaiz(oa) * ModuloVetor_semRaiz(ob)));
}
double cross(vetor a, vetor b) { return a.x * b.y - a.y * b.x; }
bool ccw(ponto p, ponto q, ponto r) {
  return cross(FazVetor(p, q), FazVetor(p, r)) > 0;
}
bool collinear(ponto p, ponto q, ponto r) {
  return fabs(cross(FazVetor(p, q), FazVetor(p, r))) < 1e-5;
}
int det3pontos_ori(ponto p, ponto a, ponto b) {
  double det = ((-(p.x * b.y) - (b.x * a.y) - (a.x * p.y)) + (p.y * b.x) +
                (a.y * p.x) + (b.y * a.x));
  return fabs(det) < 1e-5 ? 0 : det > 0 ? 1 : -1;
}
bool collinear_det(ponto a, ponto b, ponto c) {
  return ((b.y - a.y) * (c.x - b.x) == (b.x - a.x) * (c.y - b.y));
}
inline bool le(ponto &p) {
  if (cin >> p.x >> p.y) return true;
  return false;
}
inline void imprime(ponto p) { cout << p.x << " " << p.y; }
double cross(ponto origem, ponto a, ponto b) {
  return (a.x - origem.x) * (b.y - origem.y) -
         (a.y - origem.y) * (b.x - origem.x);
}
double Area(double mediana1, double mediana2, double mediana3) {
  double sm = (mediana1 + mediana2 + mediana3) / 2.0;
  double temp = sm * (sm - mediana1) * (sm - mediana2) * (sm - mediana3);
  if (0 >= temp)
    return -1;
  else
    return 4.0 * sqrt(temp) / 3.0;
}
bool ValidaTriangulo(double l1, double l2, double l3) {
  return cmp(l1, abs(l3 - l2) > 0 && cmp((l3 + l2), l1) > 0 &&
                     cmp(l2, abs(l1 - l3)) > 0 && cmp((l1 + l3), l2) > 0 &&
                     cmp(l3, abs(l2 - l1)) > 0 && cmp((l2 + l1), l3)) > 0;
}
void linhaperpendicular(linha l, ponto p, linha &l1) {
  if (fabs(l.a) < 1e-5) {
    l1.a = 1.0;
    l1.b = 0.0;
    l1.c = -p.x;
    return;
  }
  l1.a = -l.b / l.a;
  l1.b = 1.0;
  l1.c = (double)-p.y + (l.b * p.x) / l.a;
}
ponto pontomedio(ponto a, ponto b) {
  return ponto((a.x + b.x) / 2.0, (a.y + b.y) / 2.0);
}
double det2pontos(vetor a, vetor b) { return ((a.x * b.y) - (b.x * a.y)); }
ponto sum(ponto a, ponto b) { return ponto(a.x + b.x, a.y + b.y); }
void AchaCentroCircunferencia3Pontos(ponto a, ponto b, ponto c, ponto &CENTRO) {
  linha l1, l2, l3, l4;
  FazLinha(a, b, l1);
  FazLinha(c, a, l2);
  linhaperpendicular(l1, pontomedio(a, b), l3);
  linhaperpendicular(l2, pontomedio(c, a), l4);
  Intersecao(l3, l4, CENTRO);
}
int main() {
  cin.sync_with_stdio(0), cin.tie(0);
  cout << setprecision(10) << fixed;
  vector<ponto> v(3);
  le(v[0]), le(v[1]), le(v[2]);
  ponto c;
  double ans = 1e15;
  AchaCentroCircunferencia3Pontos(v[0], v[1], v[2], c);
  double r = dist(c, v[0]);
  for (int n = 3; n < 100000; ++n) {
    double theta = 360. / n;
    ponto p = v[0];
    bool o1 = 0, o2 = 0;
    for (int i = 1; i <= n; ++i) {
      if (p == v[1]) o1 = 1;
      if (p == v[2]) o2 = 1;
      p = sum(rotate(ponto(p.x - c.x, p.y - c.y), theta), c);
    }
    if (o1 && o2) {
      double b = sin((2 * acos(0) * theta / 2. / 180.0)) * r * 2;
      double h = cos((2 * acos(0) * theta / 2 / 180.0)) * r;
      cout << b * h / 2. * n << '\n';
      return 0;
    }
  }
  cout << ans << endl;
  return 0;
}
