#include <bits/stdc++.h>
using namespace std;
const int INF = (int)1E9;
int n, m;
int sx[55], sy[55], ex[55], ey[55];
int host[55][55], cnt[55], board[55][55];
pair<int, int> loc[55];
struct Move {
  int x1, y1, x2, y2;
  Move(int _x1, int _y1, int _x2, int _y2) {
    x1 = _x1;
    y1 = _y1;
    x2 = _x2;
    y2 = _y2;
  }
};
int dst[55][55];
pair<int, int> pre[55][55];
int dir[4][2] = {-1, 0, 1, 0, 0, 1, 0, -1};
void bfs(int xs, int ys) {
  queue<pair<int, int> > q;
  for (int i = (1); i < (n + 1); i++)
    for (int j = (1); j < (n + 1); j++) dst[i][j] = INF;
  dst[xs][ys] = 0;
  q.push(pair<int, int>(xs, ys));
  while (q.size()) {
    pair<int, int> now = q.front();
    q.pop();
    int x = now.first, y = now.second;
    for (int d = (0); d < (4); d++) {
      int nx = dir[d][0] + x, ny = dir[d][1] + y;
      if (nx < 1 || ny < 1 || nx > n || ny > n || board[nx][ny] > 0 ||
          dst[nx][ny] != INF)
        continue;
      dst[nx][ny] = dst[x][y] + 1;
      pre[nx][ny] = pair<int, int>(x, y);
      q.push(pair<int, int>(nx, ny));
    }
  }
}
bool possible(int xs, int ys, int xe, int ye) {
  bfs(xs, ys);
  return dst[xe][ye] != INF;
}
vector<Move> moveTo(int xs, int ys, int xe, int ye) {
  vector<Move> sol;
  while (xe != xs || ye != ys) {
    int px = pre[xe][ye].first, py = pre[xe][ye].second;
    sol.push_back(Move(px, py, xe, ye));
    xe = px;
    ye = py;
  }
  reverse(sol.begin(), sol.end());
  return sol;
}
void append(vector<Move> &ans, vector<Move> &sol) {
  ans.insert(ans.end(), sol.begin(), sol.end());
}
bool moved[55];
bool notYet() {
  for (int i = (1); i < (m + 1); i++)
    if (loc[i] != pair<int, int>(ex[i], ey[i])) return true;
  return false;
}
void relocate(int c, int x, int y) {
  int cx = loc[c].first, cy = loc[c].second;
  swap(board[cx][cy], board[x][y]);
  loc[c] = pair<int, int>(x, y);
}
void print(int b[55][55]) {
  for (int i = (1); i < (n + 1); i++) {
    for (int j = (1); j < (n + 1); j++) cerr << b[i][j];
    cerr << endl;
  }
  cerr << "-" << endl;
}
int main() {
  cin >> n >> m;
  for (int i = (1); i < (m + 1); i++) {
    cin >> sx[i] >> sy[i];
    board[sx[i]][sy[i]] = i;
    loc[i] = pair<int, int>(sx[i], sy[i]);
  }
  for (int i = (1); i < (m + 1); i++) {
    cin >> ex[i] >> ey[i];
    host[ex[i]][ey[i]] = i;
  }
  for (int i = (1); i < (n + 1); i++) {
    for (int j = (1); j < (n + 1); j++) cnt[i] += host[i][j] != 0;
  }
  vector<pair<pair<int, int>, int> > rowCnt;
  for (int i = (1); i < (n + 1); i++) {
    int before = i - 1 >= 1 ? cnt[i - 1] : n;
    int after = i + 1 <= n ? cnt[i + 1] : n;
    rowCnt.push_back(make_pair(pair<int, int>(cnt[i], before + after), i));
  }
  sort(rowCnt.begin(), rowCnt.end());
  int row = rowCnt[0].second;
  cerr << "row " << row << endl;
  memset(moved, false, sizeof(moved));
  vector<Move> ans;
  for (int col = (1); col < (m + 1); col++) {
    bool noMove = true;
    for (int c = (1); c < (m + 1); c++) {
      if (moved[c]) continue;
      int x = loc[c].first, y = loc[c].second;
      if (possible(x, y, row, col)) {
        vector<Move> sol = moveTo(x, y, row, col);
        append(ans, sol);
        relocate(c, row, col);
        moved[c] = true;
        noMove = false;
        break;
      }
    }
    if (noMove) cerr << "?";
  }
  vector<int> fillOrder;
  for (int i = (1); i < (row); i++) fillOrder.push_back(i);
  for (int i = n; i > row; i--) fillOrder.push_back(i);
  for (int fi = (0); fi < (n - 1); fi++) {
    int i = fillOrder[fi];
    for (int j = (1); j < (n + 1); j++) {
      if (host[i][j] > 0) {
        int c = host[i][j], x = loc[c].first, y = loc[c].second;
        if (possible(x, y, i, j)) {
          vector<Move> sol = moveTo(x, y, i, j);
          append(ans, sol);
          relocate(c, i, j);
        }
      }
    }
  }
  vector<int> onr;
  for (int col = (1); col < (n + 1); col++)
    if (board[row][col] > 0) onr.push_back(board[row][col]);
  int K = onr.size();
  srand(99937);
  while (notYet()) {
    vector<pair<int, int> > es;
    for (int i = (1); i < (n + 1); i++)
      for (int j = (1); j < (n + 1); j++)
        if (i != row && !board[i][j]) es.push_back(pair<int, int>(i, j));
    random_shuffle(es.begin(), es.end());
    vector<pair<int, int> > origin, originFin;
    vector<int> finC;
    bool failed = false;
    for (int i = (0); i < (K); i++) {
      int c = onr[i], x = loc[c].first, y = loc[c].second;
      if (possible(x, y, es[i].first, es[i].second)) {
        origin.push_back(pair<int, int>(x, y));
        relocate(c, es[i].first, es[i].second);
      } else {
        failed = true;
        break;
      }
    }
    if (failed) {
      for (int i = (0); i < (origin.size()); i++)
        relocate(onr[i], origin[i].first, origin[i].second);
      continue;
    }
    for (int col = (1); col < (n + 1); col++) {
      if (host[row][col] > 0) {
        int c = host[row][col], x = loc[c].first, y = loc[c].second;
        if (possible(x, y, row, col)) {
          relocate(c, row, col);
          finC.push_back(c);
          originFin.push_back(pair<int, int>(x, y));
        } else {
          failed = true;
          break;
        }
      }
    }
    if (failed) {
      for (int i = (0); i < (originFin.size()); i++)
        relocate(finC[i], originFin[i].first, originFin[i].second);
      for (int i = (0); i < (origin.size()); i++)
        relocate(onr[i], origin[i].first, origin[i].second);
      continue;
    }
    for (int i = (0); i < (originFin.size()); i++)
      relocate(finC[i], originFin[i].first, originFin[i].second);
    for (int i = (0); i < (origin.size()); i++)
      relocate(onr[i], origin[i].first, origin[i].second);
    for (int i = (0); i < (K); i++) {
      int c = onr[i];
      bfs(loc[c].first, loc[c].second);
      vector<Move> sol =
          moveTo(loc[c].first, loc[c].second, es[i].first, es[i].second);
      relocate(c, es[i].first, es[i].second);
      append(ans, sol);
    }
    for (int col = (1); col < (n + 1); col++) {
      if (host[row][col] > 0) {
        int c = host[row][col], x = loc[c].first, y = loc[c].second;
        bfs(x, y);
        vector<Move> sol = moveTo(loc[c].first, loc[c].second, row, col);
        append(ans, sol);
        relocate(c, row, col);
      }
    }
  }
  memset(board, 0, sizeof(board));
  for (int i = (1); i < (m + 1); i++) board[sx[i]][sy[i]] = i;
  cout << ans.size() << endl;
  for (int i = (0); i < (ans.size()); i++) {
    if (abs(ans[i].x2 - ans[i].x1) + abs(ans[i].y2 - ans[i].y1) != 1 ||
        board[ans[i].x1][ans[i].y1] == 0 || board[ans[i].x2][ans[i].y2] != 0)
      cerr << "WA";
    board[ans[i].x2][ans[i].y2] = board[ans[i].x1][ans[i].y1];
    board[ans[i].x1][ans[i].y1] = 0;
    printf("%d %d %d %d\n", ans[i].x1, ans[i].y1, ans[i].x2, ans[i].y2);
  }
  for (int i = (1); i < (m + 1); i++)
    if (board[ex[i]][ey[i]] != i) cerr << "WA";
  return 0;
}
