#include <iostream>
#include <assert.h>
#include <map>
#include <vector>
#include <queue>
#include <set>
#include <algorithm>
using namespace std;

long long readInt(long long l,long long r,char endd){
	long long x=0;
	int cnt=0;
	int fi=-1;
	bool is_neg=false;
	while(true){
		char g=getchar();
		if(g=='-'){
			assert(fi==-1);
			is_neg=true;
			continue;
		}
		if('0'<=g && g<='9'){
			x*=10;
			x+=g-'0';
			if(cnt==0){
				fi=g-'0';
			}
			cnt++;
			assert(fi!=0 || cnt==1);
			assert(fi!=0 || is_neg==false);
			
			assert(!(cnt>19 || ( cnt==19 && fi>1) ));
		} else if(g==endd){
			if(is_neg){
				x= -x;
			}
			assert(l<=x && x<=r);
			return x;
		} else {
			cout<<"GE: "<<(int)g<<endl;
			assert(false);
		}
	}
}
string readString(int l,int r,char endd){
	string ret="";
	int cnt=0;
	while(true){
		char g=getchar();
		assert(g!=-1);
		if(g==endd){
			break;
		}
		cnt++;
		ret+=g;
	}
	assert(l<=cnt && cnt<=r);
	return ret;
}
long long readIntSp(long long l,long long r){
	return readInt(l,r,' ');
}
long long readIntLn(long long l,long long r){
	return readInt(l,r,'\n');
}
string readStringLn(int l,int r){
	return readString(l,r,'\n');
}
string readStringSp(int l,int r){
	return readString(l,r,' ');
}


int T;
int n,k,m;

int r1[100100];
int c1[100100];
int r2[100100];
int c2[100100];

map<int,vector<pair<int,int> > > hh;
map<int,vector<pair<int,int> > >::iterator ii;


/*
int arr_comp[400400],c=0;

int compress(int x){
	int l=-1,r=c;
	while(r-l>1){
		int mid=(r+l)/2;
		if(arr_comp[mid] <= x){
			l=mid;
		} else {
			r=mid;
		}
	}
	return l;
}



int sgt[1601000];

void update(int nd,int l,int r,int ind,int val){
	if(l==r){
		sgt[nd]= val;
		return;
	}
	int mid=(r+l)/2;
	if(ind<=mid){
		update(2*nd,l,mid,ind,val);
	} else {
		update(2*nd+1,mid+1,r,ind,val);
	}
	sgt[nd] = sgt[2*nd]+sgt[2*nd+1];
}

*/

bool chk1(){
	for(ii=hh.begin();ii!=hh.end();ii++){
		vector<pair<int,int> > y=ii->second;
		sort(y.begin(),y.end());
		int si=y.size();
		for(int i=0;i<si-1;i++){
			if(y[i].second >= y[i+1].first ){
				return false;
			}
		}
	}
	return true;
}

struct evt{
	bool is_query;
	int l,r;
	int ind;
	int x;
};


int type(evt a){
	if(!a.is_query && a.ind <0){
		return 3;
	}
	if(a.is_query){
		return 2;
	}
	if(!a.is_query && a.ind > 0){
		return 1;
	}
}
bool operator<(evt a,evt b){
	if(a.x != b.x)return a.x< b.x;
	return type(a) < type(b);
}
evt A[1001001];
int u=0;

set<int> g;
set<int>::iterator jj;
bool check2(){
	u=0;
	g.clear();
	for(int i=0;i<m;i++){
		if(r1[i] == r2[i]){
			A[u].is_query=false;
			A[u].ind=r1[i];
			A[u].x=c1[i];
			u++;
			A[u].is_query=false;
			A[u].ind=-r1[i];
			A[u].x=c2[i];
			u++;
		} else {
			A[u].is_query=true;
			A[u].x=c1[i];
			A[u].l=r1[i];
			A[u].r=r2[i];
			u++;
		}
	}
	sort(A,A+u);
	for(int i=0;i<u;i++){
		if(A[i].is_query){
			jj=g.lower_bound(A[i].l);
			if(jj!=g.end() && (*jj) <=A[i].r){
				return false;
			}
		} else {
			if(A[i].ind >0){
				g.insert(A[i].ind);
			} else{
				g.erase(-A[i].ind);
			}
		}
	}
	g.clear();
	u=0;


	for(int i=0;i<m;i++){
		if(c1[i] == c2[i]){
			A[u].is_query=false;
			A[u].ind=c1[i];
			A[u].x=r1[i];
			u++;
			A[u].is_query=false;
			A[u].ind=-c1[i];
			A[u].x=r2[i];
			u++;
		} else {
			A[u].is_query=true;
			A[u].x=r1[i];
			A[u].l=c1[i];
			A[u].r=c2[i];
			u++;
		}
	}
	sort(A,A+u);
	for(int i=0;i<u;i++){
		if(A[i].is_query){
			jj=g.lower_bound(A[i].l);
			if(jj!=g.end() && (*jj) <=A[i].r){
				return false;
			}
		} else {
			if(A[i].ind >0){
				g.insert(A[i].ind);
			} else{
				g.erase(-A[i].ind);
			}
		}
	}
	return true;
}


pair<int,int> B[100100];
int t=0;

int get_ans(int L,int R){
	R++;
	for(int i=0;i<t;i++){
		B[i].second ++;
	}
	sort(B,B+t);
	int cur=0;
	priority_queue<int> V;
	int ans=0;
	while(L<R){
		while(cur<t && B[cur].first <=L){
			V.push(B[cur].second);
			cur++;
		}
		if(V.empty()){
			return 1<<20;
		}
		L=V.top();
		V.pop();
		ans++;
	}
	return ans;
}

int main(){
	//freopen("0.in.txt","r",stdin);
	T=readIntLn(1,4);
	while(T--){
		/*for(int i=0;i<1601000;i++){
			sgt[i]=0;
		}
		c=0;*/
		n=readIntSp(1,1000000000);
		k=readIntSp(1,n-2);
		m=readIntLn(1,100000);
		assert(n%2 && k%2);
		int br1 = (n-k)/2 +1;
		int bc1 = (n-k)/2 +1;
		int br2 = br1 + k -1;
		int bc2 = bc1 + k -1;
		for(int i=0;i<m;i++){
			r1[i] = readIntSp(1,n);
			c1[i] = readIntSp(1,n);
			r2[i] = readIntSp(1,n);
			c2[i] = readIntLn(1,n);
			/*arr_comp[c++]=r1[i];
			arr_comp[c++]=c1[i];
			arr_comp[c++]=r2[i];
			arr_comp[c++]=c2[i];*/
			assert(r1[i]==r2[i] || c1[i]==c2[i]);
			if(r1[i] > r2[i]){
				swap(r1[i],r2[i]);
			}
			if(c1[i] > c2[i]){
				swap(c1[i],c2[i]);
			}
			int rr1=max(r1[i],br1);
			int cc1=max(c1[i],bc1);
			int rr2=min(r2[i],br2);
			int cc2=min(c2[i],bc2);

			assert(!(rr1<=rr2 && cc1<=cc2));

		}
		t=0;
		for(int i=0;i<m;i++){
			int L=r1[i],R=r2[i];
			L=max(br1,L);
			R=min(br2,R);
			if(L<=R){
				B[t].first =L;
				B[t].second = R;
				t++;
			}
		}

		int sol=get_ans(br1,br2);

		t=0;

		for(int i=0;i<m;i++){
			int L=c1[i],R=c2[i];
			L=max(br1,L);
			R=min(br2,R);
			if(L<=R){
				B[t].first =L;
				B[t].second = R;
				t++;
			}			
		}
		sol += get_ans(br1,br2);
		if(sol>m){
			cout<<-1<<endl;
		} else {
			cout<<sol<<endl;
		}
		//sort(arr_comp,arr_comp+c);
		/*for(int i=0;i<m;i++){
			if(r1[i]==r2[i]){
				hh[r1[i]].push_back(make_pair(c1[i],c2[i]));
			}
		}
		assert(chk1());
		hh.clear();
		for(int i=0;i<m;i++){
			if(c1[i]==c2[i]){
				hh[c1[i]].push_back(make_pair(r1[i],r2[i]));
			}
		}
		assert(chk1());
		hh.clear();
		assert(check2());
		cout<<0<<endl;*/
	}
	assert(getchar()==-1);
}