#include <iostream>
#include <cstdlib>
#include <cmath>
#include <cstdio>
#include <set>
#include <vector>
#include <queue>
using namespace std;

const int MAXD = 10000;				// max value for |x|, |y|
const int MAXPOLYGONS = 100;
const int MAXSEGS = 20;

const double PI = 4*atan(1.0);

set<double> xxvals;					// scan line positions

bool equals(double a, double b)
{
	return (fabs(a-b) < 0.000001);
}

class point {
public:
	double x, y;

	point() : x(0.0), y(0.0)
	{}

	point(double xx, double yy) : x(xx), y(yy)
	{}

	bool operator==(const point &rhs) const
	{
		return (equals(x, rhs.x) && equals(y, rhs.y));
	}

	void print() const
	{
		cout << '(' << x << ',' << y << ')';
	}
};

class segment {
public:
	point p1, p2;
	double ang;			// angle from point with lowest x to point with highest x


	segment()
	{}

	segment(point pp1, point pp2) : p1(pp1), p2(pp2)
	{}

	void order()
	{
		if ((!equals(p2.x, p1.x) && p2.x < p1.x) || (equals(p2.x, p1.x) && p2.y < p1.y)) {
			point tmp = p1;
			p1 = p2;
			p2 = tmp;
		}
		ang = atan2(p2.y-p1.y, p2.x-p1.x);
	}
};

class polygon {
public:
	vector<segment> segs;
	int nsegs;
	double xmin, xmax, ymin, ymax;
	double area;

	polygon() : nsegs(0)
	{}

	void add(segment s)
	{
        area += (s.p2.x - s.p1.x)*(s.p2.y+s.p1.y);
		s.order();
		segs.push_back(s);
		nsegs++;
	}

	double getArea()
	{
	    return area/2.0;
	}

	void print()
	{
		for(int i=0; i<nsegs; i++) {
			segs[i].p1.print();
			cout << '-';
			segs[i].p2.print();
			if (nsegs <=10) cout << endl;
		}
		cout << endl;
	}
} polygons[MAXPOLYGONS];
int nPoly;

class scanLineNode
{
public:
	double x, y;
	int ipoly, iseg;
							// else it's an intersecting segment

	scanLineNode(double xx=0.0, double yy=0.0, int ip1=-1, int is1=-1) : x(xx), y(yy), ipoly(ip1), iseg(is1)
	{}

	bool operator<(const scanLineNode& rhs) const
	{
		return x > rhs.x;
	}
};

class scanLine {
public:
	int n;								// number of polygons
	int size;							// number of nodes on scan line
	scanLineNode *nodes;				// the scan line
	double prevXHigh;					// used by getArea

	scanLine(int nn)
	{
		n = nn;
		size = 0;
		nodes = new scanLineNode[2*MAXSEGS*n];
		prevXHigh = -2*MAXD;
	}

	void print()
	{
		for(int i=0; i<size; i++) {
			int ip = nodes[i].ipoly;
			int is = nodes[i].iseg;
			cout << nodes[i].x << ',' << nodes[i].y << ' ' << polygons[ip].segs[is].ang << endl;
		}
	}

	double getYval(const segment &s, double x)
	{
		point p1 = s.p1;
		point p2 = s.p2;
		if (equals(p2.x, p1.x))
			return p2.y;
		return p1.y + (p2.y-p1.y)/(p2.x - p1.x)*(x - p1.x);
	}

	void insert(scanLineNode node)
	{
		int i=size;
		while (i > 0 && !equals(nodes[i-1].y, node.y) && nodes[i-1].y > node.y) {
			nodes[i] = nodes[i-1];
			i--;
		}
		segment s = polygons[node.ipoly].segs[node.iseg];
		while(i > 0 && equals(nodes[i-1].y, node.y) && polygons[nodes[i-1].ipoly].segs[nodes[i-1].iseg].ang > s.ang) {
			nodes[i] = nodes[i-1];
			i--;
		}
		nodes[i] = node;
		size++;
	}

	double getArea(double xhigh)
	{
		if (equals(xhigh, prevXHigh))
			return 0.0;
//cout << "next x = " << xhigh << endl;
		double area = 0.0;
		bool present[n];
		for(int i=0; i<n; i++)
            present[i] = false;
		double xlow = nodes[0].x;
		double ylow1 = 2*MAXD;			// artificially high
		double ylow2 = 2*MAXD;
		double yhigh1 = -2*MAXD;		// artificially low
		double yhigh2 = -2*MAXD;
		int count = 0;						// number of polygons in current
											//   vertical section of scan line
		for(int i=0; i<size; i++) {
			scanLineNode nd = nodes[i];
//cout << "processing " << nd.x << ',' << nd.y << " from " << nd.ipoly << ":" << nd.iseg << endl;
			if (!present[nd.ipoly]) {		// first time we've seen sector
				present[nd.ipoly] = true;
				count++;
				if (equals(nd.y, ylow1) || nd.y < ylow1) {
					ylow1 = nd.y;
					double y = getYval(polygons[nd.ipoly].segs[nd.iseg], xhigh);
					if (y < ylow2)
						ylow2 = y;
				}
//cout << "  setting ylow2 = " << ylow2 << endl;
			}
			else {							// second time we've seen sector
				present[nd.ipoly] = false;
				count--;
				if (equals(nd.y, yhigh1) || nd.y > yhigh1) {
					yhigh1 = nd.y;
					double y = getYval(polygons[nd.ipoly].segs[nd.iseg], xhigh);
					if (y > yhigh2)
						yhigh2 = y;
				}
//cout << "  setting yhigh2 = " << yhigh2 << endl;
			}
			if (count == 0) {
//cout << "area calc:" << xlow << ',' << xhigh << ' ' << ylow1 << ',' << yhigh1 << ' ' << ylow2 << ',' << yhigh2 << endl;
				area += (xhigh-xlow)*(yhigh1-ylow1+yhigh2-ylow2)/2.0;
				ylow1 = ylow2 = 2*MAXD;
				yhigh1 = yhigh2 = -2*MAXD;
			}
		}
if (count != 0) cout << "NOT GOOD: count = " << count << endl;
if (area<0.0) {cout << "AREA LESS THAN ZERO" << endl; area = -area;}
//cout << "   returning area = " << area << endl;
		return area;
	}

	void buildScanLine(double x)
	{
		size = 0;
		for(int i=0; i<nPoly; i++) {
			if (!equals(x,polygons[i].xmin) && x < polygons[i].xmin)
				continue;
			if (!equals(x,polygons[i].xmax) && x > polygons[i].xmax)
				continue;
			for(int j=0; j<polygons[i].segs.size(); j++) {
				segment seg = polygons[i].segs[j];
				if (equals(seg.p2.x, x))
					continue;
				if (equals(seg.p1.x, x)) {
					scanLineNode node(x, seg.p1.y, i, j);
					insert(node);
				}
				else if (seg.p1.x < x && x < seg.p2.x) {
					double y = getYval(seg, x);
					scanLineNode node(x, y, i, j);
					insert(node);
				}
			}
		}
	}
};

bool lineIntersect(double x1, double y1, double x2, double y2,
				   double x3, double y3, double x4, double y4,
				   double &xint, double &yint)
{
	double dx1 = x2-x1;
	double dx2 = x4-x3;
	double dy1 = y2-y1;
	double dy2 = y4-y3;
	double denom = dy2*dx1-dy1*dx2;
	if (equals(denom, 0.0)) {
		return false;					// colinear lines handled already
	}
	double dx3 = x1-x3;
	double dy3 = y1-y3;
	double t = (dx2*dy3-dy2*dx3)/denom;
	double u = (dx1*dy3-dy1*dx3)/denom;
	if (equals(t, 0.0) || t < 0.0)
		return false;
	if (equals(t, 1.0) || t > 1.0)
		return false;
	if (equals(u, 0.0) || u < 0.0)
		return false;
	if (equals(u, 1.0) || u > 1.0)
		return false;
	xint = x1 + t*dx1;
	yint = y1 + t*dy1;
	return true;
}

void checkForIntersection(const segment &s1, const polygon &poly)
{
	double xint, yint;
	for(int i=0; i<poly.segs.size(); i++) {
		segment s2 = poly.segs[i];
		if (lineIntersect(s1.p1.x, s1.p1.y, s1.p2.x, s1.p2.y,
						  s2.p1.x, s2.p1.y, s2.p2.x, s2.p2.y,
						  xint, yint)) {
			scanLineNode node(xint, yint, -1, -1);
			xxvals.insert(xint);
		}
	}
}

int main()
{
	cin >> nPoly;
	double paintArea = 0.0;
	for(int i=0; i<nPoly; i++) {
        int m;
        cin >> m;
		double x, y;
		cin >> x >> y;
		polygons[i].xmin = polygons[i].xmax = x;
		polygons[i].ymin = polygons[i].ymax = y;
		point p1(x,y), p2;
		segment s;
		s.p1 = p1;
		for(int j=1; j<m; j++) {
			cin >> p2.x >> p2.y;
			xxvals.insert(p2.x);
			if (p2.x < polygons[i].xmin)
				polygons[i].xmin = p2.x;
			if (p2.x > polygons[i].xmax)
				polygons[i].xmax = p2.x;
			if (p2.y < polygons[i].ymin)
				polygons[i].ymin = p2.y;
			if (p2.y > polygons[i].ymax)
				polygons[i].ymax = p2.y;
			s.p2 = p2;
			polygons[i].add(s);
			s.p1 = s.p2;
		}
		p2.x = x;
		p2.y = y;
		xxvals.insert(p2.x);
		s.p2 = p2;
		polygons[i].add(s);
//polygons[i].print();
        paintArea += polygons[i].getArea();
//cout << "area = " << polygons[i].getArea() << endl;

		for(int j=0; j<polygons[i].segs.size(); j++) {
			segment seg = polygons[i].segs[j];
			for(int k=0; k<i; k++) {
				if ((!equals(seg.p2.x, polygons[k].xmin) && seg.p2.x < polygons[k].xmin) ||
					(!equals(seg.p1.x, polygons[k].xmax) && seg.p1.x > polygons[k].xmax))
					continue;
                double ymin = seg.p1.y, ymax = seg.p2.y;
                if (ymax < ymin) {
                    double tmp = ymax;
                    ymax = ymin;
                    ymin = tmp;
                }
				if ((!equals(ymax, polygons[k].ymin) && ymax < polygons[k].ymin) ||
					(!equals(ymin, polygons[k].ymax) && ymin > polygons[k].ymax))
					continue;
				checkForIntersection(seg, polygons[k]);
			}
		}
	}

//for(set<double>::iterator it = xxvals.begin(); it != xxvals.end(); it++)
//cout << *it << endl;

	scanLine sLine(nPoly);
	double totalArea = 0.0;
	set<double>::iterator it = xxvals.begin();
	do {
		double x = *it;
		sLine.buildScanLine(x);
//cout << "scanline:" << endl; sLine.print();
		it++;
		while (it != xxvals.end() && equals(x, *it))
			it++;
		if (it == xxvals.end())
			break;
		totalArea += sLine.getArea(*it);
	} while(true);
	printf("%.8f %.8f\n", paintArea, totalArea);
}