#include <bits/stdc++.h>
//#define int long long
#pragma GCC optimize(2)
#define endl "\n"
using namespace std;

using ll = long long;
const int MOD = 998244353;
const int N = 1e6 + 5;

ll quickPower(ll a, ll n) {
    if (a == 0)
        return 0;
    ll res = 1;
    while (n) {
        if (n & 1)
            res = res * a % MOD;
        a = a * a % MOD;
        n >>= 1;
    }
    return res;
}

ll inv(ll x) {
    return quickPower(x, MOD - 2);
}

vector<int> edges[N];
pair<int, int> query[N];

struct DSU {
    int fa[N];
    unordered_set<int> con[N];
    unordered_set<int> nd[N];

    DSU(int n = N - 1) {
        for (int i = 1; i <= n; i++) {
            fa[i] = i;
            con[i].emplace(i);
        }
    }

    void init(int n = N - 1) {
        for (int i = 1; i <= n; i++) {
            for (int j : edges[i]) {
                nd[i].emplace(j);
            }
        }
    }

    int find(int x) {
        return fa[x] == x ? x : find(fa[x]);
    }

    void merge(int u, int v) {
        u = find(u), v = find(v);
        if (con[u].size() > con[v].size()) {
            for (int x : con[v]) {
                con[u].insert(x);
            }
            for (int x : nd[v]) {
                nd[u].insert(x);
            }
            con[v].clear();
            nd[v].clear();
            fa[v] = u;
        }
        else {
            for (int x : con[u]) {
                con[v].insert(x);
            }
            for (int x : nd[u]) {
                nd[v].insert(x);
            }
            con[u].clear();
            nd[u].clear();
            fa[u] = v;
        }
    }
} dsu;

int main() {
    ios::sync_with_stdio(0),cin.tie(0),cout.tie(0);

    int n;
    cin >> n;
    for (int i = 1; i <= n - 1; i++) {
        cin >> query[i].first >> query[i].second;
    }
    for (int i = 1; i <= n - 1; i++) {
        int u, v;
        cin >> u >> v;
        edges[u].emplace_back(v);
        edges[v].emplace_back(u);
    }
    dsu.init(n);

    ll ans = 1;
    for (int i = 1; i <= n - 1; i++) {
        auto [u, v] = query[i];
        int fu = dsu.find(u);
        int fv = dsu.find(v);
        if (dsu.nd[fu].size() > dsu.nd[fv].size()) {
            for (int x : dsu.nd[fv]) {
                if (dsu.con[fv].count(x))
                    continue;
                if (!dsu.con[fu].count(x))
                    ans = 0;
                else 
                    ans = ans * inv(dsu.con[fu].size()) % MOD * inv(dsu.con[fv].size()) % MOD;
            }
        }
        else {
            for (int x : dsu.nd[fu]) {
                if (dsu.con[fu].count(x))
                    continue;
                if (!dsu.con[fv].count(x))
                    ans = 0;
                else 
                    ans = ans * inv(dsu.con[fu].size()) % MOD * inv(dsu.con[fv].size()) % MOD;
            }
        }
        dsu.merge(u, v);
    }
    cout << ans << endl;

    return 0;
}