#include <bits/stdc++.h>
using namespace std;
const int BIG = 55;
int N, M, state_cube[BIG][BIG], state_dest[BIG][BIG], sorted_cubes[BIG];
pair<int, int> cube[BIG], dest[BIG];
pair<int, int> pprev[BIG][BIG];
vector<array<int, 4>> solution;
int dist(int c, pair<int, int> pos) {
  return abs(cube[c].first - pos.first) + abs(cube[c].second - pos.second);
}
pair<int, int> q[BIG * BIG];
int head, tail;
void q_push(int r, int c, pair<int, int> p) {
  if (r < 1 || c < 1 || r > N || c > N) return;
  if (pprev[r][c].first >= 0) return;
  if (state_cube[r][c] > 0) return;
  pprev[r][c] = p;
  q[tail++] = {r, c};
}
void bfs(int r, int c, int tr, int tc) {
  head = 0, tail = 1;
  q[head] = {r, c};
  pprev[r][c] = {r, c};
  while (head < tail) {
    pair<int, int> n = q[head++];
    q_push(n.first + 1, n.second, n);
    q_push(n.first - 1, n.second, n);
    q_push(n.first, n.second - 1, n);
    q_push(n.first, n.second + 1, n);
  }
}
void add_path(int r1, int c1, int r2, int c2) {
  int cub = state_cube[r1][c1];
  ;
  for (int i = 1; i <= N; ++i) {
    for (int j = 1; j <= N; ++j) {
      pprev[i][j] = {-1, -1};
    }
  }
  bfs(r1, c1, r2, c2);
  assert(pprev[r2][c2].first >= 0);
  int r = r2, c = c2;
  vector<pair<int, int>> path;
  while (!(r == r1 && c == c1)) {
    path.push_back({r, c});
    int nr = pprev[r][c].first;
    int nc = pprev[r][c].second;
    r = nr;
    c = nc;
  }
  path.push_back({r, c});
  reverse(path.begin(), path.end());
  for (int i = 0; i < path.size() - 1; ++i) {
    solution.push_back(
        {path[i].first, path[i].second, path[i + 1].first, path[i + 1].second});
  }
  state_cube[r1][c1] = 0;
  state_cube[r2][c2] = cub;
  cube[cub] = {r2, c2};
}
int main() {
  scanf("%d %d", &N, &M);
  if (N == 1) {
    printf("0\n");
    return 0;
  }
  for (int i = 1; i <= M; ++i) {
    scanf("%d %d", &cube[i].first, &cube[i].second);
    state_cube[cube[i].first][cube[i].second] = i;
    sorted_cubes[i] = i;
  }
  for (int i = 1; i <= M; ++i) {
    scanf("%d %d", &dest[i].first, &dest[i].second);
    state_dest[dest[i].first][dest[i].second] = i;
  };
  for (int j = 1; j <= M; ++j) {
    int best = -1;
    for (int c = 1; c <= M; ++c) {
      if (!(cube[c].first == N && cube[c].second < j)) {
        if (best == -1 || dist(c, {N, j}) < dist(best, {N, j})) {
          best = c;
        }
      }
    }
    assert(best >= 0);
    add_path(cube[best].first, cube[best].second, N, j);
  };
  sort(sorted_cubes + 1, sorted_cubes + 1 + M, [](int a, int b) {
    return dest[a].first > dest[b].first ||
           (dest[a].first == dest[b].first && dest[a].second < dest[b].second);
  });
  for (int i = 1; i <= M; ++i) {
    int c = sorted_cubes[i];
    add_path(cube[c].first, cube[c].second, 1, i);
  };
  for (int i = N; i >= 1; --i) {
    for (int j = N; j >= 1; --j) {
      if (state_dest[i][j] > 0) {
        int c = state_dest[i][j];
        if (cube[c].second <= j && cube[c] != dest[c]) {
          add_path(cube[c].first, cube[c].second, i, j);
        }
      }
    }
    for (int j = 1; j <= N; ++j) {
      if (state_dest[i][j] > 0) {
        int c = state_dest[i][j];
        if (cube[c].second >= j && cube[c] != dest[c]) {
          add_path(cube[c].first, cube[c].second, i, j);
        }
      }
    }
  }
  printf("%d\n", (int)solution.size());
  for (int i = 0; i < solution.size(); ++i) {
    printf("%d %d %d %d\n", solution[i][0], solution[i][1], solution[i][2],
           solution[i][3]);
  }
  return 0;
}
