#include <bits/stdc++.h>
#define ff first
#define ss second;
using namespace std;

typedef long long ll;
typedef pair<int, int> pii;
typedef pair<ll, ll> pll;

struct Point
{
    ll x, y, z;
};

Point operator + (const Point &p, const Point &q) { return {p.x+q.x, p.y+q.y, p.z+q.z}; }
Point operator - (const Point &p, const Point &q) { return {p.x-q.x, p.y-q.y, p.z-q.z}; }
ll operator * (const Point &p, const Point &q) { return p.x*q.x+p.y*q.y+p.z*q.z; }
Point operator / (const Point &p, const Point &q) { return Point{p.y*q.z-p.z*q.y, p.z*q.x-p.x*q.z, p.x*q.y-p.y*q.x}; }
ll mag(const Point &p) { return p*p; }

const int MAXN = 200;

struct Frac
{
    ll u, d;
    bool operator == (Frac ot) { return u*ot.d == ot.u*d; }
};

int N;

struct Tree
{
    Point A[MAXN+10];
    pii E[MAXN+10];
    vector<int> adj[MAXN+10];
    vector<int> cen;

    void input()
    {
        for(int i=1; i<=N; i++) scanf("%lld%lld%lld", &A[i].x, &A[i].y, &A[i].z);
        for(int i=1; i<N; i++)
        {
            scanf("%d%d", &E[i].first, &E[i].second);
            if(E[i].first>N) E[i].first-=N;
            if(E[i].second>N) E[i].second-=N;
            if(E[i].first>E[i].second) swap(E[i].first, E[i].second);
            adj[E[i].first].push_back(E[i].second);
            adj[E[i].second].push_back(E[i].first);
        }

        getsz(1, 1);
        int c=getcen(1, 1);
        getsz(c, c);
        cen.push_back(c);
        for(auto nxt : adj[c]) if(sz[nxt]*2==N) cen.push_back(nxt);
        sort(E+1, E+N);
    }

    int sz[MAXN+10];
    void getsz(int now, int bef)
    {
        sz[now]=1;
        for(int nxt : adj[now])
        {
            if(nxt==bef) continue;
            getsz(nxt, now);
            sz[now]+=sz[nxt];
        }
    }

    int getcen(int now, int bef)
    {
        for(int nxt : adj[now])
        {
            if(nxt==bef) continue;
            if(sz[nxt]>N/2) return getcen(nxt, now);
        }
        return now;
    }

    void translate(int now)
    {
        Point p=A[now];
        for(int i=1; i<=N; i++) A[i]=A[i]-p;
    }

    vector<array<ll, 5>> f(int pp, int qq)
    {
        Point p=A[pp], q=A[qq];
        vector<array<ll, 5>> ret;
        for(int i=1; i<=N; i++)
        {
            Point r=A[i];
            ll t=(p/q)*r;
            ret.push_back(array<ll, 5>{r*p, r*q, r*r, (t>0)-(t<0), i});
        }
        sort(ret.begin(), ret.end());
        return ret;
    }
}A, B;


int main() {
    cin.tie(0); ios_base::sync_with_stdio(0);
    
    scanf("%d", &N);
    A.input();
    B.input();

    int ans=0;
    for(auto ca : A.cen) for(auto cb : B.cen)
    {
        A.translate(ca);
        B.translate(cb);

        int pa, qa=-1;
        if(ca==1) pa=2;
        else pa=1;

        for(int i=1; i<=N; i++)
        {
            if(i==ca || i==pa) continue;
            Point p=A.A[i]/A.A[pa];
            if(p.x!=0 || p.y!=0 || p.z!=0)
            {
                qa=i;
                break;
            }
        }

        if(qa==-1) qa=pa;
        // printf("%d %d %d\n", ca, pa, qa);

        for(int pb=1; pb<=N; pb++)
        {
            if(pb==cb) continue;
            Frac K = Frac{mag(A.A[pa]), mag(B.A[pb])};
            for(int qb=1; qb<=N; qb++)
            {
                if(qb==cb || (pa!=qa && qb==pb)) continue;
                if(!(K==Frac{mag(A.A[qa]), mag(B.A[qb])})) continue;
                if(!(K==Frac{A.A[pa]*A.A[qa], B.A[pb]*B.A[qb]})) continue;

                // printf("%d %d %d / %d %d %d\n", ca, pa, qa, cb, pb, qb);

                auto VA=A.f(pa, qa), VB=B.f(pb, qb);
                bool flag=true;
                vector<int> P(N+1);
                for(int i=0; i<N; i++)
                {
                    // for(int j=0; j<5; j++) printf("%lld ", VA[i][j]); printf(" : A %d\n", i);
                    // for(int j=0; j<5; j++) printf("%lld ", VB[i][j]); printf(" : B %d\n", i);
                    for(int j=0; j<3; j++) if(!(K==Frac{VA[i][j], VB[i][j]})) flag=false;
                    if(VA[i][3]!=VB[i][3]) flag=false;
                    P[VA[i][4]]=VB[i][4];
                }

                if(flag)
                {
                    for(int i=1; i<N; i++)
                    {
                        auto [u, v] = A.E[i];
                        int u2=P[u], v2=P[v];
                        if(u2>v2) swap(u2, v2);
                        if(!binary_search(B.E, B.E+N, pii{u2, v2})) flag=false;
                    }
                    if(flag) ans++;
                }
            }
        }
    }
    printf("%d\n", ans);
}