#include <bits/stdc++.h>
using namespace std;
using ll = long long;
using pll = pair<ll, ll>;

#define X first
#define Y second
using Convex = vector<pll>;
int SZ(const Convex &c) { return (int)c.size(); }
pll operator+(pll a, pll b)
{ return pll(a.X + b.X, a.Y + b.Y); }
pll operator-(pll a, pll b)
{ return pll(a.X - b.X, a.Y - b.Y); }
pll operator-(pll a)
{ return pll(-a.X, -a.Y); }
ll cross(pll a, pll b)
{ return a.X * b.Y - a.Y * b.X; }
int sign(ll a)
{ return !a ? 0 : a > 0 ? 1 : -1; }
int ori(pll a, pll b, pll c)
{ return sign(cross(b - a, c - a)); }

constexpr int kN = 10010;
vector<int> G[kN];
pll p[kN];
void hull(vector<pll> &dots) {
    sort(dots.begin(), dots.end());
    dots.resize(unique(dots.begin(), dots.end()) - dots.begin());
    Convex ans(1, dots[0]);
    for (int ct = 0; ct < 2; ++ct, reverse(dots.begin(), dots.end()))
    for (int i = 1, t = SZ(ans); i < SZ(dots); ans.push_back(dots[i++]))
        while (SZ(ans) > t && ori(ans[SZ(ans) - 2], ans.back(), dots[i]) <= 0) 
            ans.pop_back();
    ans.pop_back();
    if (ans.empty()) ans.push_back(dots[0]);
    ans.swap(dots);
    return;
}

void Flip(Convex &c) {
    for (auto &a : c) a = -a;
    hull(c);
}
void Print(const Convex &c) {
    cerr << "===\n";
    for (auto a : c) cerr << a.first << ' ' << a.second << endl;
    cerr << "===\n";
}
Convex Union(const Convex &c1, const Convex &c2) {
    Convex dots(c1.begin(), c1.end());
    dots.insert(dots.end(), c2.begin(), c2.end());
    hull(dots);
    return dots;
}
Convex Sum(const Convex &A, const Convex &B) {
    if (A.size() > B.size()) return Sum(B, A);
    assert(!A.empty());
    if ((int)A.size() <= 2) {
        vector<pll> C;
        for (const auto &a : A) {
            for (const auto &b : B) {
                C.push_back(a + b);
            }
        }
        hull(C);
        return C;
    }
  vector<pll> C(1, A[0] + B[0]), s1, s2; 
  for (int i = 0; i < SZ(A); ++i) 
    s1.push_back(A[(i + 1) % SZ(A)] - A[i]);
  for (int i = 0; i < SZ(B); i++) 
    s2.push_back(B[(i + 1) % SZ(B)] - B[i]);
  for (int i = 0, j = 0; i < SZ(A) || j < SZ(B);)
    if (j >= SZ(B) || (i < SZ(A) && cross(s1[i], s2[j]) >= 0))
      C.push_back(B[j % SZ(B)] + A[i++]);
    else
      C.push_back(A[i % SZ(A)] + B[j++]);
  hull(C);
  return C;
}
template<bool doFlip>
Convex Merge(vector<Convex> cs) {
    if ((int)cs.size() == 1) {
        if (doFlip) Flip(cs[0]);
        return cs[0];
    }
    auto mid = cs.begin() + (int)cs.size() / 2;
    if (!doFlip) {
        return Sum(
            Merge<false>(vector<Convex>(cs.begin(), mid)),
            Merge<false>(vector<Convex>(mid, cs.end()))
        );
    }
    auto c1 = Sum(
        Merge<false>(vector<Convex>(cs.begin(), mid)),
        Merge<true>(vector<Convex>(mid, cs.end()))
    );
    auto c2 = Sum(
        Merge<true>(vector<Convex>(cs.begin(), mid)),
        Merge<false>(vector<Convex>(mid, cs.end()))
    );
    return Union(c1, c2);
}
Convex solve(int u) {
    if (G[u].empty()) return {p[u]};
    vector<Convex> cs;
    for (int v : G[u]) {
        cs.push_back(solve(v));
        Flip(cs.back());
    }
    return Merge<true>(cs);
}
int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    int n;
    cin >> n;
    for (int i = 1, k; i <= n; ++i) {
        cin >> k;
        if (k) {
            for (int u; k--; ) {
                cin >> u;
                G[i].push_back(u);
            }
        } else {
            cin >> p[i].first >> p[i].second;
        }
    }
    ll ans = 0;
    auto result = solve(1);
    for (auto a : result) {
        ans = max(ans, a.first * a.first + a.second * a.second);
    }
    cout << ans << endl;
    return 0;
}