#include <bits/stdc++.h>

constexpr int inf32 = (int)(1e9) + 9;
constexpr int N = 100005;
constexpr int M = 2000006;

int n, m, tot;
struct Cond { int u[3], w; }; 
Cond cond[N];
std::vector<int> graph[M];
std::vector<int> hash[N], id[N][4];
int h(int i, int x) { return std::lower_bound(hash[i].begin(), hash[i].end(), x) - hash[i].begin(); }

bool in_sta[M];
int dfn[M], low[M], bel[M], scc, dfc;
std::stack<int> sta;
void tarjan(int u) {
    sta.push(u);
    in_sta[u] = 1;
    low[u] = dfn[u] = ++dfc;
    for (int v : graph[u]) {
        if (!dfn[v]) {
            tarjan(v);
            low[u] = std::min(low[u], low[v]);
        }
        else if (in_sta[v]) {
            low[u] = std::min(low[u], dfn[v]);
        }
    }
    if (low[u] >= dfn[u]) {
        int x;
        scc++;
        do {
            x = sta.top();
            sta.pop();
            in_sta[x] = 0;
            bel[x] = scc;
        }
        while (x != u);
    }
}

int deg[M], tpn[M];
std::vector<int> _graph[M];

int main() {
    std::cin.sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cin >> n >> m;
    for (int i = 1; i <= m; i++) {
        std::cin >> cond[i].u[0] >> cond[i].u[1] >> cond[i].u[2] >> cond[i].w;
        hash[cond[i].u[0]].push_back(cond[i].w);
        hash[cond[i].u[1]].push_back(cond[i].w);
        hash[cond[i].u[2]].push_back(cond[i].w);
    }
    for (int i = 1; i <= n; i++) {
        std::sort(hash[i].begin(), hash[i].end());
        hash[i].resize(std::unique(hash[i].begin(), hash[i].end()) - hash[i].begin());
        for (int o = 0; o < 4; o++) {
            id[i][o].resize(hash[i].size());
            for (int j = 0; j < hash[i].size(); j++) id[i][o][j] = ++tot;
        }
        for (int j = 1; j < hash[i].size(); j++) {
            graph[id[i][0][j - 1]].push_back(id[i][0][j]);
            graph[id[i][1][j - 1]].push_back(id[i][1][j]);
            graph[id[i][2][j]].push_back(id[i][2][j - 1]);
            graph[id[i][3][j]].push_back(id[i][3][j - 1]);
            graph[id[i][1][j - 1]].push_back(id[i][0][j]);
            graph[id[i][2][j]].push_back(id[i][3][j - 1]);
        }
    } 
    for (int i = 1; i <= m; i++)
    for (int x : {0, 1, 2}) for (int y : {0, 1, 2}) {
        if (x == y) continue;
        int u = cond[i].u[x], v = cond[i].u[y], w = cond[i].w;
        int wu = h(u, w), wv = h(v, w);
        graph[id[u][0][wu]].push_back(id[v][2][wv]);
        graph[id[u][3][wu]].push_back(id[v][1][wv]);
    }
    // std::cerr << tot << std::endl;
    for (int i = 1; i <= tot; i++) if (!dfn[i]) tarjan(i);
    // std::cerr << "0:\n";
    // for (int i = 1; i <= n; i++) for (int j = 0; j < hash[i].size(); j++) std::cerr << bel[id[i][0][j]] << " \n"[j + 1 == hash[i].size()];
    // std::cerr << "1:\n";
    // for (int i = 1; i <= n; i++) for (int j = 0; j < hash[i].size(); j++) std::cerr << bel[id[i][1][j]] << " \n"[j + 1 == hash[i].size()];
    // std::cerr << "2:\n";
    // for (int i = 1; i <= n; i++) for (int j = 0; j < hash[i].size(); j++) std::cerr << bel[id[i][2][j]] << " \n"[j + 1 == hash[i].size()];
    // std::cerr << "3:\n";
    // for (int i = 1; i <= n; i++) for (int j = 0; j < hash[i].size(); j++) std::cerr << bel[id[i][3][j]] << " \n"[j + 1 == hash[i].size()];
    // std::cerr << std::endl;
    bool flag = 1;
    for (int i = 1; i <= n; i++) {
        for (int j = 0; j < hash[i].size(); j++) {
            flag &= bel[id[i][0][j]] != bel[id[i][2][j]];
            flag &= bel[id[i][1][j]] != bel[id[i][3][j]];
        }
    }
    if (!flag) puts("NO");
    else {
        for (int i = 1; i <= tot; i++) for (int j : graph[i]) if (bel[i] != bel[j]) {
            _graph[bel[i]].push_back(bel[j]);
            deg[bel[j]]++;
        }
        std::queue<int> que;
        for (int i = 1; i <= scc; i++) if (!deg[i]) que.push(i);
        int cnt = 0;
        while (que.size()) {
            int u = que.front();
            que.pop();
            tpn[u] = ++cnt;
            for (int v : _graph[u]) 
                if (--deg[v] == 0) 
                    que.push(v);
        }
        puts("YES");
        for (int i = 1; i <= n; i++) {
            int ans = inf32;
            for (int j = 0; j < hash[i].size(); j++) {
                if (tpn[bel[id[i][1][j]]] > tpn[bel[id[i][3][j]]]) {
                    ans = hash[i][j];
                    break;
                }
            }
            printf("%d%c", ans, " \n"[i == n]);
        }
    }
    return 0;
}