ll dfs(vector<int> tree[],int now,int par){
	vector<ll> tmp;
	for(auto nxt:tree[now]){
		if(nxt == par)continue;
		tmp.push_back(dfs(tree,nxt,now));
	}
	sort(tmp.rbegin(),tmp.rend());
	ll re = 1;
	for(auto &i:tmp){
		re*= p;
		re += i;
		re %= mod;
	}
	return re;
}

map<vector<int>,int> mp;
int idx = 0;
void dfs1(int now,int par){
    vector<int> tmp;
    for(auto nxt:tree[now]){
        if(nxt == par)continue;
        dfs1(nxt,now);
        tmp.push_back(dp[nxt]);
    }
    sort(tmp.begin(),tmp.end());
    if(!mp[tmp]){
        dp[now] = mp[tmp] = ++idx;
    }
    else dp[now] = mp[tmp];
    return;
}

const int mxn = 303;
vector<int> tree[mxn];
int dp[mxn][mxn]
void dfs(int now,int par){
    for(auto nxt:tree[now]){
        if(nxt == par)continue;
        dfs(nxt,now);
        for(int i = mxn-1;i>=2;i--){
            for(int j = 1;j<i;j++){
                dp[now][i] = max(dp[now][i],dp[now][i-j]+dp[nxt][j]);
            }
        }
    }
}

const int mxn = 1010;
vector<int> tree[mxn];
int dp[mxn][mxn];
int sz[mxn];
 
void dfs(int now,int par){
    sz[now] = 1;
    for(auto nxt:tree[now]){
        if(nxt == par)continue;
        dfs(nxt,now);
        sz[now] += sz[nxt];
        for(int i = sz[now];i>=2;i--){
            for(int j = max(i-sz[now]+sz[nxt],0);j<=min(i-1,sz[nxt]);j++){
                dp[now][i] = max(dp[now][i],dp[now][i-j]+dp[nxt][j]);
            }
        }
    }
}

const int mxn = 1010;
vector<int> tree[mxn];
int dp[mxn][mxn];
int sz[mxn];
 
void dfs(int now,int par){
    sz[now] = 1;
    for(auto nxt:tree[now]){
        if(nxt == par)continue;
        dfs(nxt,now);
        for(int i = sz[now];i>=2;i--){
            for(int j = 1;j<=sz[nxt];j++){
                dp[now][i+j] = max(dp[now][i+j],dp[now][i]+dp[nxt][j]);
            }
        }
        sz[now] += sz[nxt];
    }
}

#include <bits/stdc++.h>
using namespace std;
const int mxn = 2e5+10;
int childs[mxn][2];
int par[mxn];
bool get(int id){
    if(!id||!par[id])return 0;
    if(childs[par[id]][0] == id)return 0;
    else if(childs[par[id]][1] == id)return 1;
    else{
    cout<<"ERROR "<<id<<endl;
    return 0;
    }
}
void rotate(int id){
    push(par[id]);
    push(id);
    int lr = get(id);
    int p = par[id];
    int g = par[par[id]];
    childs[g][get(p)] = id;
    par[id] = g;
    childs[p][lr] = childs[id][lr^1];
    par[childs[id][lr^1]] = p;
    childs[id][lr^1] = p;
    par[p] = id;//注意pull的順序
    pull(p);
    pull(id);
    pull(g);
    return;
}

    void splay(int id){
        if(!id)return;
        while(par[id]){
            if(par[par[id]])push(par[par[id]]);
            push(par[id]);
            push(id);
            if(!par[par[id]]){
                rotate(id);
                return;
            }
            if(get(par[id]) == get(id))rotate(par[id]);
            else rotate(id);
            rotate(id);
        }
    }

    void merge(int a,int b){
         if(!a||!b)return;
         splay(a);
         splay(b);
         push(a);
         push(b);
         while(childs[a][1]){
            a = childs[a][1];
            push(a);
         }
         while(childs[b][0]){
            b = childs[b][0];
            push(b);
         }
         splay(a);
         push(a);
         splay(b);
         childs[a][1] = b;
         par[b] = a;
         pull(a);
         return;
    }

    int find(int head,int k){
        if(!k)return 0;
        splay(head);
        while(head&&k){
            push(head);
            int ls = childs[head][0],rs = childs[head][1];
            if(sz[ls]+1 == k){
                splay(head);
                return head;
            }
            else if(sz[ls]+1<k){
                k -= sz[ls]+1;
                head = rs;
            }
            else head = ls;
        }
        splay(head);
        return head;
    }

    pair<int,int> split(int head,int k){
        if(k == 0){
            splay(head);
            return make_pair(0,head);
        }
        head = find(head,k);
        splay(head);
        int tmp = childs[head][1];
        childs[head][1] = par[tmp] = 0;
        pull(tmp);
        pull(head);
        return make_pair(head,tmp);
    }

    void makeroot(int now){
        access(now);
        splay(now);
        rev[now] ^=1;
        return;
    }

    int findroot(int now){
        access(now);
        splay(now);
        while(childs[now][0])now = childs[now][0];
        return now;
    }

    void link(int a,int b){
        if(findroot(a) == findroot(b))return;
        edges.insert({min(a,b),max(a,b)});
        makeroot(a);
        makeroot(b);
        par[b] = a;
    }

    void cut(int a,int b){
        if(findroot(a) != findroot(b))return;
        if(a>b)swap(a,b);
        if(edges.find({a,b}) == edges.end())return;
        edges.erase({a,b});
        makeroot(a);
        access(b);
        splay(b);
        par[childs[b][0]] = 0;
        childs[b][0] = 0;
        pull(b);
        return;
    }