#include <bits/stdc++.h>

template <class T>
inline int qlog(T a) {
    if (!a) return 0;
	double x = a;
	return ((*(long long*) & x) >> 52 & 2047) - 1023;
}

#define cin Mizuhashi
#define cout Parsee
#define endl '\n'

class Reader{
	private:
	    static const int BUF_SIZE = 1 << 22;
	    char BUF_R[BUF_SIZE], *csy1, *csy2;
	    #ifndef _LOCAL_RUNNING
		    #define GC (csy1 == csy2 && (csy2 = (csy1 = BUF_R) + fread(BUF_R, 1, BUF_SIZE, stdin), csy1 == csy2) ? EOF : *csy1 ++)
		#else
		    char cur;
		    #define GC (cur = getchar())
		#endif
	    #define IL inline
		
    public:
        IL bool eof() {
            #ifndef _LOCAL_RUNNING
                return csy1 == csy2 && (csy2 = (csy1 = BUF_R) + fread(BUF_R, 1, BUF_SIZE, stdin), csy1 == csy2);
            #else
                return cur == EOF;
            #endif
        }
        template <class Ty>
        IL Reader& operator >> (Ty &t) {
            int u = 0;
            char c = GC;
	    	for (t = 0; c < 48 || c > 57; c = GC)
                if (c == EOF) break;
                else if (c == '-') u = 1;
	    	for ( ; c > 47 && c < 58; c = GC) t = (t << 1) + (t << 3) + (c ^ 48);
	    	t = u ? -t : t; return *this;
        }
    	IL Reader& operator >> (double &t) {
            int tmp, u = 0; char c = GC;
	    	for (tmp = 0; c < 48 || c > 57; c = GC)
                if (c == EOF) break;
                else if (c == '-') u = 1;
	    	for ( ; c > 47 && c < 58; c = GC) tmp = (tmp << 1) + (tmp << 3) + (c ^ 48);
	    	t = (tmp = u ? -tmp : tmp);
    	    if (c == '.') {
    	        double x = 1;
    	        for (c = GC; c > 47 && c < 58; c = GC) t += (x /= 10) * (c ^ 48);
    	    }
    	    return *this;
    	}
    	IL Reader& operator >> (char *s) {
			char c = GC;
			for (*s = 0; c < 33; c = GC) if (c == EOF) return *this;
			for ( ; c > 32; c = GC) *s ++ = c;
			*s = 0; return *this;
		}
        IL Reader& operator >> (char &c) {
			for (c = GC; c < 33; c = GC) if (c == EOF) return *this;
            return *this;
        }
}cin;
class Writer{
	private:
	    static const int BUF_SIZE = 1 << 22;
	    char BUF_W[BUF_SIZE], *csy;
	    #define IL inline
		inline void WC(const char c) {
			if (csy - BUF_W == BUF_SIZE) fwrite(BUF_W, 1, BUF_SIZE, stdout), csy = BUF_W;
			*csy ++ = c;
		}
	
	public:
		Writer() : csy(BUF_W) {}
		~ Writer() {fwrite(BUF_W, 1, csy - BUF_W, stdout);}
		IL void flush() {fwrite(BUF_W, 1, csy - BUF_W, stdout); csy = BUF_W;}
		template <class Ty>
		IL Writer& operator << (Ty x) {
		    static int sta[32], top;
			if (x < 0) {
				WC('-');
                do sta[top ++] = - (x % 10); while (x /= 10);
			}else do sta[top ++] = x % 10; while (x /= 10);
			while (top) WC(sta[-- top] ^ 48);
			return *this;
		}
		IL Writer& operator << (const char &c) {WC(c); return *this;}
		IL Writer& operator << (const char *s) {while (*s) WC(*s ++); return *this;}
		IL Writer& operator << (char *s) {while (*s) WC(*s ++); return *this;}
}cout;

using namespace std;

typedef long long ll;
typedef pair <int, int> pii;
typedef unsigned int u32;
typedef unsigned long long u64;
typedef vector <int> vi;
typedef vector <ll> vl;

const int MAX_N = 100000 + 5;
const int MAX_V = 800000 + 5;
const int MAX_E = 8000000 + 5;
const int INF32 = 0x3f3f3f3f;
const ll INF64 = 1e18;
const int P = 998244353;

int N, M, V, S[MAX_N], E[MAX_N], idx[MAX_N];
struct SegmentNode{
	int ls, rs;
	SegmentNode () {ls = rs = 0;}
}node[MAX_V];
int rt[2], tot;
struct Edge{
	int y, prev;
}e[MAX_E];
int elast[MAX_V], ecnt;
int low[MAX_V], dfsn[MAX_V], Tm;
int sta[MAX_V], tp, scc[MAX_V], scc_cnt;
bool vis[MAX_V];

inline bool cmp_by_r(int i, int j) {return E[i] < E[j];}

void Build(int x, int y) {
	ecnt ++;
	e[ecnt].y = y;
	e[ecnt].prev = elast[x];
	elast[x] = ecnt;
}

void tarjan(int u) {
    dfsn[u] = low[u] = ++ Tm;
    sta[++ tp] = u; vis[u] = 1;
    for (int i = elast[u]; i; i = e[i].prev) {
        int v = e[i].y;
        if (!dfsn[v]) {
            tarjan(v);
            low[u] = min(low[u], low[v]);
        }else if (vis[v]) low[u] = min(low[u], dfsn[v]);
    }
    if (dfsn[u] == low[u]) {
        scc_cnt ++;
        while (sta[tp] != u) {
            scc[sta[tp]] = scc_cnt;
            vis[sta[tp --]] = 0;
        }
        scc[sta[tp]] = scc_cnt;
        vis[sta[tp --]] = 0;
    }
}

inline int NewNode() {
	tot ++;
	node[tot] = SegmentNode();
	return tot;
}

void segment_build(int &i, int l, int r, int ty) {
	i = NewNode();
	if (l == r) {
		return ;
	}
	int mid = l + r >> 1;
	segment_build(node[i].ls, l, mid, ty);
	segment_build(node[i].rs, mid + 1, r, ty);
	if (ty) {
		Build(i, node[i].ls);
		Build(i, node[i].rs);
	}else {
		Build(node[i].ls, i);
		Build(node[i].rs, i);
	}
}

void segment_build2(int i, int l, int r, int ty) {
	if (l == r) {
		if (ty) Build(i, idx[l] + tot);
		else Build(idx[l] + tot + N, i);
		return ;
	}
	int mid = l + r >> 1;
	segment_build2(node[i].ls, l, mid, ty);
	segment_build2(node[i].rs, mid + 1, r, ty);
}

void segment_modify(int i, int l, int r, int ql, int qr, int x, int ty) {
	if (l < ql || r > qr) {
		int mid = l + r >> 1;
		if (ql <= mid) segment_modify(node[i].ls, l, mid, ql, qr, x, ty);
		if (mid < qr) segment_modify(node[i].rs, mid + 1, r, ql, qr, x, ty);
	}else {
		if (ty) Build(x, i);
		else Build(i, x);
	}
}

void solve() {
	tot = 0; ecnt = 0;
	memset(elast, 0, sizeof(int) * (V + 1));
	
	scc_cnt = 0;
	memset(dfsn, 0, sizeof(int) * (V + 1));
	
	cin >> N >> M;
	for (int i = 1; i <= N; i ++) {
		cin >> S[i] >> E[i];
		idx[i] = i;
	}
	sort(idx + 1, idx + N + 1, cmp_by_r);
	segment_build(rt[0], 1, N, 0);
	segment_build(rt[1], 1, N, 1);
	segment_build2(rt[0], 1, N, 0);
	segment_build2(rt[1], 1, N, 1);
	for (int i = 2; i <= N; i ++) {
		int l = 1, r = i, p = S[idx[i]];
		while (l < r) {
			int mid = l + r >> 1;
			if (E[idx[mid]] < p) l = mid + 1;
			else r = mid;
		}
		if (l < i) {
			segment_modify(rt[0], 1, N, l, i - 1, idx[i] + tot, 0);
			segment_modify(rt[1], 1, N, l, i - 1, idx[i] + N + tot, 1);
		}
	}
	V = tot + N * 2;
	for (int i = 1; i <= M; i ++) {
		int a, b;
		cin >> a >> b;
		Build(tot + a, tot + b + N);
		Build(tot + b, tot + a + N);
	}
	for (int i = 1; i <= V; i ++) {
		if (!dfsn[i]) tarjan(i);
	}
	for (int i = 1; i <= N; i ++) {
		if (scc[i + tot] == scc[i + tot + N])  {
			cout << "NO" << endl;
			return ;
		}
	}
	cout << "YES" << endl;
}

int main() {
    int T = 1;
    cin >> T;
    while (T --) solve();
    return 0;
}