#include <bits/stdc++.h>
using ll = long long;
using ull = unsigned long long;
using uint = unsigned int;
using ld = long double;
using vi = std::vector<int>;
using pii = std::pair<int, int>;
using vvi = std::vector<vi>;
using vii = std::vector<pii>;
template <typename T>
int sign(const T& t) {
  return (t > 0) - (t < 0);
}
template <typename T>
bool remax(T& a, T b) {
  if (a < b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
bool remin(T& a, T b) {
  if (a > b) {
    a = b;
    return true;
  }
  return false;
}
template <typename T>
T gcd(T a, T b) {
  a = std::abs(a);
  b = std::abs(b);
  while (b) {
    a %= b;
    std::swap(a, b);
  }
  return a;
}
template <typename T>
T lcm(T a, T b) {
  a = std::abs(a);
  b = std::abs(b);
  return a / gcd(a, b) * b;
}
double get_time() { return static_cast<double>(clock()) / CLOCKS_PER_SEC; }
uint32_t mrand_32t() {
  static std::random_device rd;
  static std::mt19937 rng(rd());
  return rng();
}
uint64_t mrand_64t() {
  static std::random_device rd;
  static std::mt19937_64 rng(rd());
  return rng();
}
template <typename T>
void make_unique(std::vector<T>& v) {
  std::sort(std::begin(v), std::end(v));
  v.erase(std::unique(std::begin(v), std::end(v)), std::end(v));
}
template <typename T>
std::ostream& operator<<(std::ostream& os, const std::vector<T>& vec) {
  os << "{ ";
  bool first = true;
  for (const auto& it : vec) {
    if (!first) {
      os << ", ";
    }
    os << it;
    first = false;
  }
  os << " }";
  return os;
}
template <typename T>
std::ostream& operator<<(std::ostream& os, const std::set<T>& s) {
  os << "{ ";
  bool first = true;
  for (const auto& it : s) {
    if (!first) {
      os << ", ";
    }
    os << it;
    first = false;
  }
  os << " }";
  return os;
}
template <typename K, typename V>
std::ostream& operator<<(std::ostream& os, const std::map<K, V>& m) {
  os << "{"
     << "\n";
  for (const auto& it : m) {
    os << " " << it.first << " -> " << it.second << "\n";
  }
  os << "}"
     << "\n";
  return os;
}
void debug_out() { std::cerr << std::endl; }
template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  std::cerr << " " << H;
  debug_out(T...);
}
using namespace std;
const int MAXN = 50 + 5;
int n, m;
int who[MAXN][MAXN];
pii dest[MAXN];
bool read() {
  memset(who, -1, sizeof who);
  if (!(cin >> n)) {
    return 0;
  }
  cin >> m;
  for (int i = int(0); i < int(m); ++i) {
    int x, y;
    cin >> x >> y;
    --x;
    --y;
    who[x][y] = i;
  }
  for (int i = int(0); i < int(m); ++i) {
    int x, y;
    cin >> x >> y;
    --x;
    --y;
    dest[i] = make_pair(x, y);
  }
  return 1;
}
const int dx[4] = {1, -1, 0, 0};
const int dy[4] = {0, 0, 1, -1};
bool on(int x, int y) { return 0 <= x && x < n && 0 <= y && y < n; }
struct Move {
  pii from;
  pii to;
  void print() const {
    cout << from.first + 1 << " " << from.second + 1 << " " << to.first + 1
         << " " << to.second + 1 << "\n";
  }
};
vector<Move> ans;
void make_move(pii from, pii to) {
  assert(on(from.first, from.second));
  assert(on(to.first, to.second));
  ans.push_back(Move{from, to});
  assert(who[to.first][to.second] == -1);
  swap(who[from.first][from.second], who[to.first][to.second]);
}
int dist[MAXN][MAXN];
pii prev___[MAXN][MAXN];
void move_someone(int X, int Y) {
  assert(X == 0);
  memset(dist, -1, sizeof dist);
  for (int y = int(0); y < int(Y); ++y) {
    dist[0][y] = 0;
  }
  dist[X][Y] = 0;
  queue<pii> q;
  q.push(make_pair(X, Y));
  pii from(-1, -1);
  while (!q.empty()) {
    int x, y;
    tie(x, y) = q.front();
    q.pop();
    if (who[x][y] != -1) {
      from = make_pair(x, y);
      break;
    }
    for (int d = int(0); d < int(4); ++d) {
      int nx = x + dx[d];
      int ny = y + dy[d];
      if (on(nx, ny) && dist[nx][ny] == -1) {
        dist[nx][ny] = dist[x][y] + 1;
        prev___[nx][ny] = make_pair(x, y);
        q.push(make_pair(nx, ny));
      }
    }
  }
  assert(from.first != -1);
  int cnt = dist[from.first][from.second];
  while (from != make_pair(X, Y)) {
    pii nxt = prev___[from.first][from.second];
    make_move(from, nxt);
    from = nxt;
    --cnt;
  }
  assert(cnt == 0);
}
void print() {
  return;
  for (int y = int(n) - 1; y >= int(0); --y) {
    for (int x = int(0); x < int(n); ++x) {
      if (false) cerr << who[x][y] << " ";
    }
    if (false) cerr << endl;
  }
  if (false) cerr << endl;
}
void solve() {
  if (n == 1) {
    cout << 0 << endl;
    return;
  }
  ans.clear();
  for (int i = int(0); i < int(m); ++i) {
    move_someone(0, i);
  }
  vi perm(m);
  iota(begin(perm), end(perm), 0);
  sort(begin(perm), end(perm), [&](int i, int j) {
    int xi, yi;
    tie(xi, yi) = dest[i];
    int xj, yj;
    tie(xj, yj) = dest[j];
    if (xi != xj) {
      return xi < xj;
    }
    return yi < yj;
  });
  for (int i = int(0); i < int(m); ++i) {
    int y0 = -1;
    for (int y = int(0); y < int(m); ++y) {
      if (who[0][y] == perm[i]) {
        y0 = y;
        break;
      }
    }
    assert(y0 != -1);
    assert(y0 >= i);
    make_move(make_pair(0, y0), make_pair(1, y0));
    for (int y = y0 - 1; y >= i; --y) {
      make_move(make_pair(1, y + 1), make_pair(1, y));
    }
    for (int y = y0 - 1; y >= i; --y) {
      make_move(make_pair(0, y), make_pair(0, y + 1));
    }
    make_move(make_pair(1, i), make_pair(0, i));
  }
  for (int i = int(0); i < int(m); ++i) {
    assert(who[0][i] == perm[i]);
  }
  const auto final = [&](int i) {
    int X, Y;
    tie(X, Y) = dest[perm[i]];
    if (X == 0) {
      assert(Y >= i);
      for (int y = i; y < Y; ++y) {
        make_move(make_pair(0, y), make_pair(0, y + 1));
      }
      return;
    }
    make_move(make_pair(0, i), make_pair(1, i));
    if (Y > i) {
      for (int y = i; y < Y; ++y) {
        make_move(make_pair(1, y), make_pair(1, y + 1));
      }
    } else {
      for (int y = i; y > Y; --y) {
        make_move(make_pair(1, y), make_pair(1, y - 1));
      }
    }
    for (int x = 1; x < X; ++x) {
      make_move(make_pair(x, Y), make_pair(x + 1, Y));
    }
  };
  for (int i = m - 1, j = m - 1; i >= 0; i = j) {
    while (j >= 0 && dest[who[0][i]].first == dest[who[0][j]].first) {
      --j;
    }
    int l = j + 1;
    int r = i;
    while (l <= r) {
      if (dest[who[0][l]].second <= l) {
        final(l);
        ++l;
      } else {
        assert(dest[who[0][r]].second >= r);
        final(r);
        --r;
      }
    }
  }
  vi ok(m);
  for (int x = int(0); x < int(n); ++x)
    for (int y = int(0); y < int(n); ++y) {
      if (who[x][y] != -1) {
        assert(dest[who[x][y]] == make_pair(x, y));
        ok[who[x][y]] = 1;
      }
    }
  assert(*min_element(begin(ok), end(ok)) > 0);
  cout << int((ans).size()) << endl;
  for (const auto& a : ans) {
    a.print();
  }
}
int main() {
  cin.tie(nullptr);
  ios_base::sync_with_stdio(false);
  cout.tie(nullptr);
  cout.precision(12);
  cout << fixed;
  while (read()) {
    solve();
  }
  return 0;
}
