#include<iostream>
#include<fstream>
#include<random>
#include<time.h>
#include<vector>
#include<cmath>
#include<algorithm>

using namespace std;

const double TIME_LIMIT = 4.7;
const double PI = acos(-1);
const double eps = 0.0001;

double startTime;

mt19937 rnd(69420);

struct point
{
    double x, y;
    int ind;

    point(){}
    point(double x, double y)
    {
        this->x = x;
        this->y = y;
    }
    point(double x, double y, int ind)
    {
        this->x = x;
        this->y = y;
        this->ind = ind;
    }

    point operator +(point other)
    {
        point output = *this;
        output.x += other.x;
        output.y += other.y;

        return output;
    }

    void operator +=(point other)
    {
        this->x += other.x;
        this->y += other.y;
    }

    bool operator ==(point other)
    {
        if(this->x==other.x && this->y==other.y) return true;
        return false;
    }

    void applyChange(double angle, double xDelta, double yDelta)
    {
        angle = angle/180*PI;
        this->x += xDelta;
        this->y += yDelta;

        //double xPrime = this->x*cos(angle) - this->y*sin(angle);
        //double yPrime = this->x*sin(angle) + this->y*cos(angle);

        //this->x = xPrime;
        //this->y = yPrime;
    }
};

double getDist(point A, point B)
{
    return sqrt((A.x-B.x)*(A.x-B.x) + (A.y-B.y)*(A.y-B.y));
}

double calcSurface(point A, point B, point C)
{
    return((A.x*B.y + A.y*C.x + B.x*C.y) - (A.y*B.x + A.x*C.y + B.y*C.x))/2.0;
}

point pivotPoint;
bool cmpPoint(const point A, const point B)
{
    if(calcSurface(pivotPoint, A, B)>0) return true;
    return false;
}

double sign(double x)
{
    if(x<-eps) return -1;
    if(abs(x)<eps) return 0;
    if(x>eps) return 1;
}

bool areCrossing(point A1, point A2, point B1, point B2)
{
    /*
    if(abs(calcSurface(B1, A1, B2))<eps && A1.x>=min(B1.x, B2.x) && A1.x<=max(B1.x, B2.x)) return true;
    if(abs(calcSurface(B1, A2, B2))<eps && A2.x>=min(B1.x, B2.x) && A2.x<=max(B1.x, B2.x)) return true;
    if(abs(calcSurface(A1, B1, A2))<eps && B1.x>=min(A1.x, A2.x) && B1.x<=max(A1.x, A2.x)) return true;
    if(abs(calcSurface(A1, B2, A2))<eps && B2.x>=min(A1.x, A2.x) && B2.x<=max(A1.x, A2.x)) return true;
    */

    //cout << calcSurface(A1, B1, A2) << " != " << calcSurface(A1, B2, A2) << '\n';

    if(sign(calcSurface(A1, B1, A2))!=sign(calcSurface(A1, B2, A2))
       && sign(calcSurface(B1, A1, B2))!=sign(calcSurface(B1, A2, B2))) return true;

    return false;
}

struct polygon
{
    vector <point> v;

    polygon(){}
    polygon(vector <point> v)
    {
        this->v = v;
    }

    double surface()
    {
        double S = 0;
        for(int i = 1;i<v.size()-1;i++)
        {
            S += calcSurface(v[0], v[i], v[i+1]);
        }

        return abs(S);
    }

    bool isInside(point x)
    {
        double S2 = 0;
        for(int i = 0;i<v.size();i++)
        {
            double add = calcSurface(v[(i+1)%v.size()], x, v[i]);
            if(add<=0) return false;

            S2 += add;
        }

        return true;
    }

    void applyChange(double angle, double xDelta, double yDelta)
    {
        for(point &curr: this->v)
        {
            curr.applyChange(angle, xDelta, yDelta);
        }
    }
};

struct figure
{
    int index;
    point centroid;
    vector <polygon> v;
    vector <point> allPoints;

    figure(){}
    figure(vector <polygon> v, vector <point> allPoints)
    {
        this->v = v;
        this->allPoints = allPoints;

        centroid.x = 0;
        centroid.y = 0;
        for(point p: allPoints)
        {
            centroid += p;
        }

        centroid.x /= allPoints.size();
        centroid.y /= allPoints.size();
    }

    void updateCentroid()
    {
        centroid.x = 0;
        centroid.y = 0;
        for(point p: allPoints)
        {
            centroid += p;
        }

        centroid.x /= allPoints.size();
        centroid.y /= allPoints.size();
    }

    void applyChange(double angle, double xDelta, double yDelta)
    {
        for(polygon &curr: this->v)
        {
            curr.applyChange(angle, xDelta, yDelta);
        }
        for(point &curr: this->allPoints)
        {
            curr.applyChange(angle, xDelta, yDelta);
        }

        this->centroid.applyChange(angle, xDelta, yDelta);
    }
};

bool areIntersectng(polygon A, polygon B)
{
    if(B.isInside(A.v[0])==true)
    {
        //if((clock()-startTime)/CLOCKS_PER_SEC>TIME_LIMIT) return false;
        return true;
    }
    if(A.isInside(B.v[0])==true)
    {
        //if((clock()-startTime)/CLOCKS_PER_SEC>TIME_LIMIT) return false;
        return true;
    }

    for(int p1 = 0;p1<A.v.size();p1++)
    {
        if((clock()-startTime)/CLOCKS_PER_SEC>TIME_LIMIT) return false;
        for(int p2 = 0;p2<B.v.size();p2++)
        {
            if(areCrossing(A.v[p1], A.v[(p1+1)%A.v.size()], B.v[p2], B.v[(p2+1)%B.v.size()])==true)
            {
                /*
                cout << "A:";
                for(int i = 0;i<A.v.size();i++) cout << A.v[i].x << " " << A.v[i].y << "|";
                cout << '\n';

                cout << "B:";
                for(int i = 0;i<B.v.size();i++) cout << B.v[i].x << " " << B.v[i].y << "|";
                cout << '\n';

                cout << "crossing: ";
                cout << A.v[p1].x << " " << A.v[p1].y << " | " << A.v[(p1+1)%A.v.size()].x << " "  << A.v[(p1+1)%A.v.size()].y;
                cout << " X ";
                cout << B.v[p2].x << " " << B.v[p2].y << " | " << B.v[(p2+1)%B.v.size()].x << " "  << B.v[(p2+1)%B.v.size()].y << '\n';

                cout << calcSurface(A.v[p1], B.v[p2], A.v[(p1+1)%A.v.size()]) << " != " << calcSurface(A.v[p1], B.v[(p2+1)%B.v.size()], A.v[(p1+1)%A.v.size()]) << '\n';
                */

                return true;
            }
        }
    }

    return false;
}

bool areIntersectng(figure A, figure B)
{
    for(int p1 = 0;p1<A.v.size();p1++)
    {
        for(int p2 = 0;p2<B.v.size();p2++)
        {
            if(areIntersectng(A.v[p1], B.v[p2])==true) return true;
        }
    }

    return false;
}

double convexHullSurface(vector <point> &p)
{
    if(p.size()==0) return 0;

    for(int i = 0;i<p.size();i++)
    {
        if(p[i].x<p[0].x) swap(p[i], p[0]);
    }

    pivotPoint = p[0];
    sort(p.begin()+1, p.end(), cmpPoint);

    vector <point> ch = {p[0]};
    for(int i = 1;i<p.size();i++)
    {
        while(ch.size()>=2 && calcSurface(ch[ch.size()-2], ch[ch.size()-1], p[i])<0) ch.pop_back();
        ch.push_back(p[i]);
    }

    double S = 0;
    for(int i = 1;i<ch.size()-1;i++)
    {
        S += calcSurface(ch[0], ch[i], ch[i+1]);
    }

    return abs(S);
}

vector <figure> figures;
struct solution
{
    struct info
    {
        bool used;
        double angle, x, y;
    };

    info a[505];
    double S = 0;

    solution()
    {
        for(int i = 0;i<505;i++)
        {
            this->a[i].used = false;
            this->a[i].angle = 0;
            this->a[i].x = 0;
            this->a[i].y = 0;
        }
    }

    bool isCorrect(int F)
    {
        vector <figure> v;
        for(int i = 0;i<F;i++)
        {
            if(this->a[i].used==false) continue;

            v.push_back(figures[i]);
            v.back().applyChange(this->a[i].angle, this->a[i].x, this->a[i].y);
        }

        for(int f1 = 0;f1<v.size();f1++)
        {
            for(int f2 = f1+1;f2<v.size();f2++)
            {
                if(areIntersectng(v[f1], v[f2])==true)
                {
                    //cout << f1 << " X " << f2 << '\n';
                    return false;
                }
            }
        }

        return true;
    }

    double evaluate(int F)
    {
        double S1 = 0, S2 = 0, mul = 1;
        vector <point> allPoints;

        vector <figure> v = figures;
        for(int i = 0;i<F;i++)
        {
            v[i].applyChange(this->a[i].angle, this->a[i].x, this->a[i].y);
        }

        for(int f = 0;f<F;f++)
        {
            if(this->a[f].used==false)
            {
                mul *= 1.5;
                for(int i = 0;i<v[f].v.size();i++)
                {
                    S2 += v[f].v[i].surface();                }

                continue;
            }

            for(int i = 0;i<v[f].allPoints.size();i++)
            {
                allPoints.push_back(v[f].allPoints[i]);
            }
        }

        S1 = convexHullSurface(allPoints);
        return S1 + mul*S2;
    }
};

point getCentroid(vector <point> &v)
{
    point centroid = point(0, 0);
    for(point p: v)
    {
        centroid.x += p.x;
        centroid.y += p.y;
    }

    centroid.x /= v.size();
    centroid.y /= v.size();

    return centroid;
}

bool forbidden[505];
vector <point> layer[505];

solution solve(vector <figure> fig, long long scale)
{
    int startIndex = 505;

    solution currSolution = solution();
    for(figure curr: fig)
    {
        //cout << p.ind << " = true" << '\n';
        currSolution.a[curr.index].used = true;
    }

    vector <int> all;
    for(int i = 0;i<scale;i++)
    {
        all.push_back(i);
    }
    shuffle(all.begin(), all.end(), rnd);

    vector <int> xPos;
    for(int i = 0;i<fig.size();i++)
    {
        xPos.push_back(all[i]);
    }
    sort(xPos.begin(), xPos.end());

    for(int i = 0;i<fig.size();i++)
    {
        currSolution.a[fig[i].index].x += xPos[i] - fig[i].centroid.x;
        fig[i].applyChange(0, xPos[i] - fig[i].centroid.x, 0);
    }

    long long lastY = 0;
    for(int i = 0;i<fig.size();i++)
    {
        currSolution.a[fig[i].index].y += lastY - fig[i].centroid.y;
        fig[i].applyChange(0, 0,lastY - fig[i].centroid.y);

        long long l = 0, r = 2005, mid;
        while(l+1<r)
        {
            mid = (l+r)/2;
            fig[i].applyChange(0, 0, mid);

            bool fail = false;
            for(int j = i-1;j>=0;j--)
            {
                if(areIntersectng(fig[i], fig[j])==true)
                {
                    fail = true;
                    break;
                }

                if((clock()-startTime)/CLOCKS_PER_SEC>TIME_LIMIT) break;
            }

            if(fail==false) r = mid;
            else l = mid + 1;

            fig[i].applyChange(0, 0, -mid);
        }

        currSolution.a[fig[i].index].y += r + 1;
        fig[i].applyChange(0, 0, r + 1);

        lastY += r + 1;
    }

    return currSolution;
}

int main()
{
    ifstream cin("packing.in");
    ofstream fout("packing.out");

    //solve(vector <point>{point(9, 5), point(9, 4), point(10, 6), point(12, 3), point(9, 2), point(7, 4), point(7, 6)});
    //return 0;

    int F;
    cin >> F;

    for(int i = 0;i<F;i++)
    {
        int P;
        vector <point> p;
        figures.push_back(figure());

        cin >> P;
        for(int j = 0;j<P;j++)
        {
            double x, y;
            cin >> x >> y;

            p.push_back(point(x, y));
            figures[i].allPoints.push_back(point(x, y));
        }

        int M;
        cin >> M;
        for(int j = 0;j<M;j++)
        {
            int K;
            cin >> K;

            vector <point> v;
            for(int t = 0;t<K;t++)
            {
                int ind;
                cin >> ind;

                v.push_back(p[ind]);
            }

            figures[i].v.push_back(polygon(v));
        }

        figures[i].index = i;
        figures[i].updateCentroid();
    }

    startTime = clock();

    srand(time(0));
    solution answer = solution();

    for(int percent = 100;percent>=100;percent/=2)
    {
        if((clock()-startTime)/CLOCKS_PER_SEC>TIME_LIMIT) break;

        vector <figure> v;
        for(int i = 0;i<F;i++)
        {
            if(rnd()%100<percent)
                v.push_back(figures[i]);
        }

        solution currSolution = solve(v, v.size());
        if(answer.evaluate(F) > currSolution.evaluate(F))
        {
            cout << percent << "^^^^\n";
            answer = currSolution;
        }
    }

    //cout << answer.a[0].used << answer.a[1].used << '\n';

    //cout << answer.isCorrect(F) << '\n';
    //cout << "score: " <<  answer.evaluate(F) << "\n";

    for(int i = 0;i<F;i++)
    {
        if(answer.a[i].used==false) fout << "0" << '\n';
        else fout << "1 " << answer.a[i].angle << " " << answer.a[i].x << " " << answer.a[i].y << '\n';

        //if(answer.a[i].used==false) cout << "0" << '\n';
        //else cout << "1 " << answer.a[i].angle << " " << answer.a[i].x << " " << answer.a[i].y << '\n';
    }

    //polygon P = polygon(vector <point>{point(0, 1), point(0, 0), point(1, 0), point(1, 1)});
    //cout << P.isInside(point(0.5, 5.5)) << '\n';
}
/*
3
4
6 4
6 3
7 3
7 4
1
4 0 1 2 3
4
3 3
3 2
4 2
4 3
1
4 0 1 2 3
4
10 7
10 6
11 6
11 7
1
4 0 1 2 3
*/