#include<cstring>
#include<algorithm>
#include<vector>
#include<iostream>
#include<cstdio>
#define rep(i,n) for(int i=0;i<n;i++)
#define pb push_back
using namespace std;
namespace Geometry
{
    namespace Data_Struct
    {
        template<int D>
        struct Point
        {
            double X[D];
            void input()
            {
                rep(i,D)scanf("%lf",X+i);
            }
            void operator=(const Point&a)
            {
                memcpy(X,a.X,sizeof(double)*D);
            }
            Point&operator+=(const Point&a)
            {
                rep(i,D)X[i]+=a.X[i];
                return *this;
            }
            Point&operator-=(const Point&a)
            {
                rep(i,D)X[i]-=a.X[i];
                return *this;
            }
            Point&operator*=(double d)
            {
                rep(i,D)X[i]*=d;
                return *this;
            }
            Point&operator/=(double d)
            {
                rep(i,D)X[i]/=d;
                return *this;
            }
            Point operator+(const Point&a)
            {
                Point ret=*this;
                return ret+=a;
            }
            Point operator-(const Point&a)
            {
                Point ret=*this;
                return ret-=a;
            }
            Point operator*(double d)
            {
                Point ret=*this;
                return ret*=d;
            }
            Point operator/(double d)
            {
                Point ret=*this;
                return ret/=d;
            }
            bool operator<(const Point&a)const
            {
                rep(i,D)
                {
                    if(X[i]<a.X[i])return true;
                    if(X[i]>a.X[i])return false;
                }
                return false;
            }
        };
        typedef Point<1> Point1D;
        typedef Point<2> Point2D;
        typedef Point<3> Point3D;
        double dot(Point2D a,Point2D b)
        {
            return a.X[0]*b.X[0]+a.X[1]*b.X[1];
        }
        double det(Point2D a,Point2D b)
        {
            return a.X[0]*b.X[1]-a.X[1]*b.X[0];
        }
        template<int D>
        struct Rec
        {
            typedef Point<D> PointD;
            PointD low,high;
            void just()
            {
                rep(i,D)
                {
                    if(low.X[i]>high.X[i])
                        swap(low.X[i],high.X[i]);
                }
            }
            bool inrange(double x,double l,double r)
            {
                return(x>=l&&x<=r);
            }
            bool Contain(const PointD&a)const
            {
                rep(i,D)
                {
                    if(!inrange(a.X[i],low.X[i],high.X[i]))
                        return false;
                }
                return true;
            }
        };
        typedef Rec<1> Rec1D;
        typedef Rec<2> Rec2D;
        typedef Rec<3> Rec3D;
    }
    namespace Algorithm
    {
        namespace ConvexHull
        {
            typedef Geometry::Data_Struct::Point2D Point;
            using Geometry::Data_Struct::det;
            using Geometry::Data_Struct::dot;
            vector<Point> Calc_ConvexHull(vector<Point> P)
            {
                sort(P.begin(),P.end());
                int n=P.size(),k=0;
                if(n<=1)return P;
                vector<Point> qs(2*n);
                for(int i=0;i<n;qs[k++]=P[i++])
                    while(k>1&&det(qs[k-1]-qs[k-2],P[i]-qs[k-1])<=0)k--;
                for(int i=n-2,t=k;i>=0;qs[k++]=P[i--])
                    while(k>t&&det(qs[k-1]-qs[k-2],P[i]-qs[k-1])<=0)k--;
                vector<Point> ret(qs.begin(),qs.begin()+k);
                return ret;
            }
            double Area(const vector<Point>&P)
            {
                int n=P.size();double ret=0;
                rep(i,n)ret+=det(P[i],P[(i+1)%n]);
                return ret/2;
            }
        }
    }
}
int main()
{
    using namespace Geometry::Algorithm::ConvexHull;
    vector<Point> A;
    rep(i,4)
    {
        Point a;a.input();
        A.pb(a);
    }
    vector<Point>ret=Calc_ConvexHull(A);
    cout<<Area(ret)<<endl;
}