Problem: Takahashi loves walking on a tree. The tree where Takahashi walks has N vertices numbered 1 through N. The i-th of the N-1 edges connects Vertex a_i and Vertex b_i.

Takahashi has scheduled M walks. The i-th walk is done as follows:

* The walk involves two vertices u_i and v_i that are fixed beforehand.
* Takahashi will walk from u_i to v_i or from v_i to u_i along the shortest path.



The happiness gained from the i-th walk is defined as follows:

* The happiness gained is the number of the edges traversed during the i-th walk that satisfies one of the following conditions:
* In the previous walks, the edge has never been traversed.
* In the previous walks, the edge has only been traversed in the direction opposite to the direction taken in the i-th walk.



Takahashi would like to decide the direction of each walk so that the total happiness gained from the M walks is maximized. Find the maximum total happiness that can be gained, and one specific way to choose the directions of the walks that maximizes the total happiness.

Constraints

* 1 ≤ N,M ≤ 2000
* 1 ≤ a_i , b_i ≤ N
* 1 ≤ u_i , v_i ≤ N
* a_i \neq b_i
* u_i \neq v_i
* The graph given as input is a tree.

Input

Input is given from Standard Input in the following format:


N M
a_1 b_1
:
a_{N-1} b_{N-1}
u_1 v_1
:
u_M v_M


Output

Print the maximum total happiness T that can be gained, and one specific way to choose the directions of the walks that maximizes the total happiness, in the following format:


T
u^'_1 v^'_1
:
u^'_M v^'_M


where (u^'_i,v^'_i) is either (u_i,v_i) or (v_i,u_i), which means that the i-th walk is from vertex u^'_i to v^'_i.

Examples

Input

4 3
2 1
3 1
4 1
2 3
3 4
4 2


Output

6
2 3
3 4
4 2


Input

5 3
1 2
1 3
3 4
3 5
2 4
3 5
1 5


Output

6
2 4
3 5
5 1


Input

6 4
1 2
2 3
1 4
4 5
4 6
2 4
3 6
5 6
4 5


Output

9
2 4
6 3
5 6
4 5

Solution (in CPP):

Solution:
#include<bits/stdc++.h>
using namespace std;

int n, m, si[2020], ti[2020];

int dep[2020], fa[2020], vis[2020];
vector<int>G[2020], pa[2020], pb[2020], cov[2020];
int las[2020], die[2020];

void dfs(int x,int fff){
    dep[x]=dep[fff]+1; fa[x]=fff;
    for (auto y:G[x])
        if (y!=fff) dfs(y,x);
}

int main(){
    cin>>n>>m;
    for (int i=1;i<n;++i){
        int x, y; cin>>x>>y;
        G[x].push_back(y);
        G[y].push_back(x);
    }
    dfs(1,0);
    for (int i=1;i<=m;++i){
        cin>>si[i]>>ti[i];
        int x=si[i], y=ti[i];
        while (x!=y){
            if (dep[x]>dep[y]){
                pa[i].push_back(x);
                cov[x].push_back(i);
                x=fa[x];
            }else{
                pb[i].push_back(y);
                cov[y].push_back(-i);
                y=fa[y];
            }
        }
    }
    int ans=0;
    for (int i=1;i<=n;++i){
        las[i]=cov[i].size();
        ans+=min(las[i],2);
    }
    for (int p;;){
        for (p=2;p<=n&&!(las[p]==1&&__builtin_popcount(vis[p])==1);++p);
        if (p>n){
            for (p=2;p<=n&&las[p]==0;++p);
            if (p>n) break;
        }
        while (cov[p].size()&&die[abs(cov[p].back())]) cov[p].pop_back();
        int i=cov[p].back(), rev=i<0;
        die[i=abs(i)]=1;
        if (las[p]<0) exit(0);
        if (vis[p]==1) rev^=1;
        if (rev) swap(si[i],ti[i]);
        for (auto o:pa[i]) vis[o]|=1<<(rev), --las[o];
        for (auto o:pb[i]) vis[o]|=1<<(rev+1)%2, --las[o];
    }
    cout<<ans<<endl;
    for (int i=1;i<=m;++i)
        cout<<si[i]<<' '<<ti[i]<<endl;
}