#include <bits/stdc++.h>
using namespace std;
#define ull uint64_t
#define ll int64_t
#define pb push_back

const int N=105;
ll a[N],da[N],b[N],db[N];
int n;
ll m;

ll whenOne[N],whenTwo[N][N];
ll L;
bool cmp(int i,int j){
	if(a[i]<a[j] || (a[i]==a[j] && i<j)){
		if(whenTwo[i][j]<=L)return false;
		return true;
	}else{
		if(whenTwo[i][j]<=L)return true;
		return false;
	}
}

ll When(array<ll,2> f1,array<ll,2> f2){
	ll p=f1[0]-f2[0];
	ll q=f2[1]-f1[1];
	if(q<0)q=-q,p=-p;
	if(p>=0)return (p+q-1)/q;
	return p/q;
}

ull S2(ll x){
	ull a=x;
	ull b=x+1;
	if(a%2==0)a/=2;
	else b/=2;
	return a*b;
}

ull ans=0;
void Solve(ll L,ll R){
	::L=L;
	vector<int> fir,sec,ord;
	for(int i=1;i<=n;i++){
		if(a[i]<=b[i]){
			if(whenOne[i]<=L){
				sec.pb(i);
			}else{
				fir.pb(i);
			}
		}else{
			if(whenOne[i]<=L){
				fir.pb(i);
			}else{
				sec.pb(i);
			}
		}
	}
	sort(fir.begin(),fir.end(),cmp);
	sort(sec.begin(),sec.end(),cmp);
	//reverse(sec.begin(),sec.end());
	for(int i:fir)ord.pb(i);
	for(int i:sec)ord.pb(i);

	//printf("Solve %lld - %lld\n",L,R);
	//for(int i:ord)printf("%i ",i);
	//printf("\n");

	vector<array<ll,2>> func(n);
	ll sumA=0,sumDA=0,sumB=0,sumDB=0;
	for(int i=0;i<n;i++){
		sumA+=a[ord[i]];
		sumDA+=da[ord[i]];
		func[i]={sumA-sumB,sumDA-sumDB};
		//printf("%lld + k * %lld\n",func[i][0],func[i][1]);
		sumB+=b[ord[i]];
		sumDB+=db[ord[i]];
	}
	sort(func.begin(),func.end(),[&](array<ll,2> a,array<ll,2> b){return a[1]<b[1];});
	vector<array<ll,2>> hull;
	for(array<ll,2> f:func){
		if(hull.size() && hull.back()[1]==f[1]){
			if(hull.back()[0]<f[0]){
				hull.pop_back();
			}else{
				continue;
			}
		}
		while(hull.size()>1){
			int sz=hull.size();
			if(When(hull[sz-1],f)<=When(hull[sz-2],hull[sz-1])){
				hull.pop_back();
			}else{
				break;
			}
		}
		hull.pb(f);
	}
	ll last=L;
	for(int i=0;i<hull.size();i++){
		ll now;
		if(i+1==hull.size()){
			now=R;
		}else{
			now=When(hull[i],hull[i+1])-1;
		}
		if(max(L,last)<=min(R,now)){
			ll l=max(L,last);
			ll r=min(R,now);
			ans+=(ull)(r-l+1)*((ull)hull[i][0]);
			ans+=(S2(r)-S2(l-1))*((ull)hull[i][1]);
			//printf("Best at %lld - %lld\n",l,r);
			//printf("%lld + k * %lld\n",hull[i][0],hull[i][1]);
			//printf("ans: %llu\n",ans);
		}
		last=now+1;
	}
}
int main(){
	scanf("%i %lld",&n,&m);
	vector<ll> evs;
	for(int i=1;i<=n;i++){
		scanf("%lld %lld %lld %lld",&a[i],&da[i],&b[i],&db[i]);
		whenOne[i]=m+1;
		if(a[i]<=b[i]){
			if(da[i]>db[i]){
				ll p=b[i]-a[i];
				ll q=da[i]-db[i];
				evs.pb((p+q)/q);
				whenOne[i]=evs.back();
			}
		}else{
			if(da[i]<db[i]){
				ll p=a[i]-b[i];
				ll q=db[i]-da[i];
				evs.pb((p+q-1)/q);
				whenOne[i]=evs.back();
			}
		}
	}
	for(int i=1;i<=n;i++){
		for(int j=i+1;j<=n;j++){
			whenTwo[i][j]=whenTwo[j][i]=m+1;
			if(a[i]<=a[j]){
				if(da[i]>da[j]){
					ll p=a[j]-a[i];
					ll q=da[i]-da[j];
					evs.pb((p+q)/q);
					whenTwo[i][j]=whenTwo[j][i]=evs.back();
				}
			}else{
				if(da[i]<da[j]){
					ll p=a[i]-a[j];
					ll q=da[j]-da[i];
					evs.pb((p+q-1)/q);
					whenTwo[i][j]=whenTwo[j][i]=evs.back();
				}
			}
		}
	}
	evs.pb(0);
	sort(evs.begin(),evs.end());
	evs.erase(unique(evs.begin(),evs.end()),evs.end());
	while(evs.back()>m)evs.pop_back();
	evs.pb(m+1);
	for(int i=0;i+1<evs.size();i++){
		Solve(evs[i],evs[i+1]-1);
	}
	printf("%llu\n",ans);
	return 0;
}