#include <bits/stdc++.h>

using namespace std;

const int N = 2024; // No Corona those days, I hope

vector<int> g[N];

int pv[N];
int dep[N];

void dfs(int v, int p = -1) {
  pv[v] = p;
  for (int to : g[v]) {
    if (to != p) {
      dep[to] = dep[v] + 1;
      dfs(to, v);
    }
  }
}

int have[N][N];
int walk[N][N];

void del(int a, int b) {
  --have[a][b];
  --have[b][a];
}

void add(int a, int b) {
  ++have[a][b];
  ++have[b][a];
}

void dir(int a, int b) {
  del(a, b);
  ++walk[a][b];
}

bool mark[N];
int deg[N];
int n, m;

void Solve() {
  int leaf = -1;
  for (int i = 0; i < n; i++) {
    if (!mark[i] && deg[i] == 1) {
      leaf = i;
      break;
    }
  }
  if (leaf == -1) {
    for (int i = 0; i < n; i++) {
      if (!mark[i]) {
        mark[i] = true;
        while (have[i][i]) {
          dir(i, i);
        }
      }
    }
    return;
  }
  mark[leaf] = true;
  int other = -1;
  for (int x : g[leaf]) {
    if (!mark[x]) {
      other = x;
      break;
    }
  }
  assert(other != -1);
  --deg[other];
  int a = -1, b = -1;
  vector<int> vec;
  for (int i = 0; i < n; i++) {
    if (mark[i]) continue;
    if (have[i][leaf]) {
      a = (a == -1 ? i : a);
      b = i;
      vec.emplace_back(i);
    }
  }
  if (a == b && have[a][leaf] == 1) {
    a = -1;
  }
  while (have[leaf][leaf]) {
    dir(leaf, leaf);
  }
  if (a != -1 && b != -1) {
    del(a, leaf);
    del(b, leaf);
    add(a, b);
  } else if (b != -1) {
    del(b, leaf);
    add(b, other);
  }
  vector<int> done;
  for (int x : vec) {
    while (have[leaf][x]) {
      del(leaf, x);
      add(other, x);
      done.push_back(x);
    }
  }
  Solve();
  ++deg[other];
  for (int x : done) {
    if (walk[other][x]) {
      --walk[other][x];
      ++walk[leaf][x];
    } else if (walk[x][other]) {
      --walk[x][other];
      ++walk[x][leaf];
    } else {
      throw;
    }
  }
  if (a != -1 && b != -1) {
    if (walk[a][b]) {
      --walk[a][b];
      ++walk[a][leaf];
      ++walk[leaf][b];
    } else if (walk[b][a]) {
      --walk[b][a];
      ++walk[b][leaf];
      ++walk[leaf][a];
    } else {
      throw;
    }
  } else if (b != -1) {
    if (walk[b][other]) {
      --walk[b][other];
      ++walk[b][leaf];
    } else if (walk[other][b]) {
      --walk[other][b];
      ++walk[leaf][b];
    } else {
      throw;
    }
  }
}

int main() {
  ios::sync_with_stdio(false);
  cin.tie(0);
  cin >> n >> m;
  for (int i = 0; i < n - 1; ++i) {
    int x, y;
    cin >> x >> y;
    --x; --y;
    g[x].push_back(y);
    g[y].push_back(x);
    ++deg[x];
    ++deg[y];
  }
  dfs(0);
  vector<int> cnt(n);
  vector<pair<int, int>> sched;
  for (int i = 0; i < m; i++) {
    int x, y;
    cin >> x >> y;
    --x; --y;
    sched.emplace_back(x, y);
    add(x, y);
    while (x != y) {
      if (dep[x] < dep[y]) {
        swap(x, y);
      }
      ++cnt[x];
      x = pv[x];
    }
  }
  Solve();
  int ans = 0;
  for (int i = 0; i < n; i++) {
    ans += min(2, cnt[i]);
  }
  cout << ans << '\n';
  for (int i = 0; i < m; i++) {
    int x = sched[i].first;
    int y = sched[i].second;
    if (walk[x][y] > 0) {
      --walk[x][y];
      cout << x + 1 << " " << y + 1 << '\n';
    } else {
      --walk[y][x];
      cout << y + 1 << " " << x + 1 << '\n';
    }
  }
  return 0; // :)
}


Measured memory_bytes: 30904