vector<vector<int> > graph;
void dfs(int node,int parent){
    //do something
    for(auto x:graph[node]){
        if(x==parent) continue;
        dfs(x,node);
    }
}

vector<vector<int> > graph;
vector<int> pre,post;
void dfs(int node,int parent){
    //do something
    pre.push_back(node);
    for(auto x:graph[node]){
        if(x==parent) continue;
        dfs(x,node);
    }
    post.push_back(node);
}

vector<vector<int> > graph;
vector<int> sz,dep;
void dfs(int node,int parent){
    sz[node]=1;
    dep[node]=dep[parent]+1;
    for(auto x:graph[node]){
        if(node==parent) continue;
        dfs(x,node);
        sz[node]+=sz[x];
    }
}

void dfs2(int node,int parent){
    for(auto x:graph[node]){
        if(x==parent) continue;
        dp[x]=dp[node]+1;
        dfs2(x,node);
    }
}
// ans = sum(dp)

#include<iostream>
#include<vector>
#include<algorithm>
#define ll long long
using namespace std;
vector<ll> sub,dp;
vector<vector<int>> graph;
int n;
void dfs1(int node,int parent){
    for(auto x:graph[node]){
        if(x==parent) continue;
        dfs1(x,node);
        sub[node]+=sub[x];
    }
    sub[node]++;
}
void dfs2(int node,int parent){
    for(auto x:graph[node]){
        if(x==parent) continue;
        dp[x]=dp[node]+1;
        dfs2(x,node);
    }
}
void dfs3(int node,int parent){
    for(auto x:graph[node]){
        if(x==parent) continue;
        dp[x]=dp[node]-sub[x]+n-sub[x];
        dfs3(x,node);
    }
}
int main(){
    cin>>n;
    int a,b;
    sub.resize(n+1);
    dp.resize(n+1);
    graph.resize(n+1);
    for(int i=1;i<n;i++){
        cin>>a>>b;
        graph[a].push_back(b);
        graph[b].push_back(a);
    }
    dfs1(1,0);
    dfs2(1,0);
    for(int i=2;i<=n;i++) dp[1]+=dp[i];
    for(int i=2;i<=n;i++) dp[i]=0;
    dfs3(1,0);
    for(int i=1;i<=n;i++) cout<<dp[i]<<' ';
}

#include<iostream>
#include<vector>
#define ll long long
using namespace std;
vector<vector<int>> graph;
vector<ll> val,seg,order,out;
int cnt=0;
void dfs(int node,int parent){
    cnt++;
    order[cnt]=node;
    for(auto x:graph[node]){
        if(x==parent) continue;
        dfs(x,node);
    }
    out[node]=cnt;
}
void build(int l,int r,int ind){
    if(l==r){
        seg[ind]=val[order[l]];
        return;
    }
    int mid=(l+r)>>1;
    build(l,mid,ind*2);
    build(mid+1,r,ind*2+1);
    seg[ind]=seg[ind*2]+seg[ind*2+1];
}
ll query(int l,int r,int start,int end,int ind){
    if(start<=l&&r<=end) return seg[ind];
    if(r<start||end<l){
        return 0;
    }
    int mid=(l+r)>>1;
    return query(l,mid,start,end,ind*2)+query(mid+1,r,start,end,ind*2+1);
}
void modify(int l,int r,int pos,ll num,int ind){
    if(l==r){
        seg[ind]=num;
        return;
    }
    int mid=(l+r)>>1;
    if(pos<=mid){
        modify(l,mid,pos,num,ind*2);
        seg[ind]=seg[ind*2]+seg[ind*2+1];
    }
    else{
        modify(mid+1,r,pos,num,ind*2+1);
        seg[ind]=seg[ind*2]+seg[ind*2+1];
    }
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,q;
    cin>>n>>q;
    val.resize(n+1);
    seg.resize(4*n+4);
    order.resize(n+1);
    out.resize(n+1);
    graph.resize(n+1);
    for(int i=1;i<=n;i++) cin>>val[i];
    int a,b;
    for(int i=1;i<n;i++){
        cin>>a>>b;
        graph[a].push_back(b);
        graph[b].push_back(a);
    }
    dfs(1,0);
    build(1,n,1);
    ll s,x,op;
    vector<int> revord(n+1);
    for(int i=1;i<=n;i++) revord[order[i]]=i;
    for(int i=0;i<q;i++){
        cin>>op;
        if(op==1){
            cin>>s>>x;
            modify(1,n,revord[s],x,1);
            
        }
        else{
            cin>>s;
            cout<<query(1,n,revord[s],out[s],1)<<"\n";
        }
    }
}

#include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
#define ll long long
using namespace std;
vector<ll> in,vec,out,dep,bit;
vector<vector<ll>> anc;
vector<pair<pair<ll,ll>,ll>> edges;
vector<vector<pair<ll,ll>>> graph;
void dfs(int node,int parent){
    in.push_back(node);
    for(auto x:graph[node]){
        if(x.first==parent) continue;
        anc[x.first][0]=node;
        dep[x.first]=dep[node]+1;
        vec[x.first]=vec[node]+x.second;
        dfs(x.first,node);
    }
    out[node]=in.size()-1;
}
void build(int n){
    bit[1]=vec[in[1]];
    if(n>1) bit[2]=vec[in[1]];
    for(int i=2;i<=n;i++){
        bit[i]+=vec[in[i]]-vec[in[i-1]];
        if(i+(i&-i)<=n) bit[i+(i&-i)]+=bit[i];
    }
}
void modify(int l,int r,int num,int n){
    while(l<=n){
        bit[l]+=num;
        l+=(l&-l);
    }
    r++;
    while(r<=n){
        bit[r]-=num;
        r+=(r&-r);
    }
}
ll query(int pos){
    ll ans=0;
    while(pos>0){
        ans+=bit[pos];
        pos-=(pos&-pos);
    }
    return ans;
}
void build_anc(int n){
    for(int j=1;j<19;j++){
        for(int i=1;i<=n;i++) anc[i][j]=anc[anc[i][j-1]][j-1];
    }
}
int lca(int u,int v){
    if(dep[v]>dep[u]) swap(u,v);
    int diff=(dep[u]-dep[v]);
    for(int i=0;i<19;i++){
        if(diff&(1<<i)){
            u=anc[u][i];
            diff-=(1<<i);
        }
        if(diff==0) break;
    }
    if(u==v) return u;
    for(int i=18;i>=0;i--){
        if(anc[u][i]!=anc[v][i]){
            u=anc[u][i];
            v=anc[v][i];
        }
    }
    return anc[u][0];
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,q;
    cin>>n;
    ll a,b,c;
    edges.resize(n);
    vec.resize(n+1);
    anc.resize(n+1,vector<ll>(19));
    out.resize(n+1);
    dep.resize(n+1);
    bit.resize(n+1);
    in.push_back(0);
    graph.resize(n+1);
    for(int i=1;i<n;i++){
        cin>>a>>b>>c;
        edges[i].first.first=a;
        edges[i].first.second=b;
        edges[i].second=c;
        graph[a].push_back(make_pair(b,c));
        graph[b].push_back(make_pair(a,c));
    }
    dfs(1,0);
    build(n);
    build_anc(n);
    cin>>q;
    vector<int> opin(n+1);
    for(int i=1;i<=n;i++) opin[in[i]]=i;
    for(int i=0;i<q;i++){
        cin>>c>>a>>b;
        if(c==1){
            int son;
            if(opin[edges[a].first.first]>opin[edges[a].first.second]) son=edges[a].first.first;
            else son=edges[a].first.second;
            modify(opin[son],out[son],b-edges[a].second,n);
            edges[a].second=b;
        }
        else{
            int gp=lca(a,b);
            cout<<query(opin[a])+query(opin[b])-2*query(opin[gp])<<"\n";
        }
    }
}

int cnt[maxn];
void add(int v, int p, int x){
    cnt[ col[v] ] += x;
    for(auto u: g[v])
        if(u != p)
            add(u, v, x)
}
void dfs(int v, int p){
    add(v, p, 1);
    //now cnt[c] is the number of vertices in subtree of vertex v that has color c. You can answer the queries easily.
    add(v, p, -1);
    for(auto u : g[v])
        if(u != p)
            dfs(u, v);
}

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
vector<int> cnt,sz,ans,in,out,ord,vec;
vector<vector<int> > graph;
int timer=0;
void dfsz(int node,int parent){
    sz[node]++;
    ord.push_back(node);
    in[node]=timer++;
    for(auto x:graph[node]){
        if(x==parent) continue;
        dfsz(x,node);
        sz[node]+=sz[x];
    }
    out[node]=timer-1;
}
void dfs(int node,int parent,bool keep){
    int big=-1,maxi=-1;
    for(auto x:graph[node]){
        if(x==parent) continue;
        if(sz[x]>maxi){
            maxi=sz[x];
            big=x;
        }
    }
    for(auto x:graph[node]){
        if(x!=parent&&x!=big){
            dfs(x,node,0);
        }
    }
    if(big!=-1) dfs(big,node,1),ans[node]=ans[big];
    for(auto x:graph[node]){
        if(x!=parent&&x!=big){
            for(int i=in[x];i<=out[x];i++){
                cnt[vec[ord[i]]]++;
                if(cnt[vec[ord[i]]]==1) ans[node]++;
            }
        }
    }
    cnt[vec[node]]++;
    if(cnt[vec[node]]==1) ans[node]++;
    if(!keep){
        for(int i=in[node];i<=out[node];i++) cnt[vec[ord[i]]]--;
    }
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n;
    cin>>n;
    cnt.resize(n+1);
    graph.resize(n+1);
    ans.resize(n+1);
    sz.resize(n+1);
    in.resize(n+1);
    out.resize(n+1);
    vec.resize(n+1);
    for(int i=1;i<=n;i++) cin>>vec[i];
    vector<int> cp;
    for(int i=1;i<=n;i++) cp.push_back(vec[i]);
    sort(cp.begin(),cp.end());
    cp.resize(unique(cp.begin(),cp.end())-cp.begin());
    for(int i=1;i<=n;i++) vec[i]=lower_bound(cp.begin(),cp.end(),vec[i])-cp.begin()+1;
    int a,b;
    for(int i=1;i<n;i++){
        cin>>a>>b;
        graph[a].push_back(b);
        graph[b].push_back(a);
    }
    dfsz(1,0);
    dfs(1,0,1);
    for(int i=1;i<=n;i++) cout<<ans[i]<<" ";
}

#include<iostream>
#include<vector>
#include<algorithm>
#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx,avx2")
using namespace std;
const int N=2e5+5;
int in[N],out[N],sz[N],nxt[N],par[N],vec[N],seg[4*N],dep[N];
vector<int> ord;
vector<vector<int> > graph;
int cnt=0;
void dfs_sz(int node,int parent){
    sz[node]=1;
    par[node]=parent;
    if(node!=1) dep[node]=dep[parent]+1;
    int szz=graph[node].size();
    int mx=0;
    for(int i=0;i<szz;i++){
        if(graph[node][i]==parent) continue;
        dfs_sz(graph[node][i],node);
        sz[node]+=sz[graph[node][i]];
        if(sz[graph[node][i]]>mx){
            mx=sz[graph[node][i]];
            swap(graph[node][i],graph[node][0]);
        }
    }
}
void dfs_nxt(int node,int parent){
    in[node]=++cnt;
    ord.push_back(node);
    for(auto x:graph[node]){
        if(x==parent) continue;
        if(x==graph[node][0]) nxt[x]=nxt[node];
        else nxt[x]=x;
        dfs_nxt(x,node);
    }
    out[node]=cnt;
}
void build(int l,int r,int ind){
    if(l==r){
        seg[ind]=vec[ord[l]];
    }
    else{
        int mid=(l+r)>>1;
        build(l,mid,ind*2);
        build(mid+1,r,ind*2+1);
        seg[ind]=max(seg[ind*2],seg[ind*2+1]);
    }
}
void modify(int l,int r,int num,int pos,int ind){
    if(l==r){
        seg[ind]=num;
        return;
    }
    int mid=(l+r)>>1;
    if(pos<=mid) modify(l,mid,num,pos,ind*2);
    else modify(mid+1,r,num,pos,ind*2+1);
    seg[ind]=max(seg[ind*2],seg[ind*2+1]);
}
int query(int l,int r,int start,int end,int ind){
    if(r<start||end<l) return 0;
    if(start<=l&&r<=end) return seg[ind];
    int mid=(l+r)>>1;
    return max(query(l,mid,start,end,ind*2),query(mid+1,r,start,end,ind*2+1));
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int n,q;
    cin>>n>>q;
    graph.resize(n+1);
    nxt[1]=1;
    dep[1]=1;
    ord.push_back(0);
    int a,b;
    for(int i=1;i<=n;i++) cin>>vec[i];
    for(int i=1;i<n;i++){
        cin>>a>>b;
        graph[a].push_back(b);
        graph[b].push_back(a);
    }
    dfs_sz(1,0);
    dfs_nxt(1,0);
    build(1,n,1);
    int op;
    for(int i=0;i<q;i++){
        cin>>op;
        if(op==1){
            cin>>a>>b;
            modify(1,n,b,in[a],1);
            vec[a]=b;
        }
        else{
            cin>>a>>b;
            int ans=vec[a];
            while(nxt[a]!=nxt[b]){
                if(dep[nxt[a]]<dep[nxt[b]]) swap(a,b);
                ans=max(ans,query(1,n,in[nxt[a]],in[a],1));
                a=par[nxt[a]];
            }
            if(dep[a]<dep[b]) swap(a,b);
            ans=max(ans,query(1,n,in[b],in[a],1));
            cout<<ans<<" ";
        }
    }
}

#include<iostream>
#include<vector>
using namespace std;
vector<vector<int> > graph;
vector<int> sz;
int n;
void dfs_sz(int node,int parent){
    for(auto x:graph[node]){
        if(x==parent) continue;
        dfs_sz(x,node);
        sz[node]+=sz[x];
    }
    sz[node]++;
}
int dfs_cent(int node,int parent){
    for(auto x:graph[node]){
        if(x==parent) continue;
        if(sz[x]>n/2) return dfs_cent(x,node);
    }
    return node;
}
int main(){
    cin>>n;
    graph.resize(n+1);
    sz.resize(n+1);
    int a,b;
    for(int i=1;i<n;i++){
        cin>>a>>b;
        graph[a].push_back(b);
        graph[b].push_back(a);
    }
    dfs_sz(1,0);
    cout<<dfs_cent(1,0);
}

#pragma GCC optimize("O3,unroll-loops")
#pragma GCC target("avx,avx2,bmi,bmi2")
#include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
#define ll long long
using namespace std;
const int N = 2e5+5;
int sz[N],dep[N];
bool vis[N];
vector<vector<int> > graph;
ll cnt[N];
int n,k;
void dfs_sz(int node,int parent){
    sz[node]=1;
    for(auto x:graph[node]){
        if(x==parent||vis[x]) continue;
        dfs_sz(x,node);
        sz[node]+=sz[x];
    }
}
int dfs_cent(int node,int parent,int tot_sz){
    for(auto x:graph[node]){
        if(x==parent||vis[x]) continue;
        if(sz[x]*2>tot_sz) return dfs_cent(x,node,tot_sz);
    }
    return node;
}
void dfs_dep(int node,int parent){
    if(parent==-1) dep[node]=0;
    else dep[node]=dep[parent]+1;
    for(auto x:graph[node]){
        if(x==parent||vis[x]) continue;
        dfs_dep(x,node);
    }
}
ll dfs_calc_ans(int node,int parent){
    ll sum;
    if(dep[node]>k) sum=0;
    else sum=cnt[k-dep[node]];
    for(auto x:graph[node]){
        if(x==parent||vis[x]) continue;
        sum+=dfs_calc_ans(x,node);
    }
    return sum;
}
void dfs_build_cnt(int node,int parent){
    cnt[dep[node]]++;
    for(auto x:graph[node]){
        if(x==parent||vis[x]) continue;
        dfs_build_cnt(x,node);
    }
}
void dfs_reset(int node,int parent){
    cnt[dep[node]]=0;
    for(auto x:graph[node]){
        if(x==parent||vis[x]) continue;
        dfs_reset(x,node);
    }
}
ll decent(int node){
    dfs_sz(node,0);
    int cent=dfs_cent(node,0,sz[node]);
    dfs_dep(cent,-1);
    cnt[0]++;
    ll ans=0;
    for(auto x:graph[cent]){
        if(vis[x]) continue;
        ans+=dfs_calc_ans(x,cent);
        dfs_build_cnt(x,cent);
    }
    dfs_reset(cent,0);
    vis[cent]=1;
    for(auto x:graph[cent]){
        if(vis[x]) continue;
        ans+=decent(x);
    }
    return ans;
}
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    cin>>n>>k;
    graph.resize(n+1);
    int a,b;
    for(int i=1;i<n;i++){
        cin>>a>>b;
        graph[a].push_back(b);
        graph[b].push_back(a);
    }
    cout<<decent(1)<<"\n";
}

#include<iostream>
#include<vector>
#include<algorithm>
#include<utility>
#include<map>
using namespace std;
map<vector<int>,int> m;
int cnt;
struct iso{
    vector<vector<int> > graph;
    int n;
    vector<int> id;
    iso(int _n){
        n=_n;
        cnt=0;
        graph.resize(n+1);
        id.resize(n+1);
        int a,b;
        for(int i=1;i<n;i++){
            cin>>a>>b;
            graph[a].push_back(b);
            graph[b].push_back(a);
        }
    }
    int dfs(int node,int parent){
        vector<int> children;
        for(auto x:graph[node]){
            if(x==parent) continue;
            children.push_back(dfs(x,node));
        }
        sort(children.begin(),children.end());
        if(m.count(children)) return m[children];
        else{
            m[children]=++cnt;
            return cnt;
        }
    }
    int get_id(){
        return dfs(1,0);
    }
};
int main(){
    ios::sync_with_stdio(false);
    cin.tie(0);
    int t;
    cin>>t;
    while(t--){
        int n;
        cin>>n;
        m.clear();
        cnt=0;
        iso a=iso(n),b=iso(n);
        if(a.get_id()==b.get_id()) cout<<"YES\n";
        else cout<<"NO\n";
    }