// https://contest.ucup.ac/submission/596156

// #define _GLIBCXX_DEBUG

// #pragma GCC target("avx2")
// #pragma GCC optimize("O3")
// #pragma GCC optimize("unroll-loops")

#include <bits/stdc++.h>
using namespace std;

#ifdef LOCAL
#include <debug_print.hpp>
#define OUT(...) debug_print::multi_print(#__VA_ARGS__, __VA_ARGS__)
#else
#define OUT(...) (static_cast<void>(0))
#endif

#define endl '\n'
#define lfs cout << fixed << setprecision(15)
#define ALL(a) (a).begin(), (a).end()
#define ALLR(a) (a).rbegin(), (a).rend()
#define UNIQUE(a) (a).erase(unique((a).begin(), (a).end()), (a).end())
#define spa << " " <<
#define fi first
#define se second
#define MP make_pair
#define MT make_tuple
#define PB push_back
#define EB emplace_back
#define rep(i, n, m) for (ll i = (n); i < (ll)(m); i++)
#define rrep(i, n, m) for (ll i = (ll)(m) - 1; i >= (ll)(n); i--)

namespace template_tute {
using ll      = long long;
using ld      = long double;
const ll MOD1 = 1e9 + 7;
const ll MOD9 = 998244353;
const ll INF  = 1e18;
using P       = pair<ll, ll>;
template <typename T>
using PQ = priority_queue<T>;
template <typename T>
using QP = priority_queue<T, vector<T>, greater<T>>;
template <typename T1, typename T2>
bool chmin(T1 &a, T2 b) {
    if (a > b) {
        a = b;
        return true;
    } else
        return false;
}
template <typename T1, typename T2>
bool chmax(T1 &a, T2 b) {
    if (a < b) {
        a = b;
        return true;
    } else
        return false;
}
ll median(ll a, ll b, ll c) {
    return a + b + c - max<ll>({a, b, c}) - min<ll>({a, b, c});
}
void ans1(bool x) {
    if (x)
        cout << "Yes" << endl;
    else
        cout << "No" << endl;
}
void ans2(bool x) {
    if (x)
        cout << "YES" << endl;
    else
        cout << "NO" << endl;
}
void ans3(bool x) {
    if (x)
        cout << "Yay!" << endl;
    else
        cout << ":(" << endl;
}
template <typename T1, typename T2>
void ans(bool x, T1 y, T2 z) {
    if (x)
        cout << y << endl;
    else
        cout << z << endl;
}
template <typename T1, typename T2, typename T3>
void anss(T1 x, T2 y, T3 z) {
    ans(x != y, x, z);
};
template <typename T>
void debug(const T &v, ll h, ll w, string sv = " ") {
    for (ll i = 0; i < h; i++) {
        cout << v[i][0];
        for (ll j = 1; j < w; j++) cout << sv << v[i][j];
        cout << endl;
    }
};
template <typename T>
void debug(const T &v, ll n, string sv = " ") {
    if (n != 0) cout << v[0];
    for (ll i = 1; i < n; i++) cout << sv << v[i];
    cout << endl;
};
template <typename T>
void debug(const vector<T> &v) {
    debug(v, v.size());
}
template <typename T>
void debug(const vector<vector<T>> &v) {
    for (auto &vv : v) debug(vv, vv.size());
}
template <typename T>
void debug(stack<T> st) {
    while (!st.empty()) {
        cout << st.top() << " ";
        st.pop();
    }
    cout << endl;
}
template <typename T>
void debug(queue<T> st) {
    while (!st.empty()) {
        cout << st.front() << " ";
        st.pop();
    }
    cout << endl;
}
template <typename T>
void debug(deque<T> st) {
    while (!st.empty()) {
        cout << st.front() << " ";
        st.pop_front();
    }
    cout << endl;
}
template <typename T>
void debug(PQ<T> st) {
    while (!st.empty()) {
        cout << st.top() << " ";
        st.pop();
    }
    cout << endl;
}
template <typename T>
void debug(QP<T> st) {
    while (!st.empty()) {
        cout << st.top() << " ";
        st.pop();
    }
    cout << endl;
}
template <typename T>
void debug(const set<T> &v) {
    for (auto z : v) cout << z << " ";
    cout << endl;
}
template <typename T>
void debug(const multiset<T> &v) {
    for (auto z : v) cout << z << " ";
    cout << endl;
}
template <typename T, size_t size>
void debug(const array<T, size> &a) {
    for (auto z : a) cout << z << " ";
    cout << endl;
}
template <typename T, typename V>
void debug(const map<T, V> &v) {
    for (auto z : v) cout << "[" << z.first << "]=" << z.second << ",";
    cout << endl;
}
template <typename T>
vector<vector<T>> vec(ll x, ll y, T w) {
    vector<vector<T>> v(x, vector<T>(y, w));
    return v;
}
vector<ll> dx = {1, -1, 0, 0, 1, 1, -1, -1};
vector<ll> dy = {0, 0, 1, -1, 1, -1, 1, -1};
template <typename T>
vector<T> make_v(size_t a, T b) {
    return vector<T>(a, b);
}
template <typename... Ts>
auto make_v(size_t a, Ts... ts) {
    return vector<decltype(make_v(ts...))>(a, make_v(ts...));
}
template <typename T1, typename T2>
ostream &operator<<(ostream &os, const pair<T1, T2> &p) {
    return os << "(" << p.first << "," << p.second << ")";
}
template <typename T>
ostream &operator<<(ostream &os, const vector<T> &v) {
    os << "[";
    for (auto &z : v) os << z << ",";
    os << "]";
    return os;
}
template <typename T>
void rearrange(vector<int> &ord, vector<T> &v) {
    auto tmp = v;
    for (int i = 0; i < tmp.size(); i++) v[i] = tmp[ord[i]];
}
template <typename Head, typename... Tail>
void rearrange(vector<int> &ord, Head &&head, Tail &&...tail) {
    rearrange(ord, head);
    rearrange(ord, tail...);
}
template <typename T>
vector<int> ascend(const vector<T> &v) {
    vector<int> ord(v.size());
    iota(ord.begin(), ord.end(), 0);
    sort(ord.begin(), ord.end(),
         [&](int i, int j) { return make_pair(v[i], i) < make_pair(v[j], j); });
    return ord;
}
template <typename T>
vector<int> descend(const vector<T> &v) {
    vector<int> ord(v.size());
    iota(ord.begin(), ord.end(), 0);
    sort(ord.begin(), ord.end(),
         [&](int i, int j) { return make_pair(v[i], -i) > make_pair(v[j], -j); });
    return ord;
}
template <typename T>
vector<T> inv_perm(const vector<T> &ord) {
    vector<T> inv(ord.size());
    for (int i = 0; i < ord.size(); i++) inv[ord[i]] = i;
    return inv;
}
ll FLOOR(ll n, ll div) {
    assert(div > 0);
    return n >= 0 ? n / div : (n - div + 1) / div;
}
ll CEIL(ll n, ll div) {
    assert(div > 0);
    return n >= 0 ? (n + div - 1) / div : n / div;
}
ll digitsum(ll n) {
    ll ret = 0;
    while (n) {
        ret += n % 10;
        n /= 10;
    }
    return ret;
}
ll modulo(ll n, ll d) {
    return (n % d + d) % d;
};
template <typename T>
T min(const vector<T> &v) {
    return *min_element(v.begin(), v.end());
}
template <typename T>
T max(const vector<T> &v) {
    return *max_element(v.begin(), v.end());
}
template <typename T>
T acc(const vector<T> &v) {
    return accumulate(v.begin(), v.end(), T(0));
};
template <typename T>
T reverse(const T &v) {
    return T(v.rbegin(), v.rend());
};
// mt19937 mt(chrono::steady_clock::now().time_since_epoch().count());
int popcount(ll x) {
    return __builtin_popcountll(x);
};
int poplow(ll x) {
    return __builtin_ctzll(x);
};
int pophigh(ll x) {
    return 63 - __builtin_clzll(x);
};
template <typename T>
T poll(queue<T> &q) {
    auto ret = q.front();
    q.pop();
    return ret;
};
template <typename T>
T poll(priority_queue<T> &q) {
    auto ret = q.top();
    q.pop();
    return ret;
};
template <typename T>
T poll(QP<T> &q) {
    auto ret = q.top();
    q.pop();
    return ret;
};
template <typename T>
T poll(stack<T> &s) {
    auto ret = s.top();
    s.pop();
    return ret;
};
ll MULT(ll x, ll y) {
    if (LLONG_MAX / x <= y) return LLONG_MAX;
    return x * y;
}
ll POW2(ll x, ll k) {
    ll ret = 1, mul = x;
    while (k) {
        if (mul == LLONG_MAX) return LLONG_MAX;
        if (k & 1) ret = MULT(ret, mul);
        mul = MULT(mul, mul);
        k >>= 1;
    }
    return ret;
}
ll POW(ll x, ll k) {
    ll ret = 1;
    for (int i = 0; i < k; i++) {
        if (LLONG_MAX / x <= ret) return LLONG_MAX;
        ret *= x;
    }
    return ret;
}
std::ostream &operator<<(std::ostream &dest, __int128_t value) {
    std::ostream::sentry s(dest);
    if (s) {
        __uint128_t tmp = value < 0 ? -value : value;
        char buffer[128];
        char *d = std::end(buffer);
        do {
            --d;
            *d = "0123456789"[tmp % 10];
            tmp /= 10;
        } while (tmp != 0);
        if (value < 0) {
            --d;
            *d = '-';
        }
        int len = std::end(buffer) - d;
        if (dest.rdbuf()->sputn(d, len) != len) {
            dest.setstate(std::ios_base::badbit);
        }
    }
    return dest;
}
namespace converter {
int dict[500];
const string lower  = "abcdefghijklmnopqrstuvwxyz";
const string upper  = "ABCDEFGHIJKLMNOPQRSTUVWXYZ";
const string digit  = "0123456789";
const string digit1 = "123456789";
void regi_str(const string &t) {
    for (int i = 0; i < t.size(); i++) {
        dict[t[i]] = i;
    }
}
void regi_int(const string &t) {
    for (int i = 0; i < t.size(); i++) {
        dict[i] = t[i];
    }
}
vector<int> to_int(const string &s, const string &t) {
    regi_str(t);
    vector<int> ret(s.size());
    for (int i = 0; i < s.size(); i++) {
        ret[i] = dict[s[i]];
    }
    return ret;
}
vector<int> to_int(const string &s) {
    auto t = s;
    sort(t.begin(), t.end());
    t.erase(unique(t.begin(), t.end()), t.end());
    return to_int(s, t);
}

vector<vector<int>> to_int(const vector<string> &s, const string &t) {
    regi_str(t);
    vector<vector<int>> ret(s.size(), vector<int>(s[0].size()));
    for (int i = 0; i < s.size(); i++) {
        for (int j = 0; j < s[0].size(); j++) {
            ret[i][j] = dict[s[i][j]];
        }
    }
    return ret;
}
vector<vector<int>> to_int(const vector<string> &s) {
    string t;
    for (int i = 0; i < s.size(); i++) {
        t += s[i];
    }
    sort(t.begin(), t.end());
    t.erase(unique(t.begin(), t.end()), t.end());
    return to_int(s, t);
}
string to_str(const vector<int> &s, const string &t) {
    regi_int(t);
    string ret;
    for (auto z : s) ret += dict[z];
    return ret;
}
vector<string> to_str(const vector<vector<int>> &s, const string &t) {
    regi_int(t);
    vector<string> ret(s.size());
    for (int i = 0; i < s.size(); i++) {
        for (auto z : s[i]) ret[i] += dict[z];
    }
    return ret;
}
} // namespace converter
template <typename T = int>
struct edge {
    int to;
    T cost;
    int id;
    edge() : to(-1), id(-1) {};
    edge(int to, T cost = 1, int id = -1) : to(to), cost(cost), id(id) {}
    operator int() const {
        return to;
    }
};

template <typename T>
using Graph = vector<vector<edge<T>>>;
template <typename T>
Graph<T> revgraph(const Graph<T> &g) {
    Graph<T> ret(g.size());
    for (int i = 0; i < g.size(); i++) {
        for (auto e : g[i]) {
            int to = e.to;
            e.to   = i;
            ret[to].push_back(e);
        }
    }
    return ret;
}
template <typename T>
Graph<T> readGraph(int n, int m, int indexed = 1, bool directed = false, bool weighted = false) {
    Graph<T> ret(n);
    for (int es = 0; es < m; es++) {
        int u, v;
        T w = 1;
        cin >> u >> v;
        u -= indexed, v -= indexed;
        if (weighted) cin >> w;
        ret[u].emplace_back(v, w, es);
        if (!directed) ret[v].emplace_back(u, w, es);
    }
    return ret;
}
template <typename T>
Graph<T> readParent(int n, int indexed = 1, bool directed = true) {
    Graph<T> ret(n);
    for (int i = 1; i < n; i++) {
        int p;
        cin >> p;
        p -= indexed;
        ret[p].emplace_back(i);
        if (!directed) ret[i].emplace_back(p);
    }
    return ret;
}
} // namespace template_tute
using namespace template_tute;

template <typename T>
struct Lowlink {
    const Graph<T> G;
    int size;
    vector<int> ord, low, used;
    vector<int> articulation;
    vector<pair<int, int>> bridge;
    Lowlink(const Graph<T> &g) : G(g) {
        size = G.size();
        ord.assign(size, -1);
        low.assign(size, -1);
        used.assign(size, 0);
        int tmp = 0;
        for (int i = 0; i < size; i++) {
            if (!used[i]) {
                dfs(i, tmp, -1);
            }
        }
    }
    void dfs(int k, int &num, int par) {
        ord[k] = num;
        low[k] = num;
        num++;
        used[k]              = 1;
        int cnt              = 0;
        bool is_articulation = false;
        bool multiple        = false;
        for (int i = 0; i < G[k].size(); i++) {
            if (!multiple && par == G[k][i]) {
                multiple = true;
                continue;
            }
            if (used[G[k][i]]) {
                chmin(low[k], ord[G[k][i]]);
            } else {
                cnt++;
                dfs(G[k][i], num, k);
                chmin(low[k], low[G[k][i]]);
                if (ord[k] < low[G[k][i]]) bridge.emplace_back(k, G[k][i]);
                if (ord[k] <= low[G[k][i]] && par != -1) is_articulation = true;
            }
        }
        if (par == -1 && cnt >= 2) is_articulation = true;
        if (is_articulation) articulation.push_back(k);
        return;
    }
    vector<int> tecc_index; // 二重辺連結成分の番号
    Graph<T> tecc_graph;
    int TECC() {
        tecc_index.assign(G.size(), -1);
        int cnt = 0;
        for (int i = 0; i < size; i++) {
            if (tecc_index[i] == -1) dfs_tecc(i, -1, cnt);
        }
        tecc_graph.assign(cnt, vector<edge<T>>());
        for (int i = 0; i < bridge.size(); i++) {
            int u = tecc_index[bridge[i].fi], v = tecc_index[bridge[i].se];
            tecc_graph[u].emplace_back(v);
            tecc_graph[v].emplace_back(u);
        }
        return *max_element(tecc_index.begin(), tecc_index.end()) + 1;
    }
    void dfs_tecc(int k, int par, int &group) {
        if (par == -1 || ord[par] < low[k]) {
            tecc_index[k] = group++;
        } else
            tecc_index[k] = tecc_index[par];
        for (int i = 0; i < G[k].size(); i++) {
            if (tecc_index[G[k][i]] == -1) dfs_tecc(G[k][i], k, group);
        }
    }
    vector<vector<pair<int, int>>> bcc;
    stack<pair<int, int>> tmp;
    void BCC() {
        used.assign(G.size(), false);
        for (int i = 0; i < G.size(); i++) {
            if (!used[i]) {
                dfs_bcc(i, -1);
            }
        }
    }
    void dfs_bcc(int k, int par) {
        used[k] = true;
        for (int to : G[k]) {
            if (to == par) continue;
            if (!used[to] | ord[to] < ord[k]) {
                tmp.emplace(minmax(k, to));
            }
            if (!used[to]) {
                dfs_bcc(to, k);
                if (low[to] >= ord[k]) {
                    bcc.emplace_back();
                    while (1) {
                        auto e = tmp.top();
                        bcc.back().emplace_back(e);
                        tmp.pop();
                        if (e.first == min(k, to) && e.second == max(k, to)) break;
                    }
                }
            }
        }
    }
    Graph<T> bct_graph;
    vector<int> bct_index;
    vector<bool> art;
    // BCC:bccのindexと一致
    // 関節点:以降
    void makeBCT() {
        assert(bcc.empty());
        BCC();
        art.assign(G.size(), false);
        bct_index.assign(G.size(), -1);
        bct_graph.resize(bcc.size() + articulation.size());
        for (int i = 0; i < articulation.size(); i++) {
            bct_index[articulation[i]] = i + bcc.size();
            bct_graph.emplace_back();
            art[articulation[i]] = true;
        }
        vector<bool> check(G.size(), false);
        int idx = 0;
        for (auto &ev : bcc) {
            bct_graph.emplace_back();
            queue<int> rev;
            for (auto &e : ev) {
                for (auto &v : {e.first, e.second}) {
                    if (art[v] && !check[v]) {
                        rev.push(v);
                        check[v] = true;
                        bct_graph[idx].emplace_back(bct_index[v]);
                        bct_graph[bct_index[v]].emplace_back(idx);
                    } else if (!art[v]) {
                        bct_index[v] = idx;
                    }
                }
            }
            while (!rev.empty()) {
                check[rev.front()] = false;
                rev.pop();
            }
            idx++;
        }
    }
};
template <typename T>
vector<int> nibu_graph(const Graph<T> &g) {
    int n = g.size();
    vector<int> t(n, -1);
    queue<int> que;
    for (ll i = 0; i < n; i++) {
        if (t[i] != -1) continue;
        que.push(i);
        t[i] = 0;
        while (!que.empty()) {
            auto p = que.front();
            que.pop();
            for (auto e : g[p]) {
                if (t[e.to] == -1) {
                    que.push(e.to);
                    t[e.to] = t[p] ^ e.cost;
                } else if (t[p] != (t[e.to] ^ e.cost))
                    return vector<int>();
            }
        }
    }
    return t;
}
template <typename T>
vector<pair<bool, vector<vector<int>>>> nibu_graph_con(const Graph<T> &g) {
    int n = g.size();
    vector<pair<bool, vector<vector<int>>>> v;
    vector<int> t(n, -1);
    queue<int> que;
    for (ll i = 0; i < n; i++) {
        if (t[i] != -1) continue;
        que.emplace(i);
        v.emplace_back(true, vector<vector<int>>(2));
        t[i] = 0;
        while (!que.empty()) {
            auto p = que.front();
            que.pop();
            v.back().second[t[p]].push_back(p);
            for (auto e : g[p]) {
                if (t[e.to] == -1) {
                    que.push(e.to);
                    t[e.to] = t[p] ^ e.cost;
                } else if (t[p] != (t[e.to] ^ e.cost))
                    v.back().first = false;
            }
        }
    }
    return v;
}
void solve() {
    ll res = 0, buf = 0;
    bool judge = true;

    ll n, m;
    cin >> n >> m;
    auto g  = readGraph<ll>(n, m);
    bool sw = true;
    if (nibu_graph(g).empty()) sw = false;
    Lowlink<ll> low(g);
    low.BCC();
    vector<ll> deg(n, 0);
    for (int i = 0; i < n; i++) {
        deg[i] = g[i].size();
    }
    for (auto z : low.bcc) {
        if (z.size() > 4) {
            map<ll, ll> mp;
            for (auto e : z) mp[e.fi]++, mp[e.se]++;
            vector<P> p;
            for (auto e : mp) p.EB(e.se, e.fi);
            sort(ALLR(p));
            int c = 0;
            for (auto e : z) {
                bool ok = false;
                int tt  = e.fi + e.se;
                for (auto t : {e.fi, e.se}) {
                    if (p[0].se == t) {
                        ok = true;
                        if (deg[tt - t] > 2) c++;
                    }
                    if (p[1].se == t) {
                        ok = true;
                        if (deg[tt - t] > 2) c++;
                    }
                }
                if (!ok) {
                    sw = false;
                    break;
                }
            }
            if (c >= 4) {
                sw = false;
                break;
            }
        }
    }
    ans2(sw);
}

int main() {
    cin.tie(nullptr);
    ios_base::sync_with_stdio(false);
    ll res = 0, buf = 0;
    bool judge = true;
    int T      = 1;
    cin >> T;
    while (T--) {
        solve();
    }
    return 0;
}