#pragma GCC optimize("Ofast")
#include <iostream>
#include <vector>
#include <algorithm>
#include <cmath>
#include <set>
#include <assert.h>
using namespace std;

const double eps = 1e-8;
int sgn(double a){return a<-eps?-1:a>eps?1:0;}
int sgn(double a, double b){return sgn(a-b);}
struct point{
    double x,y,z;
    point() {}
    point(double x,double y,double z): x(x), y(y), z(z) {}
    point operator+ (const point& p){
        return point(x+p.x, y+p.y, z+p.z);
    }
    point operator- (const point& p){
        return point(x-p.x, y-p.y, z-p.z);
    }
    point operator/ (const double d){
        return point(x/d, y/d, z/d);
    }
    double dist(const point& p){
        return sqrt((x-p.x)*(x-p.x) + (y-p.y)*(y-p.y) + (z-p.z)*(z-p.z));
    }
};

int main(){
    cin.tie(nullptr);
    ios::sync_with_stdio(false);
    // input
    int n; cin >> n;
    vector<point> A(n);
    for(int i=0;i<n;i++){
        int x,y,z; cin >> x >> y >> z;
        A[i] = point(x,y,z);
    }
    vector<vector<int>> g1(n);
    for(int i=1;i<n;i++){
        int x,y; cin >> x >> y;
        x--; y--;
        g1[x].push_back(y);
        g1[y].push_back(x);
    }
    vector<point> B(n);
    for(int i=0;i<n;i++){
        int x,y,z; cin >> x >> y >> z;
        B[i] = point(x,y,z);
    }
    vector<vector<int>> g2(n);
    for(int i=1;i<n;i++){
        int x,y; cin >> x >> y;
        x -= n+1; y -= n+1;
        g2[x].push_back(y);
        g2[y].push_back(x);
    }

    // 木の葉ノードを基準に変形
    auto getTree = [&](vector<point> A, vector<vector<int>> &g, int leaf, int idx = -1)->vector<point>{
        // step1: 葉ノードを原点に平行移動させる
        {
            auto p = A[leaf];
            for(int i=0;i<n;i++){
                A[i] = A[i]-p;
            }
        }
        // step2: 葉ノードと親の距離を1にする
        int par = g[leaf][0];
        {
            double d = A[leaf].dist(A[par]);
            vector<point> nA(n);
            nA[leaf] = A[leaf];
            auto dfs = [&](auto self, int s, int p)->void{
                for(int t:g1[s]){
                    if(t == p) continue;
                    point v = (A[t]-A[s])/d;
                    nA[t] = nA[s]+v;
                    self(self, t, s);
                }
            };
            dfs(dfs, leaf, -1);
            swap(A, nA);
        }
        // step3:z軸中心に回転させ、親ノードをxz平面上へ
        {
            double theta = -atan2(A[par].y, A[par].x);
            for(int i=0;i<n;i++){
                double nx = A[i].x*cos(theta) - A[i].y*sin(theta);
                double ny = A[i].x*sin(theta) + A[i].y*cos(theta);
                A[i].x = nx, A[i].y = ny;
            }
        }
        // step4:y軸中心に回転させ、親ノードをx軸上へ
        {
            double theta = -atan2(A[par].z, A[par].x);
            for(int i=0;i<n;i++){
                double nx = A[i].x*cos(theta) - A[i].z*sin(theta);
                double nz = A[i].x*sin(theta) + A[i].z*cos(theta);
                A[i].x = nx, A[i].z = nz;
            }
        }
        // step5:x軸中心に回転させ、親ノードに接続する元の葉以外をy軸上へ
        // idx = -1 ならば任意、それ以外はA[idx]を合わせる
        if(idx == -1){
            for(int t:g[par]){
                if(t == leaf) continue;
                if(abs(A[t].y) < eps and abs(A[t].z) < eps) continue;
                idx = t; break;
            }
        }
        if(idx != -1){
            double theta = -atan2(A[idx].z, A[idx].y);
            for(int i=0;i<n;i++){
                double ny = A[i].y*cos(theta) - A[i].z*sin(theta);
                double nz = A[i].y*sin(theta) + A[i].z*cos(theta);
                A[i].y = ny, A[i].z = nz;
            }
        }
        return A;
    };

    int lA = -1;
    for(int i=0;i<n;i++){
        sort(g1[i].begin(), g1[i].end());
        if(g1[i].size() == 1) lA = i;
    }
    assert(lA != -1);
    auto gA = getTree(A, g1, lA);

    // 比較用の関数
    set<vector<int>> st;
    auto compare = [&](vector<point> &A, vector<point> &B)->void{
        vector<int> Bidx(n,-1),Binv(n);
        // A[i] = B[Bidx[i]]
        for(int i=0;i<n;i++){
            for(int j=0;j<n;j++){
                if(sgn(A[i].x, B[j].x) or sgn(A[i].y, B[j].y) or sgn(A[i].z, B[j].z)) continue;
                Bidx[i] = j; Binv[j] = i; break;
            }
            if(Bidx[i] == -1) return;
        }
        // 隣接リストがそれぞれ一致しているか調べる
        for(int i=0;i<n;i++){
            auto v = g1[i], vv = g2[Bidx[i]];
            for(int &j:vv){
                j = Binv[j];
            }
            sort(vv.begin(), vv.end());
            if(v != vv) return;
        }
        st.insert(Bidx);
    };

    // AとBの比較
    for(int i=0;i<n;i++){
        if(g2[i].size() != 1) continue;
        // iは葉ノード
        int par = g2[i][0];
        // step5でy軸に合わせるidxを全て試す
        for(int j:g2[par]){
            auto gB = getTree(B, g2, i, (i==j?-1:j));
            compare(gA, gB);
        }
    }

    // output
    cout << st.size() << endl;
}