#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


constexpr int MAX = 1010;

int N, M;
vector<int> A[2], B[2];

bitset<MAX> adj[2][MAX];

vector<pair<pair<int, int>, pair<int, int>>> ops[2];
void ae(int h, int a, int b) {
  adj[h][a].set(b);
  adj[h][b].set(a);
}
void re(int h, int a, int b) {
  adj[h][a].reset(b);
  adj[h][b].reset(a);
}
void oper(int h, int a, int b, int c, int d) {
  assert(adj[h][a][b]);
  assert(adj[h][c][d]);
  assert(!adj[h][a][c]);
  assert(!adj[h][b][d]);
  re(h, a, b);
  re(h, c, d);
  ae(h, a, c);
  ae(h, b, d);
  ops[h].emplace_back(make_pair(a, b), make_pair(c, d));
}

int main() {
  for (; ~scanf("%d%d", &N, &M); ) {
    for (int h = 0; h < 2; ++h) {
      A[h].resize(M);
      B[h].resize(M);
      for (int i = 0; i < M; ++i) {
        scanf("%d%d", &A[h][i], &B[h][i]);
        --A[h][i];
        --B[h][i];
      }
    }
    
    vector<int> deg[2];
    for (int h = 0; h < 2; ++h) {
      deg[h].assign(N, 0);
      for (int i = 0; i < M; ++i) {
        ++deg[h][A[h][i]];
        ++deg[h][B[h][i]];
      }
    }
    if (deg[0] == deg[1]) {
      for (int h = 0; h < 2; ++h) {
        for (int u = 0; u < N; ++u) adj[h][u].reset();
        for (int i = 0; i < M; ++i) {
          ae(h, A[h][i], B[h][i]);
        }
      }
      for (int u = N; --u >= 0; ) {
        vector<int> vss[2];
        for (int v = 0; v < u; ++v) {
          if (adj[0][u][v] && !adj[1][u][v]) vss[0].push_back(v);
          if (!adj[0][u][v] && adj[1][u][v]) vss[1].push_back(v);
        }
        assert(vss[0].size() == vss[1].size());
        for (int j = 0; j < (int)vss[0].size(); ++j) {
          const int v0 = vss[0][j];
          const int v1 = vss[1][j];
          {
            const auto tmp = ~adj[0][v0] & adj[0][v1];
            int w = tmp._Find_first();
            if (w == v0) w = tmp._Find_next(w);
            if (w < u) {
              oper(0, u, v0, v1, w);
              continue;
            }
          }
          {
            const auto tmp = adj[1][v0] & ~adj[1][v1];
            int w = tmp._Find_first();
            if (w == v1) w = tmp._Find_next(w);
            if (w < u) {
              oper(1, u, v1, v0, w);
              continue;
            }
          }
          assert(false);
        }
      }
      reverse(ops[1].begin(), ops[1].end());
      printf("%d\n", (int)ops[0].size() + (int)ops[1].size());
      for (const auto &op : ops[0]) printf("%d %d %d %d\n", op.first.first + 1, op.first.second + 1, op.second.first + 1, op.second.second + 1);
      for (const auto &op : ops[1]) printf("%d %d %d %d\n", op.first.first + 1, op.second.first + 1, op.first.second + 1, op.second.second + 1);
    } else {
      puts("-1");
    }
  }
  return 0;
}