#pragma GCC optimize("Ofast,no-stack-protector,unroll-loops")
#include<bits/stdc++.h>
#define rep(i,a,b) for(int i=(a);i<=(b);i++)
#define per(i,a,b) for(int i=(a);i>=(b);i--)
#define op(x) ((x&1)?x+1:x-1)
#define odd(x) (x&1)
#define even(x) (!odd(x))
#define lc(x) (x<<1)
#define rc(x) (lc(x)|1)
#define lowbit(x) (x&-x)
#define mp(x,y) make_pair(x,y)
typedef long long ll;
typedef __int128 i128;
typedef unsigned long long ull;
typedef double db;
using namespace std;
const ll MAXN = 2e5+10,M = 1e9,mod = 998244353;
typedef array<ll,2> pr;
typedef array<ll,4> node;

void tomin(ll& x,ll y){x = min(x,y);}
void tomax(ll& x,ll y){x = max(x,y);}
void add(ll& x,ll y){x=(x+y)%mod;}
void sub(ll& x,ll y){x=(x-y+mod)%mod;}
ll addv(ll x,ll y){return (x+y)%mod;}
ll subv(ll x,ll y){return (x-y+mod)%mod;}

struct D{
	int b[MAXN],tot;
	void clr(){tot=0;}
	void add(int x){b[++tot]=x;}
	void pr(){
		sort(b+1,b+1+tot);
		tot=unique(b+1,b+1+tot)-b-1;
		b[tot+1]=M+1;
	}
	int qry(int x){return lower_bound(b+1,b+1+tot,x)-b;}
}dx,dy;

int T,n;
ll ans;
pr a[MAXN],b[MAXN],ra[MAXN],rb[MAXN]; //左下，右上

ll C(int x,int y){
	if(x<y)return 0;
	i128 r = 1;
	rep(i,0,y-1)r = r*(x-i);
	if(y==2)r/=2;	
	else if(y==3)r/=6;
	return r%mod;
}

namespace _{
	ll dp[4][MAXN],sum[4][MAXN],pre[MAXN],vx[MAXN],vy[MAXN];
	ll spre[MAXN],all,ban;

	#define mid ((l+r)>>1)
	struct Seg{
		ll tag[MAXN<<2],sum[MAXN<<2],val[MAXN<<2],all[MAXN<<2];
		vector<node> opt;
		void pu(int x){
			opt.push_back({tag[x],sum[x],val[x],x});
			sum[x]=sum[lc(x)]+sum[rc(x)],val[x]=val[rc(x)];
		}
		void cv(int x,ll v){
			opt.push_back({tag[x],sum[x],val[x],x});
			tag[x]=v,sum[x]=all[x]*v,val[x]=v;
		}
		void pd(int x){
			if(tag[x]==-1)return;
			opt.push_back({tag[x],sum[x],val[x],x});
			cv(lc(x),tag[x]),cv(rc(x),tag[x]);
			tag[x]=-1;
		}
		//
		void build(int x,int l,int r,int t){
			tag[x]=-1; all[x] = 0;
			if(l==r){
				val[x]=(!t)?(dx.b[l+1]):(M+1);
				sum[x]=val[x]*vx[l];
				all[x]=vx[l];
				return;
			}
			build(lc(x),l,mid,t),build(rc(x),mid+1,r,t);
			pu(x);
			all[x]=all[lc(x)]+all[rc(x)];
		}
		void mdf(int x,int l,int r,int ql,int qr,ll val){
			if(ql>qr)return;if(ql<=l && qr>=r)return cv(x,val);
			pd(x);
			if(ql<=mid)mdf(lc(x),l,mid,ql,qr,val);
			if(qr>mid)mdf(rc(x),mid+1,r,ql,qr,val);
			pu(x);
		}
		int qry(int x,int l,int r,ll lim){ //第一个>=lim的位置
			if(val[x]<lim)return r+1;
			if(l==r)return r;
			pd(x);
			int ret=qry(lc(x),l,mid,lim);if(ret != mid+1)return ret;
			return qry(rc(x),mid+1,r,lim);
		}
		ll qsum(int x,int l,int r,int ql,int qr){
			if(ql>qr)return 0;if(ql<=l && qr>=r)return sum[x];
			pd(x);ll ret=0;
			if(ql<=mid)ret+=qsum(lc(x),l,mid,ql,qr);
			if(qr>mid)ret+=qsum(rc(x),mid+1,r,ql,qr);
			return ret;
		}
		//
		void Init(int t){
			opt.clear(); 
			build(1,1,dx.tot,t);
		}
		void cmax(int l,int r,ll t){
			if(l>r)return;
			int q=qry(1,1,dx.tot,t);
			mdf(1,1,dx.tot,l,q-1,t);
		}
		void cmin(int l,int r,ll t){ 
			if(l>r)return;
			int q=qry(1,1,dx.tot,t);
			mdf(1,1,dx.tot,q,r,t);
		}
		void back(){
			assert(opt.size());
			node nd=opt.back();opt.pop_back(); int x=nd[3];
			tag[x]=nd[0],sum[x]=nd[1],val[x]=nd[2];
		}
		void back(int to){
			assert(opt.size()>=to);
			while(opt.size()>to)back();
		}
	}sL,sR;
	vector<pr>o[MAXN<<2];
	void build(int x,int l,int r){
		o[x].clear();if(l==r)return;
		build(lc(x),l,mid),build(rc(x),mid+1,r);
	}
	void ins(int x,int l,int r,int ql,int qr,pr p){
		if(ql>qr)return;if(ql<=l && qr>=r)return (void)(o[x].push_back(p));
		if(ql<=mid)ins(lc(x),l,mid,ql,qr,p);
		if(qr>mid)ins(rc(x),mid+1,r,ql,qr,p);
	}
	void mdf(int l,int r,int L,int R){ 
		if(l>r)return;
		all++;
		sL.cmax(l,r,L); sR.cmax(l,r,L);
		sR.cmin(l,r,R); sL.cmin(l,r,R);
	}
	ll qry(){
		return sR.qsum(1,1,dx.tot,1,ban) - sL.qsum(1,1,dx.tot,1,ban);
	}

	void solve(int x,int l,int r,ll xl,ll xr){
		int tagL=sL.opt.size(),tagR=sR.opt.size(),preban = ban;
		
		for(auto [L,R] : o[x]){
			tomax(xl,L),tomin(xr,R);

			ban = min(ban,R);
			mdf(1,L-1,dx.b[L],dx.b[R+1]);
		}

		if(l^r){
			solve(lc(x),l,mid,xl,xr);
			solve(rc(x),mid+1,r,xl,xr);
		}else{ 
			ll ret = qry(); 
			if(xl<=xr)ret += spre[xr]-spre[xl-1];
			ret%=mod;

			add(ans,ret * vy[l]);
		}
		sL.back(tagL),sR.back(tagR);ban = preban;
	}
	#undef mid

	void solve(int tag){
		dx.clr();dy.clr();
		dx.add(1),dy.add(1);
		rep(i,1,n){
			dx.add(a[i][0]);
			if(b[i][0]<M)dx.add(b[i][0]+1);
			dy.add(a[i][1]);
			if(b[i][1]<M)dy.add(b[i][1]+1);
		}
		dx.pr();dy.pr();
		rep(i,1,dx.tot)vx[i]=dx.b[i+1]-dx.b[i];
		rep(i,1,dy.tot)vy[i]=dy.b[i+1]-dy.b[i];


		rep(i,1,n){
			ra[i][0] = dx.qry(a[i][0]);
			ra[i][1] = dy.qry(a[i][1]);
			rb[i][0] = dx.qry(b[i][0]+1)-1;
			rb[i][1] = dy.qry(b[i][1]+1)-1;
		}
		//三个x

		ll mnR = dx.tot+1,mxL = 0;
		rep(i,0,dx.tot)pre[i]=1;
		rep(i,1,n){
			tomax(pre[rb[i][0]],ra[i][0]);
			tomin(mnR,rb[i][0]);
			tomax(mxL,ra[i][0]);
		}
		pre[0]=1,spre[0]=0;
		rep(i,1,dx.tot){
			pre[i] = max(pre[i-1],pre[i]);
			spre[i] = spre[i-1] + C(vx[i],2);
		}
		rep(i,0,dx.tot)rep(j,0,3)dp[j][i] = sum[j][i] = 0;
		
		rep(i,1,dx.tot){
			rep(j,1,3){
				ll& ret=dp[j][i];
				if(mnR>=i)add(ret,C(vx[i],j));
			
				rep(k,1,j-1){
					ll pos=pre[i-1]; //[pos,i-1]
					if(pos<=i-1){
						ll R=subv(sum[k][i-1],sum[k][pos-1]);
						add(ret,R*C(vx[i],j-k));
					}
				}
				if(mxL<=i && j==3)add(ans,ret);
				sum[j][i] = addv(sum[j][i-1],ret);
			}
		}
		
		//两个x，一个y
		sL.Init(0),sR.Init(1);
		build(1,1,dy.tot);
		rep(i,1,n){
			pr p={ra[i][0],rb[i][0]};
			ins(1,1,dy.tot,1,ra[i][1]-1,p);
			ins(1,1,dy.tot,rb[i][1]+1,dy.tot,p);
		}
		ban = dx.tot;
		solve(1,1,dy.tot,1,dx.tot);
	}
};

void solve(){
	cin>>n;ans=0;
	rep(i,1,n){
		cin>>a[i][0]>>a[i][1]>>b[i][0]>>b[i][1];
	}
	//
	_::solve(0);
	rep(i,1,n)swap(a[i][0],a[i][1]),swap(b[i][0],b[i][1]);
	_::solve(1);
	//
	cout<<ans<<"\n";
}

int main(){
	ios::sync_with_stdio(false);cin.tie(0);

	cin>>T;
	while(T--)solve();

    return 0;
}