#include <iostream.h>
#include <math.h>

const int INT_MAX = 33767;

// main data structures for geometrical algorithms
struct point {double x, y; };
struct line { point p1, p2; };

inline void swap(point p[], int i,int j)
{
    point temp;
    temp=p[i];
    p[i]=p[j];
    p[j]=temp;
}

// Tells if 3rd point if clockwise to the line(-1),
// or anti-clockwise(+1), or if coincides(0).
int ccw(point p0, point p1, point p2)
{
    if(p0.x==p1.x && p0.y==p1.y) return 0;
    double dx1, dx2, dy1, dy2;
    dx1=p1.x - p0.x; dy1=p1.y - p0.y;
    dx2=p2.x - p0.x; dy2=p2.y - p0.y;
    if(dx1*dy2 > dy1*dx2) return +1;
    if(dx1*dy2 < dy1*dx2) return -1;
    if((dx1*dx2 < 0) || (dy1*dy2 < 0)) return -1;
    if((dx1*dx1+dy1*dy1) < (dx2*dx2+dy2+dy2)) return +1;
    return 0;
}

// Line Segment Intersection
// returns 1 if an intersection, 0 if not
inline int intersect(line l1, line l2)
{
    return    ((ccw(l1.p1, l1.p2, l2.p1) * ccw(l1.p1, l1.p2, l2.p2)) <=0)
           && ((ccw(l2.p1, l2.p2, l1.p1) * ccw(l2.p1, l2.p2, l1.p2)) <=0);
}

// returns 2D distance
inline double distance2d(point p1, point p2)
{ return sqrt((p1.x-p2.x)*(p1.x-p2.x) + (p1.y-p2.y)*(p1.y-p2.y)); }

// tells if 3 points are collinear or not
inline int collinear(point p1, point p2, point p3)
{
    if((p1.x==p2.x && p1.y==p2.y) || (p1.x==p3.x && p1.y==p3.y) || (p2.x==p3.x && p2.y==p3.y)) return 1;
    if((p2.y-p1.y)*(p3.x-p2.x)==(p3.y-p2.y)*(p2.x-p1.x)) return 1;
    return 0;
}

// Line Intersection
// returns 0 if parallel, -1 if line segments form the same line
// returns +1 if a proper intersection, puts intersection point in x,y
int linesect(line l1, line l2, double& x, double& y)
{
    if(collinear(l1.p1,l1.p2,l2.p1) && collinear(l1.p1,l1.p2,l2.p2)
    && collinear(l2.p1,l2.p2,l1.p1) && collinear(l2.p1,l2.p2,l1.p2)) return -1;

    double a1,b1,c1,a2,b2,c2,d;

    a1 = l1.p1.y - l1.p2.y;
    b1 = -1 * (l1.p1.x - l1.p2.x);
    c1 = (a1 * l1.p1.x) + (b1 * l1.p1.y);

    a2 = l2.p1.y - l2.p2.y;
    b2 = -1 * (l2.p1.x - l2.p2.x);
    c2 = (a2 * l2.p1.x) + (b2 * l2.p1.y);

    d = (b1 * a2) - (a1 * b2);

    if(d==0) return 0;

    x=((b1 * c2) - (b2 * c1))/double(d);
    y=((a2 * c1) - (a1 * c2))/double(d);

    return 1;
}

// returns the (approximate) angle made by the horizontal
// and the line made by the 2 points.
double theta(point p1, point p2)
{
    double dx, dy, ax, ay;
    double t;
    dx = p2.x - p1.x; ax = fabs(dx);
    dy = p2.y - p1.y; ay = fabs(dy);
    t = (ax+ay == 0) ? 0 : (double) dy/(ax+ay);
    if(dx < 0) t = 2-t; else if (dy < 0) t = 4+t;
    return t*90.0;
}

// Given N points, it orders them so that they form a polygon
void simplepolygon(point p[], int N)
{
    int i,j;
    point temp;

    for(i=1;i<N-1;i++)
        for(j=i+1;j<N;j++)
            if(theta(p[0],p[i])>theta(p[0],p[j]))
                swap(p,i,j);
}

// takes a polygon of N points, and returns its area.
double polygonarea(point polygon[],int N)
{
    int i,j;
    double area = 0;

    if (N==4) simplepolygon(polygon,N);

    for (i=0;i<N;i++)
    {
        j = (i + 1) % N;

        area += polygon[i].x * polygon[j].y;
        area -= polygon[i].y * polygon[j].x;
    }

    area /= 2;
    return(area < 0 ? -area : area);
}

// takes a polygon of N points, and test point
// and returns whether it is inside or not
int inside(struct point t, struct point p[], int N)
{
    int i,j,min=0,count=0;
    point temp1,temp2;

    for(i=1;i<N;i++)
        if(p[i].y < p[min].y) min=i;
    for(i=0;i<N;i++)
        if(p[i].y == p[min].y)
            if(p[i].x < p[min].x) min=i;

    if(min!=0)
    {
        while(min)
        {
            temp1=p[0];
            for(i=0;i<N;i++)
            {
                temp2=p[(i+1)%N];
                p[(i+1)%N]=temp1;
                temp1=temp2;
            }
            min=(min+1)%N;
        }
    }

    j=N-1;
    line lt,lp;
    lt.p1 = t; lt.p2 = t; lt.p2.x = INT_MAX;
    for(i=0;i<N;i++)
    {
        lp.p1=p[i];lp.p2=p[i];
        if(!intersect(lp,lt))
        {
            lp.p2=p[j]; j=i;
            if(intersect(lp,lt)) count++;
        }
    }

    return count & 1;
}


int main()
{
    int tris,i,j,k,m,n;
    point t[20][3];
    point quad[4];
    point tri[3];
    line l[6];

    cin >> tris;

    for(i=0;i<tris;i++)
        for(j=0;j<3;j++)
            cin >> t[i][j].x >> t[i][j].y;

    double area=0.0;
    for(i=0;i<tris;i++)
    {
        area+=polygonarea(t[i],3);
    }

    cout << area << endl;

    for(i=0;i<tris-1;i++)
    {
        for(j=i+1;j<tris;j++)
        {
            //if one triangle is completely inside another
            if(inside(t[j][0],t[i],3) && inside(t[j][1],t[i],3) && inside(t[j][2],t[i],3))
                area-=polygonarea(t[j],3);

            // if one triangle has two points inside another
            if(inside(t[j][0],t[i],3) && inside(t[j][1],t[i],3) && !inside(t[j][2],t[i],3))
            {
                quad[0].x=t[j][0].x; quad[0].y=t[j][0].y;
                quad[1].x=t[j][1].x; quad[1].y=t[j][1].y;
                int c=2;

                l[1].p1.x=t[i][0].x; l[1].p1.y=t[i][0].y;
                l[1].p2.x=t[i][1].x; l[1].p2.y=t[i][1].y;
                l[2].p1.x=t[i][1].x; l[2].p1.y=t[i][1].y;
                l[2].p2.x=t[i][2].x; l[2].p2.y=t[i][2].y;
                l[3].p1.x=t[i][0].x; l[3].p1.y=t[i][0].y;
                l[3].p2.x=t[i][2].x; l[3].p2.y=t[i][2].y;

                l[4].p1.x=t[j][0].x; l[4].p1.y=t[j][0].y;
                l[4].p2.x=t[j][2].x; l[4].p2.y=t[j][2].y;
                l[5].p1.x=t[j][1].x; l[5].p1.y=t[j][1].y;
                l[5].p2.x=t[j][2].x; l[5].p2.y=t[j][2].y;

                for(m=4;m<=5;m++)
                {
                    for(n=1;n<=3;n++)
                    {
                        if(intersect(l[m],l[n]))
                        {
                            k=linesect(l[m],l[n],quad[c].x,quad[c].y);
                            c++;
                        }
                    }
                }

                area-=polygonarea(quad,4);
            }

            if(inside(t[j][1],t[i],3) && inside(t[j][2],t[i],3) && !inside(t[j][0],t[i],3))
            {
                quad[0].x=t[j][1].x; quad[0].y=t[j][1].y;
                quad[1].x=t[j][2].x; quad[1].y=t[j][2].y;
                int c=2;

                l[1].p1.x=t[i][0].x; l[1].p1.y=t[i][0].y;
                l[1].p2.x=t[i][1].x; l[1].p2.y=t[i][1].y;
                l[2].p1.x=t[i][1].x; l[2].p1.y=t[i][1].y;
                l[2].p2.x=t[i][2].x; l[2].p2.y=t[i][2].y;
                l[3].p1.x=t[i][0].x; l[3].p1.y=t[i][0].y;
                l[3].p2.x=t[i][2].x; l[3].p2.y=t[i][2].y;

                l[4].p1.x=t[j][0].x; l[4].p1.y=t[j][0].y;
                l[4].p2.x=t[j][2].x; l[4].p2.y=t[j][2].y;
                l[5].p1.x=t[j][1].x; l[5].p1.y=t[j][1].y;
                l[5].p2.x=t[j][0].x; l[5].p2.y=t[j][0].y;

                for(m=4;m<=5;m++)
                {
                    for(n=1;n<=3;n++)
                    {
                        if(intersect(l[m],l[n]))
                        {
                            k=linesect(l[m],l[n],quad[c].x,quad[c].y);
                            c++;
                        }
                    }
                }

                area-=polygonarea(quad,4);
            }

            if(inside(t[j][0],t[i],3) && inside(t[j][2],t[i],3) && !inside(t[j][1],t[i],3))
            {
                quad[0].x=t[j][0].x; quad[0].y=t[j][0].y;
                quad[1].x=t[j][2].x; quad[1].y=t[j][2].y;
                int c=2;

                l[1].p1.x=t[i][0].x; l[1].p1.y=t[i][0].y;
                l[1].p2.x=t[i][1].x; l[1].p2.y=t[i][1].y;
                l[2].p1.x=t[i][1].x; l[2].p1.y=t[i][1].y;
                l[2].p2.x=t[i][2].x; l[2].p2.y=t[i][2].y;
                l[3].p1.x=t[i][0].x; l[3].p1.y=t[i][0].y;
                l[3].p2.x=t[i][2].x; l[3].p2.y=t[i][2].y;

                l[4].p1.x=t[j][0].x; l[4].p1.y=t[j][0].y;
                l[4].p2.x=t[j][1].x; l[4].p2.y=t[j][1].y;
                l[5].p1.x=t[j][1].x; l[5].p1.y=t[j][1].y;
                l[5].p2.x=t[j][2].x; l[5].p2.y=t[j][2].y;

                for(m=4;m<=5;m++)
                {
                    for(n=1;n<=3;n++)
                    {
                        if(intersect(l[m],l[n]))
                        {
                            k=linesect(l[m],l[n],quad[c].x,quad[c].y);
                            c++;
                        }
                    }
                }

                area-=polygonarea(quad,4);
            }

            //if one triangle has one point inside another
            if(inside(t[j][0],t[i],3) && !inside(t[j][1],t[i],3) && !inside(t[j][2],t[i],3))
            {
                tri[0].x=t[j][0].x; tri[0].y=t[j][0].y;
                int c=1;

                l[1].p1.x=t[i][0].x; l[1].p1.y=t[i][0].y;
                l[1].p2.x=t[i][1].x; l[1].p2.y=t[i][1].y;
                l[2].p1.x=t[i][1].x; l[2].p1.y=t[i][1].y;
                l[2].p2.x=t[i][2].x; l[2].p2.y=t[i][2].y;
                l[3].p1.x=t[i][0].x; l[3].p1.y=t[i][0].y;
                l[3].p2.x=t[i][2].x; l[3].p2.y=t[i][2].y;

                l[4].p1.x=t[j][0].x; l[4].p1.y=t[j][0].y;
                l[4].p2.x=t[j][2].x; l[4].p2.y=t[j][2].y;
                l[5].p1.x=t[j][1].x; l[5].p1.y=t[j][1].y;
                l[5].p2.x=t[j][0].x; l[5].p2.y=t[j][0].y;

                for(m=4;m<=5;m++)
                {
                    for(n=1;n<=3;n++)
                    {
                        if(intersect(l[m],l[n]))
                        {
                            k=linesect(l[m],l[n],tri[c].x,tri[c].y);
                            c++;
                        }
                    }
                }

                area-=polygonarea(tri,3);
            }

            if(!inside(t[j][0],t[i],3) && inside(t[j][1],t[i],3) && !inside(t[j][2],t[i],3))
            {
                tri[0].x=t[j][1].x; tri[0].y=t[j][1].y;
                int c=1;

                l[1].p1.x=t[i][0].x; l[1].p1.y=t[i][0].y;
                l[1].p2.x=t[i][1].x; l[1].p2.y=t[i][1].y;
                l[2].p1.x=t[i][1].x; l[2].p1.y=t[i][1].y;
                l[2].p2.x=t[i][2].x; l[2].p2.y=t[i][2].y;
                l[3].p1.x=t[i][0].x; l[3].p1.y=t[i][0].y;
                l[3].p2.x=t[i][2].x; l[3].p2.y=t[i][2].y;

                l[4].p1.x=t[j][1].x; l[4].p1.y=t[j][1].y;
                l[4].p2.x=t[j][2].x; l[4].p2.y=t[j][2].y;
                l[5].p1.x=t[j][1].x; l[5].p1.y=t[j][1].y;
                l[5].p2.x=t[j][0].x; l[5].p2.y=t[j][0].y;

                for(m=4;m<=5;m++)
                {
                    for(n=1;n<=3;n++)
                    {
                        if(intersect(l[m],l[n]))
                        {
                            k=linesect(l[m],l[n],tri[c].x,tri[c].y);
                            c++;
                        }
                    }
                }

                area-=polygonarea(tri,3);
            }

            if(!inside(t[j][0],t[i],3) && !inside(t[j][1],t[i],3) && inside(t[j][2],t[i],3))
            {
                tri[0].x=t[j][2].x; tri[0].y=t[j][2].y;
                int c=1;

                l[1].p1.x=t[i][0].x; l[1].p1.y=t[i][0].y;
                l[1].p2.x=t[i][1].x; l[1].p2.y=t[i][1].y;
                l[2].p1.x=t[i][1].x; l[2].p1.y=t[i][1].y;
                l[2].p2.x=t[i][2].x; l[2].p2.y=t[i][2].y;
                l[3].p1.x=t[i][0].x; l[3].p1.y=t[i][0].y;
                l[3].p2.x=t[i][2].x; l[3].p2.y=t[i][2].y;

                l[4].p1.x=t[j][0].x; l[4].p1.y=t[j][0].y;
                l[4].p2.x=t[j][2].x; l[4].p2.y=t[j][2].y;
                l[5].p1.x=t[j][1].x; l[5].p1.y=t[j][1].y;
                l[5].p2.x=t[j][2].x; l[5].p2.y=t[j][2].y;

                for(m=4;m<=5;m++)
                {
                    for(n=1;n<=3;n++)
                    {
                        if(intersect(l[m],l[n]))
                        {
                            k=linesect(l[m],l[n],tri[c].x,tri[c].y);
                            c++;
                        }
                    }
                }

                area-=polygonarea(tri,3);
            }
        }
     }

    for(j=0;j<tris-1;j++)
    {
        for(i=j+1;i<tris;i++)
        {
            //if one triangle is completely inside another
            if(inside(t[j][0],t[i],3) && inside(t[j][1],t[i],3) && inside(t[j][2],t[i],3))
                area-=polygonarea(t[j],3);

            // if one triangle has two points inside another
            if(inside(t[j][0],t[i],3) && inside(t[j][1],t[i],3) && !inside(t[j][2],t[i],3))
            {
                quad[0].x=t[j][0].x; quad[0].y=t[j][0].y;
                quad[1].x=t[j][1].x; quad[1].y=t[j][1].y;
                int c=2;

                l[1].p1.x=t[i][0].x; l[1].p1.y=t[i][0].y;
                l[1].p2.x=t[i][1].x; l[1].p2.y=t[i][1].y;
                l[2].p1.x=t[i][1].x; l[2].p1.y=t[i][1].y;
                l[2].p2.x=t[i][2].x; l[2].p2.y=t[i][2].y;
                l[3].p1.x=t[i][0].x; l[3].p1.y=t[i][0].y;
                l[3].p2.x=t[i][2].x; l[3].p2.y=t[i][2].y;

                l[4].p1.x=t[j][0].x; l[4].p1.y=t[j][0].y;
                l[4].p2.x=t[j][2].x; l[4].p2.y=t[j][2].y;
                l[5].p1.x=t[j][1].x; l[5].p1.y=t[j][1].y;
                l[5].p2.x=t[j][2].x; l[5].p2.y=t[j][2].y;

                for(m=4;m<=5;m++)
                {
                    for(n=1;n<=3;n++)
                    {
                        if(intersect(l[m],l[n]))
                        {
                            k=linesect(l[m],l[n],quad[c].x,quad[c].y);
                            c++;
                        }
                    }
                }

                area-=polygonarea(quad,4);
            }

            if(inside(t[j][1],t[i],3) && inside(t[j][2],t[i],3) && !inside(t[j][0],t[i],3))
            {
                quad[0].x=t[j][1].x; quad[0].y=t[j][1].y;
                quad[1].x=t[j][2].x; quad[1].y=t[j][2].y;
                int c=2;

                l[1].p1.x=t[i][0].x; l[1].p1.y=t[i][0].y;
                l[1].p2.x=t[i][1].x; l[1].p2.y=t[i][1].y;
                l[2].p1.x=t[i][1].x; l[2].p1.y=t[i][1].y;
                l[2].p2.x=t[i][2].x; l[2].p2.y=t[i][2].y;
                l[3].p1.x=t[i][0].x; l[3].p1.y=t[i][0].y;
                l[3].p2.x=t[i][2].x; l[3].p2.y=t[i][2].y;

                l[4].p1.x=t[j][0].x; l[4].p1.y=t[j][0].y;
                l[4].p2.x=t[j][2].x; l[4].p2.y=t[j][2].y;
                l[5].p1.x=t[j][1].x; l[5].p1.y=t[j][1].y;
                l[5].p2.x=t[j][0].x; l[5].p2.y=t[j][0].y;

                for(m=4;m<=5;m++)
                {
                    for(n=1;n<=3;n++)
                    {
                        if(intersect(l[m],l[n]))
                        {
                            k=linesect(l[m],l[n],quad[c].x,quad[c].y);
                            c++;
                        }
                    }
                }

                area-=polygonarea(quad,4);
            }

            if(inside(t[j][0],t[i],3) && inside(t[j][2],t[i],3) && !inside(t[j][1],t[i],3))
            {
                quad[0].x=t[j][0].x; quad[0].y=t[j][0].y;
                quad[1].x=t[j][2].x; quad[1].y=t[j][2].y;
                int c=2;

                l[1].p1.x=t[i][0].x; l[1].p1.y=t[i][0].y;
                l[1].p2.x=t[i][1].x; l[1].p2.y=t[i][1].y;
                l[2].p1.x=t[i][1].x; l[2].p1.y=t[i][1].y;
                l[2].p2.x=t[i][2].x; l[2].p2.y=t[i][2].y;
                l[3].p1.x=t[i][0].x; l[3].p1.y=t[i][0].y;
                l[3].p2.x=t[i][2].x; l[3].p2.y=t[i][2].y;

                l[4].p1.x=t[j][0].x; l[4].p1.y=t[j][0].y;
                l[4].p2.x=t[j][1].x; l[4].p2.y=t[j][1].y;
                l[5].p1.x=t[j][1].x; l[5].p1.y=t[j][1].y;
                l[5].p2.x=t[j][2].x; l[5].p2.y=t[j][2].y;

                for(m=4;m<=5;m++)
                {
                    for(n=1;n<=3;n++)
                    {
                        if(intersect(l[m],l[n]))
                        {
                            k=linesect(l[m],l[n],quad[c].x,quad[c].y);
                            c++;
                        }
                    }
                }

                area-=polygonarea(quad,4);
            }

            //if one triangle has one point inside another
            if(inside(t[j][0],t[i],3) && !inside(t[j][1],t[i],3) && !inside(t[j][2],t[i],3))
            {
                tri[0].x=t[j][0].x; tri[0].y=t[j][0].y;
                int c=1;

                l[1].p1.x=t[i][0].x; l[1].p1.y=t[i][0].y;
                l[1].p2.x=t[i][1].x; l[1].p2.y=t[i][1].y;
                l[2].p1.x=t[i][1].x; l[2].p1.y=t[i][1].y;
                l[2].p2.x=t[i][2].x; l[2].p2.y=t[i][2].y;
                l[3].p1.x=t[i][0].x; l[3].p1.y=t[i][0].y;
                l[3].p2.x=t[i][2].x; l[3].p2.y=t[i][2].y;

                l[4].p1.x=t[j][0].x; l[4].p1.y=t[j][0].y;
                l[4].p2.x=t[j][2].x; l[4].p2.y=t[j][2].y;
                l[5].p1.x=t[j][1].x; l[5].p1.y=t[j][1].y;
                l[5].p2.x=t[j][0].x; l[5].p2.y=t[j][0].y;

                for(m=4;m<=5;m++)
                {
                    for(n=1;n<=3;n++)
                    {
                        if(intersect(l[m],l[n]))
                        {
                            k=linesect(l[m],l[n],tri[c].x,tri[c].y);
                            c++;
                        }
                    }
                }

                area-=polygonarea(tri,3);
            }

            if(!inside(t[j][0],t[i],3) && inside(t[j][1],t[i],3) && !inside(t[j][2],t[i],3))
            {
                tri[0].x=t[j][1].x; tri[0].y=t[j][1].y;
                int c=1;

                l[1].p1.x=t[i][0].x; l[1].p1.y=t[i][0].y;
                l[1].p2.x=t[i][1].x; l[1].p2.y=t[i][1].y;
                l[2].p1.x=t[i][1].x; l[2].p1.y=t[i][1].y;
                l[2].p2.x=t[i][2].x; l[2].p2.y=t[i][2].y;
                l[3].p1.x=t[i][0].x; l[3].p1.y=t[i][0].y;
                l[3].p2.x=t[i][2].x; l[3].p2.y=t[i][2].y;

                l[4].p1.x=t[j][1].x; l[4].p1.y=t[j][1].y;
                l[4].p2.x=t[j][2].x; l[4].p2.y=t[j][2].y;
                l[5].p1.x=t[j][1].x; l[5].p1.y=t[j][1].y;
                l[5].p2.x=t[j][0].x; l[5].p2.y=t[j][0].y;

                for(m=4;m<=5;m++)
                {
                    for(n=1;n<=3;n++)
                    {
                        if(intersect(l[m],l[n]))
                        {
                            k=linesect(l[m],l[n],tri[c].x,tri[c].y);
                            c++;
                        }
                    }
                }

                area-=polygonarea(tri,3);
            }

            if(!inside(t[j][0],t[i],3) && !inside(t[j][1],t[i],3) && inside(t[j][2],t[i],3))
            {
                tri[0].x=t[j][2].x; tri[0].y=t[j][2].y;
                int c=1;

                l[1].p1.x=t[i][0].x; l[1].p1.y=t[i][0].y;
                l[1].p2.x=t[i][1].x; l[1].p2.y=t[i][1].y;
                l[2].p1.x=t[i][1].x; l[2].p1.y=t[i][1].y;
                l[2].p2.x=t[i][2].x; l[2].p2.y=t[i][2].y;
                l[3].p1.x=t[i][0].x; l[3].p1.y=t[i][0].y;
                l[3].p2.x=t[i][2].x; l[3].p2.y=t[i][2].y;

                l[4].p1.x=t[j][0].x; l[4].p1.y=t[j][0].y;
                l[4].p2.x=t[j][2].x; l[4].p2.y=t[j][2].y;
                l[5].p1.x=t[j][1].x; l[5].p1.y=t[j][1].y;
                l[5].p2.x=t[j][2].x; l[5].p2.y=t[j][2].y;

                for(m=4;m<=5;m++)
                {
                    for(n=1;n<=3;n++)
                    {
                        if(intersect(l[m],l[n]))
                        {
                            k=linesect(l[m],l[n],tri[c].x,tri[c].y);
                            c++;
                        }
                    }
                }

                area-=polygonarea(tri,3);
            }
        }
     }

    cout << area;

}