#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
typedef pair<int, int> pii;
const int MAXN = 1e5 + 5;

vector<int> g[MAXN];

int deg[MAXN];
bool alive[MAXN];

int clr[MAXN];
bool invalid = 0;
vector<int> vec;
void dfs(int u) {
    if (deg[u] > 3)
        invalid = 1;

    if (deg[u] == 3) {
        vec.emplace_back(u);

        if (vec.size() > 2)
            invalid = 1;
    }

    if (invalid)
        return;

    for (int v : g[u]) {
        if (clr[v] == -1) {
            clr[v] = clr[u] ^ 1;
            dfs(v);
        } else if (clr[v] != (clr[u] ^ 1)) {
            invalid = 1;
        }

        if (invalid)
            return;
    }
}

void solve(void) {
    int n, m;
    cin >> n >> m;

    for (int i = 1; i <= n; ++i)
        g[i].clear();

    for (int i = 1; i <= m; ++i) {
        int u, v;
        cin >> u >> v;
        g[u].emplace_back(v);
        g[v].emplace_back(u);
    }

    queue<int> q;

    for (int i = 1; i <= n; ++i) {
        deg[i] = (int)g[i].size();
        alive[i] = 1;

        if (deg[i] <= 1)
            alive[i] = 0, q.emplace(i);
    }

    while (q.size()) {
        int u = q.front();
        q.pop();

        for (int v : g[u])
            if (alive[v])
                if (--deg[v] <= 1)
                    alive[v] = 0, q.emplace(v);
    }

    for (int u = 1; u <= n; ++u)
        if (alive[u]) {
            vector<int> nxt;

            for (int v : g[u])
                if (alive[v])
                    nxt.emplace_back(v);

            g[u].swap(nxt);
        }

    memset(clr, -1, (n + 1) << 2);
    invalid = 0;

    for (int rt = 1; rt <= n; ++rt)
        if (alive[rt] && clr[rt] == -1) {
            vec.clear();
            clr[rt] = 0;
            dfs(rt);

            if (invalid)
                break;

            if (!vec.size())
                continue;

            int u1 = vec[0], u2 = vec[1];
            int cnt = 0;

            for (int beg : g[u1]) {
                int cur = beg, lst = u1, len = 0;

                while (cur != u2) {
                    ++len;

                    if (g[cur][0] == lst)
                        swap(g[cur][0], g[cur][1]);

                    lst = cur;
                    cur = g[cur][0];
                }

                if (len == 1)
                    ++cnt;
            }

            if (cnt < 2) {
                invalid = 1;
                break;
            }
        }

    cout << (invalid ? "NO\n" : "YES\n");
}

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

    int T;
    cin >> T;

    while (T--)
        solve();

    return 0;
}