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 h[2010],nex[4010],to[4010],dep[2010],fa[2010],fav[2010],M;
void add(int a,int b){ M++; to[M]=b; nex[M]=h[a]; h[a]=M; }
void dfs(int x){ dep[x]=dep[fa[x]]+1; for(int i=h[x];i;i=nex[i]){ if(to[i]!=fa[x]){ fa[to[i]]=x; dfs(to[i]); } } }
void col(int x,int y){ if(dep[x]<dep[y])swap(x,y); while(dep[x]>dep[y]){ fav[x]++; x=fa[x]; } while(x!=y){ fav[x]++; fav[y]++; x=fa[x]; y=fa[y]; } }
struct rt{ int x,y; rt(int a=0,int b=0){x=a;y=b;} };
bool operator==(rt a,rt b){return a.x==b.x&&a.y==b.y;}
int d[2010],n;
vector<rt>solve(vector<rt>v){
    if(v.size()==0)return v;
    int x,u,i; for(x=1;x<=n;x++){ if(d[x]==1)break; }
    if(x>n)return v;
    for(i=h[x];i;i=nex[i]){ if(d[to[i]]){ u=to[i]; break; } }
    d[x]--; d[u]--; vector<rt>lx,nv; vector<int>id; int pos[2010];
    memset(pos,-1,sizeof(pos));
    for(i=0;i<(int)v.size();i++){ if(v[i].x==x||v[i].y==x){ lx.push_back(v[i]); id.push_back(i); }else{ nv.push_back(v[i]); pos[i]=nv.size()-1; } }
    if(lx.size()==0)return solve(v);
    for(i=0;i+1<(int)lx.size();i+=2){
        if(lx[i].y==x)swap(lx[i].x,lx[i].y); if(lx[i+1].y==x)swap(lx[i+1].x,lx[i+1].y);
        if(lx[i]==lx[i+1]){ if(v[id[i]]==v[id[i+1]])swap(v[id[i]].x,v[id[i]].y); continue; }
        nv.push_back(rt(lx[i].y,lx[i+1].y)); pos[id[i]]=pos[id[i+1]]=nv.size()-1;
    }
    if(lx.size()&1){
        if(lx[lx.size()-1].y==x)swap(lx[lx.size()-1].x,lx[lx.size()-1].y);
        if(lx[lx.size()-1].y!=u){ nv.push_back(rt(u,lx[lx.size()-1].y)); pos[id[lx.size()-1]]=nv.size()-1; }
    }
    nv=solve(nv); for(i=0;i<(int)v.size();i++){ if(pos[i]!=-1&&!(v[i].x==nv[pos[i]].x||v[i].y==nv[pos[i]].y))swap(v[i].x,v[i].y); }
    return v;
}
vector<rt>v;
int main(){
    int m,i,x,y,ans; scanf("%d%d",&n,&m);
    for(i=1;i<n;i++){ scanf("%d%d",&x,&y); add(x,y); add(y,x); d[x]++; d[y]++; }
    dfs(1); for(i=1;i<=m;i++){ scanf("%d%d",&x,&y); v.push_back(rt(x,y)); col(x,y); } v=solve(v);
    ans=0; for(i=2;i<=n;i++)ans+=min(2,fav[i]); printf("%d\n",ans);
    for(rt t:v)printf("%d %d\n",t.x,t.y);
}