#include <bits/stdc++.h>
using namespace std;
const int N = 1e4 + 7;
const int INF = 1e9 + 7;
inline int ri() {
  int x = 0;
  bool f = 1;
  char c = getchar();
  for (; !isdigit(c); c = getchar())
    if (c == '-') f = 0;
  for (; isdigit(c); c = getchar()) x = x * 10 + c - 48;
  return f ? x : -x;
}
int n, m;
namespace G {
static const int N = 32773 * 2;
static const int M = 11000 * 15 * 15 * 2 + N;
static const int S = 0, T = 32773;
struct vec {
  int g[N], te;
  struct edge {
    int y, f, nxt;
  } e[M];
  vec() { te = 1; }
  inline void push(int x, int y, int f) {
    e[++te] = (edge){y, f, g[x]};
    g[x] = te;
  }
  inline void link(int x, int y, int f) {
    push(x, y, f);
    push(y, x, 0);
  }
  inline int &operator()(int x) { return g[x]; }
  inline edge &operator[](int x) { return e[x]; }
} e;
int lev[N];
bool bfs() {
  static int q[N];
  int h = 0, t = 1;
  memset(lev, 0, sizeof lev);
  q[1] = S, lev[S] = 1;
  while (h != t) {
    int x = q[++h];
    for (int ep = e(x), y = e[ep].y; ep; y = e[ep = e[ep].nxt].y)
      if (e[ep].f && !lev[y]) {
        lev[y] = lev[x] + 1;
        if (y == T) return 1;
        q[++t] = y;
      }
  }
  return 0;
}
int dfs(int x, int fl) {
  if (x == T) return fl;
  int res = 0;
  for (int ep = e(x), y = e[ep].y; ep; y = e[ep = e[ep].nxt].y)
    if (e[ep].f && lev[x] + 1 == lev[y]) {
      int tp = dfs(y, min(fl, e[ep].f));
      if (tp) {
        e[ep].f -= tp;
        e[ep ^ 1].f += tp;
        res += tp;
        fl -= tp;
        if (fl == 0) return res;
      }
    }
  if (!res) lev[x] = 0;
  return res;
}
int dinic() {
  int res = 0;
  while (bfs()) res += dfs(S, INF);
  return res;
}
inline void link(int x, int y, int f) { e.link(x, y, f); }
}  // namespace G
namespace Seg {
static const int N = 32773;
static const int S = 0, T = N;
void get(int x, int l, int r, int tl, int tr, int *to, int &cnt) {
  if (tl <= l && r <= tr) {
    to[++cnt] = x;
    return;
  }
  int mid = (l + r) >> 1;
  if (tl <= mid) get((x << 1), l, mid, tl, tr, to, cnt);
  if (mid < tr) get((x << 1 | 1), mid + 1, r, tl, tr, to, cnt);
}
void insert(int l, int r, int u, int v) {
  if (l > r || u > v) return;
  static int L[N], R[N], tL, tR;
  get(1, 1, n, l, r, L, tL = 0);
  get(1, 1, n, u, v, R, tR = 0);
  for (int i = (1); i <= (tL); ++i)
    for (int j = (1); j <= (tR); ++j) G::link(L[i], R[j] + N, INF);
}
void build(int x, int l, int r, int kd) {
  if (l == r) {
    if (kd == 1) G::link(S, x, 1);
    if (kd == 2) G::link(x + N, T, 1);
    return;
  }
  int mid = (l + r) >> 1;
  build((x << 1), l, mid, kd);
  build((x << 1 | 1), mid + 1, r, kd);
  if (kd == 1) G::link((x << 1), x, INF), G::link((x << 1 | 1), x, INF);
  if (kd == 2)
    G::link(x + N, (x << 1) + N, INF), G::link(x + N, (x << 1 | 1) + N, INF);
}
void build() {
  build(1, 1, n, 1);
  build(1, 1, n, 2);
}
}  // namespace Seg
namespace rect {
struct line {
  int u, v;
  int x;
  bool operator<(const line &y) const { return v < y.u; }
} e[N];
int te;
set<line> S;
void build() {
  sort(e + 1, e + te + 1, [](const line &a, const line &b) -> bool {
    if (abs(a.x) != abs(b.x))
      return abs(a.x) < abs(b.x);
    else
      return a.x < b.x;
  });
  for (int i = (1); i <= (te); ++i) {
    if (e[i].x < 0)
      e[i].x = -e[i].x, S.insert(e[i]);
    else {
      set<line>::iterator it;
      while ((it = S.lower_bound(e[i])) != S.end()) {
        if (e[i].v < it->u) break;
        line tp = *it;
        S.erase(it);
        Seg::insert(tp.x, e[i].x - 1, max(e[i].u, tp.u), min(e[i].v, tp.v));
        if (tp.u < e[i].u) S.insert((line){tp.u, e[i].u - 1, tp.x});
        if (tp.v > e[i].v) S.insert((line){e[i].v + 1, tp.v, tp.x});
      }
    }
  }
}
inline void push(int u, int v, int x) { e[++te] = (line){u, v, x}; }
}  // namespace rect
int main() {
  n = ri(), m = ri();
  rect::push(1, n, -(1));
  rect::push(1, n, n + 1);
  for (int i = (1); i <= (m); ++i) {
    int x1 = ri(), y1 = ri(), x2 = ri(), y2 = ri();
    rect::push(y1, y2, x1);
    rect::push(y1, y2, -(x2 + 1));
  }
  rect::build();
  Seg::build();
  printf("%d\n", G::dinic());
  return 0;
}
