//
// Stvoreno ENERGom o 11.04.24. 16:40:54
//

#include <bits/stdc++.h>

#define all(a) a.begin(),a.end()
#define len(a) (int)(a.size())
#define F first
#define fir first
#define S second
#define sec second
#define mp make_pair
#define MP make_pair
#define pb push_back
#define PB push_back

using namespace std;

typedef pair<int, int> pii;
typedef long long ll;
typedef long double ld;

#ifdef Energy
#define DEBUG for (int _____DEBUG=1;_____DEBUG;_____DEBUG=0)

template<class ...Ts>
auto &PRNT(Ts ...ts) { return ((cerr << ts << " "), ...); }

#define LOG(...) PRNT(#__VA_ARGS__" ::",__VA_ARGS__)<<endl
#else
#define DEBUG while (0)
#define LOG(...)
#endif

const int max_n = 10011, inf = 1000111222;
const ld pi = 2 * acosl(0.0l);
const int max_its = 50;

struct Point {
    int x, y;

    Point operator - (const Point &p) const {
        return {x - p.x, y - p.y};
    }
};

int n;
vector<int> g[max_n];
Point p[max_n];
vector<Point> points;

vector<ld> angs;

void add(ld ang) {
    if (ang >= 2 * pi) {
        ang -= 2 * pi;
    }
    angs.push_back(ang);
}

const ld phi = (sqrtl(5) - 1) / 2;
const ld phi1 = 1 - phi;

const int max_cands = 4 * max_n;

ld val[max_n];
pair<ld, pair<int, int>> dp[max_n][2], tmp[2][2];
void upd(pair<ld, pair<int, int>> &a, const pair<ld, pair<int, int>> &b) {
    a = max(a, b);
}

pair<ld, pair<int, int>> comb(const pair<ld, pair<int, int>> &a, const pair<ld, pair<int, int>> &b) {
    return {a.first + b.first, {a.second.first + b.second.first, a.second.second + b.second.second}};
}
int q1 = 0, q2 = 1;

void calc(int v) {
    for (int to : g[v]) {
        calc(to);
    }
    for (int f = 0; f < 2; ++f) {
        int sign = 1 - 2 * f;
        if (g[v].empty()) {
            dp[v][f] = {sign * val[v], {p[v].x * sign, p[v].y * sign}};
            continue;
        }
        tmp[q1][0] = {-1e18, {0, 0}};
        tmp[q1][1] = {-1e18, {0, 0}};
        tmp[q1][0] = {0, {0, 0}};
        for (int to : g[v]) {
            tmp[q2][0] = {-1e18, {0, 0}};
            tmp[q2][1] = {-1e18, {0, 0}};
            for (int cur = 0; cur < 2; ++cur) {
                for (int take = 0; cur + take < 2; ++take) {
                    upd(tmp[q2][cur + take], comb(tmp[q1][cur], dp[to][f ^ take]));
                }
            }
            swap(q1, q2);
        }
        dp[v][f] = tmp[q1][1];
    }
//    LOG(v, dp[v][0].first, dp[v][1].first);
}

pair<ld, ll> f(ld ang) {
    ld dx = cosl(ang), dy = sinl(ang);
    const ld A = -dy, B = dx, C = 0;
    const ld SQ = sqrtl(A * A + B * B);
    for (int i = 0; i < n; ++i) {
        if (g[i].empty()) {
            ld dd = (A * p[i].x + B * p[i].y + C) / SQ;
            ld dot = (dx * p[i].x + dy * p[i].y);
            val[i] = sqrtl(p[i].x * p[i].x + p[i].y * p[i].y - dd * dd);
            if (dot < 0) {
                val[i] *= -1;
            }
//            LOG(i, dd, val[i]);
        }
    }
//    LOG(val[3] + val[2] + val[1]);
    calc(0);
    return {dp[0][0].first, 1LL * dp[0][0].second.first * dp[0][0].second.first + 1LL * dp[0][0].second.second * dp[0][0].second.second};
}

struct Data {
    ld L, R, m1, m2;
    pair<ld, ll> ans1, ans2;

    pair<ld, ll> get_ans() {
        return max(ans1, ans2);
    }

    void init(ld LL, ld RR) {
        L = LL;
        R = RR;
        m1 = L * phi + R * phi1;
        ans1 = f(m1);
        m2 = L * phi1 + R * phi;
        ans2 = f(m2);
    }

    void iter() {
        if (ans1 > ans2) {
            R = m2;
            m2 = m1;
            ans2 = ans1;
            m1 = L * phi + R * phi1;
            ans1 = f(m1);
        } else {
            L = m1;
            m1 = m2;
            ans1 = ans2;
            m2 = L * phi1 + R * phi;
            ans2 = f(m2);
        }
    }

    ll get_ok_ans() {
        return max(ans1.second, ans2.second);
    }
};

Data d[max_cands];

void dfs(int v, int h = 0) {
    for (int to : g[v]) {
        dfs(to, h ^ 1);
    }
    if (g[v].empty()) {
        if (h) {
            p[v].x *= -1;
            p[v].y *= -1;
        }
    }
}

int main() {
//    freopen("input_k.txt","r",stdin);
//    freopen("output.txt","w",stdout);
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    cin >> n;
    for (int i = 0; i < n; ++i) {
        int k;
        cin >> k;
        if (!k) {
            cin >> p[i].x >> p[i].y;
            LOG(p[i].x, p[i].y);
        } else {
            while (k--) {
                int to;
                cin >> to;
                --to;
                g[i].push_back(to);
            }
        }
    }
    dfs(0);
    for (int i = 0; i < n; ++i) {
        if (p[i].x || p[i].y) {
            points.push_back(p[i]);
        }
    }
    if (0) {
        auto [d1, d2] = f(atan2(-12, 5));
        LOG(d1, d2);
        LOG(d1 * d1);
        return 0;
    }
    angs.push_back(0);
    angs.push_back(2 * pi);
    for (int it = 1; it < 8; ++it) {
        angs.push_back(it * 2 * pi / 8);
    }
//    for (auto p : points) {
//        ld ang = atan2l(p.y, p.x);
//        if (ang < 0) {
//            ang += 2 * pi;
//        }
//        add(ang + pi / 2);
//        add(ang + 3 * pi / 2);
//    }
    sort(angs.begin(), angs.end());
    vector<pair<pair<ld, ll>, int>> cands, ncands;
    for (int i = 0; i + 1 < angs.size(); ++i) {
        d[i].init(angs[i], angs[i + 1]);
        cands.push_back({{0, 0}, i});
    }
    ll ans = 0;
    for (int it = 0; it < max_its; ++it) {
        ncands.clear();
        for (auto [P, id] : cands) {
            d[id].iter();
            ans = max(ans, d[id].get_ok_ans());
            ncands.push_back({d[id].get_ans(), id});
        }
        int to_leave = ncands.size();
//        to_leave = 10;
        if (it > 3) {
//            to_leave *= 0.74;
//            to_leave = max(to_leave, 47);
        }
        nth_element(ncands.begin(), ncands.begin() + to_leave, ncands.end(), greater<pair<pair<ld, ll>, int>>());
        if (ncands.size() > to_leave) {
            ncands.resize(to_leave);
        }
        cands.swap(ncands);
    }
    cout << ans << "\n";
    exit(0);
}