#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <ctime>
#include <cassert>
#include <string.h>
//#include <unordered_set>
//#include <unordered_map>
//#include <bits/stdc++.h>

#define MP(A,B) make_pair(A,B)
#define PB(A) push_back(A)
#define SIZE(A) ((int)A.size())
#define LEN(A) ((int)A.length())
#define FOR(i,a,b) for(int i=(a);i<(b);++i)
#define fi first
#define se second

using namespace std;

template<typename T>inline bool upmin(T &x,T y) { return y<x?x=y,1:0; }
template<typename T>inline bool upmax(T &x,T y) { return x<y?x=y,1:0; }

typedef long long ll;
typedef unsigned long long ull;
typedef long double lod;
typedef pair<int,int> PR;
typedef vector<int> VI;

const lod eps=1e-11;
const lod pi=acos(-1);
const int oo=1<<30;
const ll loo=1ll<<62;
const int mods=998244353;
const int MAXN=4005;
const int INF=0x3f3f3f3f;//1061109567
/*--------------------------------------------------------------------*/
inline int read()
{
	int f=1,x=0; char c=getchar();
	while (c<'0'||c>'9') { if (c=='-') f=-1; c=getchar(); }
	while (c>='0'&&c<='9') { x=(x<<3)+(x<<1)+(c^48); c=getchar(); }
	return x*f;
}
struct rt
{
    int x,y;
    rt(int a=0,int b=0) { x=a;y=b; }
};
int d[MAXN],head[MAXN],nxt[MAXN],to[MAXN],dep[MAXN],fa[MAXN],fav[MAXN],edgenum,n;
void add(int a,int b) { edgenum++,to[edgenum]=b,nxt[edgenum]=head[a],head[a]=edgenum; }
void dfs(int x)
{
	dep[x]=dep[fa[x]]+1;
	for (int i=head[x];i;i=nxt[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];
}
bool operator == (rt a,rt b) { return a.x==b.x&&a.y==b.y; }
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=head[x];i;i=nxt[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()) 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;
    n=read(),m=read();
    for(int i=1;i<n;i++)
    {
    	int x=read(),y=read();
        add(x,y),add(y,x);
        d[x]++,d[y]++;
    }
    dfs(1);
    for(int i=1;i<=m;i++)
	{
    	int x=read(),y=read();
        v.push_back(rt(x,y));
        col(x,y);
    }
    v=solve(v);
    ans=0;
    for(int 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);
}

Measured memory_bytes: 56064