#include <bits/stdc++.h>
#define fst first
#define snd second
#define fore(i,a,b) for(int i=a,ThxDem=b;i<ThxDem;++i)
#define pb push_back
#define ALL(s) s.begin(),s.end()
#define FIN ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0)
#define SZ(s) int(s.size())
using namespace std;
typedef long long ll;
typedef pair<int,int> ii;

struct pt{
	ll x,y;
	pt(){}
	pt(ll x, ll y):x(x),y(y){}
	ll norm2(){return *this**this;}
	pt operator +(pt p){return pt(x+p.x,y+p.y);}
	pt operator -(pt p){return pt(x-p.x,y-p.y);}
	pt operator *(ll k){return pt(x*k,y*k);}
	pt operator /(ll k){return pt(x/k,y/k);}
	ll operator *(pt p){return x*p.x+y*p.y;}
	ll operator %(pt p){return x*p.y-y*p.x;}
	bool left(pt p, pt q){return (q-p)%(*this-p)>=0;}
	bool operator <(pt p){return x<p.x||(x==p.x&&y<p.y);}
};

typedef vector<pt> poly;
 
vector<pt> chull(vector<pt> p){
	if(SZ(p)<3)return p;
	vector<pt> r;
	sort(ALL(p));
	fore(i,0,p.size()){
		while(r.size()>=2&&r.back().left(r[r.size()-2],p[i]))r.pop_back();
		r.pb(p[i]);
	}
	r.pop_back();
	int k=r.size();
	for(int i=p.size()-1;i>=0;--i){
		while(r.size()>=k+2&&r.back().left(r[r.size()-2],p[i]))r.pop_back();
		r.pb(p[i]);
	}
	r.pop_back();
	return r;
}
 
void reorder_polygon(vector<pt> & P){
    size_t pos = 0;
    for(size_t i = 1; i < P.size(); i++){
        if(P[i].y < P[pos].y || (P[i].y == P[pos].y && P[i].x < P[pos].x))
            pos = i;
    }
    rotate(P.begin(), P.begin() + pos, P.end());
}

vector<pt> add(vector<pt> P, vector<pt> Q){
	if(!SZ(P)) return Q;
	if(!SZ(Q)) return P;
	
	if(SZ(P)==1){
		for(auto &x:Q) x=(x+P[0]);
		return Q;
	}
	
	if(SZ(Q)==1){
		for(auto &x:P) x=(x+Q[0]);
		return P;
	}
	
    // the first vertex must be the lowest
    reorder_polygon(P);
    reorder_polygon(Q);
    // we must ensure cyclic indexing
    P.push_back(P[0]);
    P.push_back(P[1]);
    Q.push_back(Q[0]);
    Q.push_back(Q[1]);
    // main part
    vector<pt> result;
    size_t i = 0, j = 0;
    while(i < P.size() - 2 || j < Q.size() - 2){
        result.push_back(P[i] + Q[j]);
        auto cross = (P[i + 1] - P[i])%(Q[j + 1] - Q[j]);
        if(cross >= 0)
            ++i;
        if(cross <= 0)
            ++j;
    }
    return result;
}

poly mul(poly p, ll k){
	for(auto &x:p) x=x*k;
	return p;
}

const int MAXN=10010;
poly wh[MAXN];
vector<int> g[MAXN];

void dfs(int pos){
	if(!SZ(g[pos])) return;
	
	for(auto x:g[pos]) dfs(x);
	
	vector<poly> lef,rig;
	
	poly now;
	fore(i,0,SZ(g[pos])){
		lef.pb(now);
		reverse(ALL(wh[g[pos][i]]));
		now=add(now,mul(wh[g[pos][i]],-1));
		reverse(ALL(wh[g[pos][i]]));
	}
	
	now.clear();
	for(int i=SZ(g[pos])-1;i>=0;i--){
		rig.pb(now);
		reverse(ALL(wh[g[pos][i]]));
		now=add(now,mul(wh[g[pos][i]],-1));
		reverse(ALL(wh[g[pos][i]]));
	}
	reverse(ALL(rig));
	
	poly all;
	fore(i,0,SZ(g[pos])){
		now=add(wh[g[pos][i]], add(lef[i],rig[i]));
		for(auto p:now) all.pb(p);
	}
	
	wh[pos]=chull(all);
}

int main(){FIN;
	int n; cin>>n;
	fore(i,0,n){
		int k; cin>>k;
		if(k==0){
			int x,y; cin>>x>>y;
			wh[i].pb(pt(x,y));
		}
		else{
			fore(j,0,k){
				int x; cin>>x; x--;
				g[i].pb(x);
			}
		}
	}
	
	dfs(0);
	
	ll ans=0;
	for(auto p:wh[0]) ans=max(ans, p.norm2());
	cout<<ans<<"\n";
}