#include <iostream>
#include <vector>
#include <algorithm>
#include <ranges>
#include <random>
#include <chrono>

struct UnionFind {
    std::vector<int> a;

    UnionFind(int n) : a(n, -1) {}

    auto find(int idx) -> int {
        if (a[idx] < 0)
            return idx;
        else
            return a[idx] = find(a[idx]);
    }

    auto unite(int l, int r) -> bool {
        l = find(l);
        r = find(r);

        if (l == r)
            return false;

        if (-a[l] < -a[r])
            std::swap(l, r);

        a[l] += a[r];
        a[r] = l;

        return true;
    }

    void reset() {
        std::fill(a.begin(), a.end(), -1);
    }
};

int main() {

    auto cl = std::chrono::high_resolution_clock{};
    auto now = cl.now();
    int n, m;
    std::cin >> n >> m;


    // auto adj = std::vector<std::vector<std::pair<int, int>>>(n);
    auto edges = std::vector<std::tuple<int, int, int>>{};
    for (int i = 0; i < m; i++) {
        int u, v;
        std::cin >> u >> v;

        u--, v--;

        edges.push_back({0, u, v});
    }

    std::shuffle(edges.begin(), edges.end(), std::mt19937{std::random_device{}()});

    auto q = std::vector<std::vector<int>>{};
    auto dsu = UnionFind(n);

    for (int i = 1; i <= 50'000 && std::chrono::duration_cast<std::chrono::milliseconds>(cl.now() - now).count() < 1900; i++) {
        // std::cout << i << '\n';
        dsu.reset();

        std::ranges::sort(edges, {}, [&](auto e) { return std::get<0>(e); });
        // std::ranges::sort(edges);

        auto used = std::vector<std::pair<int, int>>{};
        auto adj = std::vector<std::vector<int>>(n);
        auto deg = std::vector<int>(n);

        for (auto &[w, u, v] : edges) {
            if (dsu.unite(u, v)) {
                used.push_back({u, v});
                adj[u].push_back(v);
                deg[v] += 1;
            }
        }

            auto in0 = std::vector<int>{};
            for (int i = 0; i < n; i++) {
                if (deg[i] == 0)
                    in0.push_back(i);
            }

            auto s = std::vector<int>{};
            while (!in0.empty()) {
                auto x = in0.back();
                in0.pop_back();
                s.push_back(x);
                for (auto y : adj[x]) {
                    deg[y] -= 1;
                    if (deg[y] == 0)
                        in0.push_back(y);
                }
            }

            auto &res = s;
        for (auto &[w, u, v] : edges) {
            if (std::find(res.begin(), res.end(), u) - res.begin() < std::find(res.begin(), res.end(), v) - res.begin())
                w += 1;
        }
        q.push_back(std::move(res));

        auto min_w = std::get<0>(edges[0]);
        for (int i = 0; i < m; i++) {
            min_w = std::min(min_w, std::get<0>(edges[i]));
        }

        if (min_w >= i / 2 + 1) {
            std::cout << "YES\n";
            // std::cerr << min_w << ' ' << i << '\n';
            std::cout << q.size() << '\n';
            for (auto &v : q) {
                for (auto x : v) {
                    std::cout << x + 1 << ' ';
                }
                std::cout << '\n';
            }
            return 0;
        }
    }
    std::cout << "NO\n";
}