/*
Author: haze
2023/12/6
12:52
*/

#include <bits/stdc++.h>

#define irep(i, l, r) for(int (i) = (l); (i) <= (r); ++(i))
#define drep(i, r, l) for(int (i) = (r); (i) >= (l); --(i))
#define ll long long
#define ull unsigned long long
#define LL __int128
using namespace std;

inline ll read() {
    char ch = getchar();
    ll s = 0;
    bool w = 0;
    while (!isdigit(ch)) {
        if (ch == '-')w = 1;
        ch = getchar();
    }
    while (isdigit(ch))s = (s << 3) + (s << 1) + (ch ^ 48), ch = getchar();
    return w ? -s : s;
}

inline char rc() {
    char ch = getchar();
    while (1) {
        if (ch >= '!' && ch <= '~')return ch;
        ch = getchar();
    }
}

template<class T1, class T2>
T1 min(T1 AA, T2 BB) { return AA > BB ? BB : AA; }

template<class T1, class T2>
T1 max(T1 AA, T2 BB) { return AA < BB ? BB : AA; }

const int itinf = 1e9;
const ll llinf = 4e18;
const int mod = 1000000007;
const int N = 500009;
const ull mask = chrono::steady_clock::now().time_since_epoch().count();
bool solve(){
    int n = read(), m = read();
    vector<vector<int>>g(n);
    vector<int>deg(n);
    irep(i, 0, m - 1){
        int u = read() - 1, v = read() - 1;
        g[u].emplace_back(v);
        g[v].emplace_back(u);
        deg[u] ++, deg[v] ++;
    }
    if(m == n - 1)return true;
    if(m > n)return false;
    stack<int>st;
    irep(i, 0, n - 1){
        if(deg[i] == 1)
            st.push(i);
    }
    while(st.size()){
        int x = st.top();
        st.pop();
        for(int y : g[x]){
            deg[y] --;
            if(deg[y] == 1)
                st.push(y);
        }
    }
    vector<int>vis(n);

    auto shift = [](ull x) -> ull{
        x ^= mask;
        x ^= x << 13;
        x ^= x >> 7;
        x ^= x << 17;
        x ^= mask;
        return x;
    };
    function<ull(int)> hs = [&](int x) -> ull{
        ull key = 7;
        vis[x] = 1;
        for(int y : g[x]){
            if(! vis[y]){
                key += shift(hs(y));
            }
        }
        return key;
    };
    int S = -1, rc = 0;
    vector<int>ring[2];
    irep(i, 0, n - 1){
        if(deg[i] == 2){
            S = i;
            rc ++;
        }
    }
    function<void(int, int)> dfs = [&](int x, int tp) -> void{
        vis[x] = 1;
        ring[tp].emplace_back(x);
        for(int y : g[x]){
            if(deg[y] == 2 && vis[y] == 0){
                dfs(y, tp ^ 1);
            }
        }
    };
    dfs(S, 0);
    ull K[2];
    irep(op, 0, 1){
        for(int x : ring[op]){
            if(x == ring[op][0])K[op] = hs(x);
            else if(hs(x) != K[op])return false;
        }
        cerr << endl;
    }
    if(rc & 1)return K[0] == K[1];
    return true;
}

int main() {
    int T = read();
    while(T --){
        puts(solve() ? "YES" : "NO");
    }
    return 0;
}
/*
 1
 6 6
 1 2
 2 3
 3 4
 4 1
 5 1
 6 3
 */
/*
4
7 6
1 2
2 3
3 4
4 5
5 6
3 7

3 3
1 2
2 3
3 1

5 5
1 2
2 3
3 4
4 1
1 5

1 0
 */
/*
2 1
1 2
3 2
1 3
2 3
3 3
1 2
1 3
2 3
4 3
1 4
2 4
3 4
4 3
1 3
1 4
2 4
4 4
1 3
1 4
2 4
3 4
4 4
1 3
1 4
2 3
2 4
4 5
1 3
1 4
2 3
2 4
3 4
4 6
1 2
1 3
1 4
2 3
2 4
3 4
5 4
1 5
2 5
3 5
4 5
5 4
1 4
1 5
2 5
3 5
5 5
1 4
1 5
2 5
3 5
4 5
5 5
1 4
1 5
2 4
3 5
4 5
5 5
1 4
1 5
2 4
2 5
3 5
5 6
1 4
1 5
2 4
2 5
 */