#include <bits/stdc++.h>

using namespace std;

using ll=long long;
using uint=unsigned;

#define rng(i,a,b) for(int i=int(a);i<int(b);i++)
#define rep(i,b) rng(i,0,b)
#define zero(x) memset(x,0,sizeof(x))
#define bg begin()
#define ed end()
#define all(x) x.bg,x.ed
#define si(x) int(x.size())
#define pb push_back
#define eb emplace_back
template<class t>using vc=vector<t>;

template<class t>ostream&operator<<(ostream&os,const vc<t>&vs){
	os<<"{";
	for(auto e:vs)os<<e<<",";
	return os<<"}";
}

template<class t,class u>bool chmax(t&a,u b){
	if(a<b){a=b;return true;}
	else return false;
}

template<class t>void mkuni(vc<t>&vs){
	sort(all(vs));
	vs.erase(unique(all(vs)),vs.ed);
}

template<class t>int lwb(const vc<t>&vs,t a){
	return lower_bound(all(vs),a)-vs.bg;
}

const uint mod=998244353;
struct mint{
	uint v;
	mint(ll vv=0){s(vv%mod+mod);}
	mint&s(uint vv){
		v=vv<mod?vv:vv-mod;
		return *this;
	}
	mint operator-()const{return mint()-*this;}
	mint&operator+=(const mint&r){return s(v+r.v);}
	mint&operator-=(const mint&r){return s(v+mod-r.v);}
	mint&operator*=(const mint&r){v=(unsigned ll)v*r.v%mod;return *this;}
	mint&operator/=(const mint&r){return *this*=r.inv();}
	mint operator+(const mint&r)const{return mint(*this)+=r;}
	mint operator-(const mint&r)const{return mint(*this)-=r;}
	mint operator*(const mint&r)const{return mint(*this)*=r;}
	mint operator/(const mint&r)const{return mint(*this)/=r;}
	mint pow(ll n)const{
		if(n<0)return inv().pow(-n);
		mint res(1),x(*this);
		while(n){
			if(n&1)res*=x;
			x*=x;
			n>>=1;
		}
		return res;
	}
	mint inv()const{return pow(mod-2);}
};

ostream& operator<<(ostream&os,mint v){
	return os<<v.v;
}

#define a first
#define b second

using vi=vc<int>;
using pi=pair<int,int>;
using ppi=pair<pi,pi>;

const int inf=INT_MAX/2-100;

const int nmax=505;
int dp[nmax*2][nmax];
int memo[nmax][nmax];
struct Lower{
	pi a[nmax];
	int s;
	void clear(){s=0;}
	void add(int x,int y){
		while(s>0&&a[s-1].b<=y)s--;
		a[s++]=pi(x,y);
	}
	ll area(){
		ll pre=-1,res=0;
		rep(i,s){
			auto [x,y]=a[i];
			res+=(x-pre)*(y+1);
			pre=x;
		}
		return res;
	}
} unko[nmax];

void slv(){
	int n,k;cin>>n>>k;
	vc<ppi> qss[2];
	rep(i,n){
		int a,b,c,d;cin>>a>>b>>c>>d;
		a--;b--;c--;d--;
		if(a>c){
			swap(a,c);
			swap(b,d);
		}
		int j=0;
		if(d<b){
			j=1;
			d=k-1-d;
			b=k-1-b;
		}
		qss[j].eb(pi(a,b),pi(c,d));
	}
	mint org=mint(k+1)*k*(k-1)/6*k*k*2;
	mint ans=0;
	
	rep(step,2){
		auto qs=qss[step];
		int q=si(qs);
		sort(all(qs));
		
		vi xs{k},ys{k};
		for(auto [u,v]:qs){
			xs.pb(u.a);ys.pb(u.b);
			xs.pb(v.a);ys.pb(v.b);
		}
		mkuni(xs);
		mkuni(ys);
		
		rep(y,si(ys)-1)rep(i,q)dp[y][i]=-inf;
		rep(x,si(xs)-1){
			rep(y,si(ys)-1){
				if(y)rep(i,q)chmax(dp[y][i],dp[y-1][i]);
				rep(j,q){
					if(qs[j].b==pi(xs[x],ys[y])){
						chmax(dp[y][j],0);
						rep(i,q)chmax(dp[y][i],memo[j][i]+1);
					}
				}
				rep(j,q){
					if(qs[j].a==pi(xs[x],ys[y])){
						rep(i,q)memo[j][i]=dp[y][i];
					}
				}
				rep(j,q){
					if(dp[y][j]>=0){
						unko[dp[y][j]].add(qs[j].a.a,qs[j].a.b);
					}
				}
				mint tot=0;
				rep(j,q){
					tot+=unko[j].area();
					unko[j].clear();
				}
				ans+=tot*(xs[x+1]-xs[x])*(ys[y+1]-ys[y]);
			}
		}
	}
	
	cout<<org-ans<<endl;
}

signed main(){
	cin.tie(0);
	ios::sync_with_stdio(0);
	cout<<fixed<<setprecision(10);
	
	slv();
}