#pragma GCC optimize("Ofast")
#pragma GCC optimize("unroll-loops")

#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>

#pragma GCC target("avx2")

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")


int root(vector<int> &uf, int u) {
  return (uf[u] < 0) ? u : (uf[u] = root(uf, uf[u]));
}
bool connect(vector<int> &uf, int u, int v) {
  u = root(uf, u);
  v = root(uf, v);
  if (u == v) return false;
  if (uf[u] > uf[v]) swap(u, v);
  uf[u] += uf[v];
  uf[v] = u;
  return true;
}


int N, Q, O;
vector<int> X0, X1, Y0, Y1;


namespace brute {
int calc(const bitset<5010> &a, const bitset<5010> &b) {
  auto a_ = (const unsigned long long *)&a;
  auto b_ = (const unsigned long long *)&b;
  const int lim = (N + 63) / N;
  for (int i = 0; i < lim; ++i) {
    const auto f = ~a_[i] & b_[i];
    const auto g = a_[i] & ~b_[i];
    if (f) {
      if (g) {
        return i << 6 | max(__builtin_ctzll(f), __builtin_ctzll(g));
      } else {
        for (int j = i + 1; j < lim; ++j) {
          const auto gg = a_[j] & ~b_[j];
          if (gg) return j << 6 | __builtin_ctzll(gg);
        }
        break;
      }
    } else {
      if (g) {
        for (int j = i + 1; j < lim; ++j) {
          const auto ff = ~a_[j] & b_[j];
          if (ff) return j << 6 | __builtin_ctzll(ff);
        }
      } else {
        //
      }
    }
  }
  return N;
}

int A[5010][5010];
bitset<5010> B[5010], C[5010];
vector<Int> run() {
  for (int x = 0; x <= N; ++x) for (int y = 0; y <= N; ++y) A[x][y] = 0;
  for (int q = 0; q < Q; ++q) {
    A[X0[q]][Y0[q]] ^= 1;
    A[X0[q]][Y1[q]] ^= 1;
    A[X1[q]][Y0[q]] ^= 1;
    A[X1[q]][Y1[q]] ^= 1;
  }
  for (int x = 0; x <= N; ++x) for (int y = 0; y <= N; ++y) A[x + 1][y] ^= A[x][y];
  for (int x = 0; x <= N; ++x) for (int y = 0; y <= N; ++y) A[x][y + 1] ^= A[x][y];
// for(int x=0;x<N;++x){for(int y=0;y<N;++y)cerr<<A[x][y];cerr<<endl;}
  
  for (int x = 0; x < N; ++x) {
    B[x].reset();
    for (int y = 0; y < N; ++y) B[x][y] = A[x][y];
  }
  for (int y = 0; y < N; ++y) {
    C[y].reset();
    for (int x = 0; x < N; ++x) C[y][x] = A[x][y];
  }
  vector<vector<pair<int, pair<int, int>>>> ess(N);
  for (int x0 = 0; x0 < N; ++x0) for (int x1 = 0; x1 < x0; ++x1) {
    // const int y = max((~B[x0] & B[x1])._Find_first(), (B[x0] & ~B[x1])._Find_first());
    const int y = calc(B[x0], B[x1]);
    if (y < N) {
      ess[y].emplace_back(N + y, make_pair(x0, x1));
    }
  }
  for (int y0 = 0; y0 < N; ++y0) for (int y1 = 0; y1 < y0; ++y1) {
    // const int x = max((~C[y0] & C[y1])._Find_first(), (C[y0] & ~C[y1])._Find_first());
    const int x = calc(C[y0], C[y1]);
    if (x < N) {
      ess[y0].emplace_back(x, make_pair(N + y0, N + y1));
    }
  }
  
  vector<int> uf(N + N, -1);
  vector<Int> fs(N + N, 0), gs(N + N, 0);
  for (int x = 0; x < N; ++x) fs[x] = 1;
  for (int y = 0; y < N; ++y) gs[N + y] = 1;
  Int now = 0;
  auto conn = [&](int u, int v) -> void {
    u = root(uf, u);
    v = root(uf, v);
    if (u != v) {
      connect(uf, u, v);
      if (u != uf[v]) swap(u, v);
      assert(u == uf[v]);
      now -= max(fs[u] * gs[u] - 1, 0LL);
      now -= max(fs[v] * gs[v] - 1, 0LL);
      fs[u] += fs[v];
      gs[u] += gs[v];
      now += max(fs[u] * gs[u] - 1, 0LL);
    }
  };
  
  vector<Int> ans(N);
  for (int y = 0; y < N; ++y) {
    for (const auto &e : ess[y]) {
      conn(e.first, e.second.first);
      conn(e.first, e.second.second);
    }
// for(int r=0;r<N+N;++r)if(uf[r]<0)cerr<<make_pair(fs[r],gs[r])<<" ";cerr<<endl;
    ans[y] = N * (y + 1) - now;
  }
  if (O == 0) ans = {ans.back()};
  return ans;
}
}  // brute


int main() {
  for (; ~scanf("%d%d%d", &N, &Q, &O); ) {
    X0.resize(Q);
    X1.resize(Q);
    Y0.resize(Q);
    Y1.resize(Q);
    for (int q = 0; q < Q; ++q) {
      scanf("%d%d%d%d", &X0[q], &X1[q], &Y0[q], &Y1[q]);
      --X0[q];
      --Y0[q];
    }
    
    const auto ans = brute::run();
    for (int i = 0; i < (int)ans.size(); ++i) {
      if (i) printf(" ");
      printf("%lld", ans[i]);
    }
    puts("");
  }
  return 0;
}