#include <bits/stdc++.h>
using namespace std;

const int N=2e5+5;
const int P=131;
const int INF=0x3f3f3f3f;

int l1[N], r1[N], l2[N], r2[N], n, q, op;
int id[N], rk[N*2];
vector <int> vec[N];

namespace sortline
{
	vector <pair<int,int> > add[N];
	int sum[N*80], lc[N*80], rc[N*80], rt[N], cnt;
	unsigned long long Hash[N*80], pw[N];

	int update(int rt,int l,int r,int pos)
	{
		int p=++cnt;
		sum[p]=sum[rt], lc[p]=lc[rt], rc[p]=rc[rt], Hash[p]=Hash[rt];
		if(l==r)
		{
			Hash[p] ^= 1, sum[p] ^= 1;
			return p;
		}

		int mid=(l+r)/2;
		if(pos<=mid)
			lc[p]=update(lc[rt],l,mid,pos);
		else
			rc[p]=update(rc[rt],mid+1,r,pos);

		sum[p]=sum[lc[p]]+sum[rc[p]];
		Hash[p]=Hash[lc[p]]*pw[r-mid]+Hash[rc[p]];
		return p;
	}

	int getsum(int rt1,int rt2,int l,int r)
	{
		if(l==r)
			return sum[rt1];

		int mid=(l+r)/2;
		if(Hash[lc[rt1]]==Hash[lc[rt2]])
			return sum[lc[rt1]]+getsum(rc[rt1],rc[rt2],mid+1,r);
		return getsum(lc[rt1],lc[rt2],l,mid);
	}

	bool cmp(int x,int y)
	{
		if(Hash[rt[x]]==Hash[rt[y]])
			return x<y;

		return getsum(rt[x],rt[y],1,n)%2==1;
	}

	void main()
	{
		for(int i=1;i<=q;i++)
		{
			add[l1[i]].push_back(make_pair(l2[i],r2[i]));
			add[r1[i]+1].push_back(make_pair(l2[i],r2[i]));
		}

		pw[0]=1;
		for(int i=1;i<=n+1;i++)
			pw[i]=pw[i-1]*P;

		for(int i=1;i<=n;i++)
		{
			rt[i]=rt[i-1];
			for(auto x:add[i])
			{
				rt[i]=update(rt[i],1,n,x.first);
				if(x.second+1<=n)
					rt[i]=update(rt[i],1,n,x.second+1);
			}
		}

		for(int i=1;i<=n;i++)
			id[i]=i;

		sort(id+1,id+n+1,cmp);
	}
}

namespace sortcol
{
	vector <pair<int,int> > add[N];
	int sum[N*4], rev[N*4];

	void cov(int rt,int l,int r)
	{
		rev[rt] ^= 1;
		sum[rt] = r-l+1-sum[rt];
	}

	void update(int rt,int l,int r,int ql,int qr)
	{
		if(ql<=l && r<=qr)
		{
			cov(rt,l,r);
			return;
		}

		int mid=(l+r)/2;
		if(rev[rt])
		{
			cov(rt*2,l,mid);
			cov(rt*2+1,mid+1,r);
			rev[rt]=0;
		}

		if(ql<=mid)
			update(rt*2,l,mid,ql,qr);
		if(mid+1<=qr)
			update(rt*2+1,mid+1,r,ql,qr);
		sum[rt]=sum[rt*2]+sum[rt*2+1];
	}

	void main()
	{
		for(int i=1;i<=q;i++)
		{
			add[l2[i]].push_back(make_pair(l1[i],r1[i]));
			add[r2[i]+1].push_back(make_pair(l1[i],r1[i]));
		}

		for(int i=1;i<=n;i++)
		{
			for(auto x:add[i])
				update(1,1,n,x.first,x.second);

			vec[sum[1]].push_back(i);
		}
	}
}

namespace getans
{
	vector <pair<int,int> > add[N];
	int Max0[N*4], Min0[N*4], Max1[N*4], Min1[N*4], rev[N*4];
	long long tot;

	void cov(int rt,int l,int r)
	{
		rev[rt] ^= 1;
		swap(Min0[rt], Min1[rt]);
		swap(Max0[rt], Max1[rt]);
	}

	void pushup(int rt)
	{
		Max0[rt]=max(Max0[rt*2],Max0[rt*2+1]);
		Min0[rt]=min(Min0[rt*2],Min0[rt*2+1]);
		Max1[rt]=max(Max1[rt*2],Max1[rt*2+1]);
		Min1[rt]=min(Min1[rt*2],Min1[rt*2+1]);
	}

	void build(int rt,int l,int r)
	{
		if(l==r)
		{
			Min0[rt]=Max0[rt]=rk[l];
			Min1[rt]=INF, Max1[rt]=-INF;
			return;
		}

		int mid=(l+r)/2;
		build(rt*2,l,mid);
		build(rt*2+1,mid+1,r);
		pushup(rt);
	}

	void update(int rt,int l,int r,int ql,int qr)
	{
		if(ql<=l && r<=qr)
		{
			cov(rt,l,r);
			return;
		}

		int mid=(l+r)/2;
		if(rev[rt])
		{
			cov(rt*2,l,mid);
			cov(rt*2+1,mid+1,r);
			rev[rt]=0;
		}

		if(ql<=mid)
			update(rt*2,l,mid,ql,qr);
		if(mid+1<=qr)
			update(rt*2+1,mid+1,r,ql,qr);
		pushup(rt);
	}

	int sum[N*2][2], fa[N*2];

	int getfa(int x)
	{
		if(x!=fa[x])
			fa[x]=getfa(fa[x]);
		return fa[x];
	}

	void merge(int x,int y)
	{
		int fax=getfa(x), fay=getfa(y);
		if(fax!=fay)
		{
			fa[fax]=fay;
			sum[fay][0] += sum[fax][0];
			sum[fay][1] += sum[fax][1];
		}
	}

	long long calc(int x)
	{
		return max(1ll*sum[x][0]*sum[x][1]-1,0ll);
	}

	void merge_segment(int l,int r)
	{
		if(l>r)
			return;

		if(getfa(l)==getfa(r))
			return;

		tot -= calc(getfa(l));
		tot -= calc(getfa(getfa(l)+1));
		merge(getfa(l),getfa(l)+1);
		tot += calc(getfa(l));
		merge_segment(l,r);
	}

	void main()
	{
		int cnt=0;
		for(auto x:vec[0])
			rk[x+n]=++cnt;

		for(int i=1;i<=n;i++)
		{
			rk[id[i]]=++cnt;
			for(auto x:vec[i])
				rk[x+n]=++cnt;
		}

		for(int i=1;i<=q;i++)
		{
			add[l2[i]].push_back(make_pair(l1[i],r1[i]));
			add[r2[i]+1].push_back(make_pair(l1[i],r1[i]));
		}

		build(1,1,n);

		for(int i=1;i<=n*2;i++)
			fa[i]=i;

		for(int i=1;i<=n;i++)
			sum[rk[i]][0]=1;

		for(int i=1;i<=n;i++)
		{
			for(auto x:add[i])
				update(1,1,n,x.first,x.second);

			merge_segment(Min0[1], Max1[1]);
			tot -= calc(getfa(rk[i+n]));
			sum[getfa(rk[i+n])][1]++;
			tot += calc(getfa(rk[i+n]));
			if(op==1 || i==n)
				printf("%lld ",1ll*i*n-tot);
		}
	}
}

int main()
{
	cin >> n >> q >> op;
	for(int i=1;i<=q;i++)
		scanf("%d %d %d %d",&l1[i],&r1[i],&l2[i],&r2[i]);

	sortline::main();
	sortcol::main();
	getans::main();
	return 0;
}