flow with bound

#include <cstdio>
#include <cstring>

#include <algorithm>
#include <queue>

using namespace std;

struct edge {
    int v, w;
    edge *next, *rev;
};

const int N = 210, M = 10210, S = 0, T = N - 1, INF = 1e8;

static edge pool[2 * (N + M)];

int n, m;
int d[N], level[N];
int l[M];
bool vis[N];
edge* g[N];

edge* add_edge(int u, int v, int w);
void link(int u, int v, int w);
int dinic();
bool bfs();
int dfs(int u, int lim);

int main() {
    int expected = 0;
    scanf("%d%d", &n, &m);
    for (int i = 1; i <= m; ++i) {
        int u, v, r;
        scanf("%d%d%d%d", &u, &v, &l[i], &r);
        r -= l[i];
        d[u] += l[i];
        d[v] -= l[i];
        link(u, v, r);
    }
    for (int i = 1; i <= n; ++i)
        if (d[i] > 0) {
            expected += d[i];
            link(i, T, d[i]);
        } else if (d[i] < 0)
            link(S, i, -d[i]);
    if (dinic() == expected) {
        puts("YES");
        for (int i = 1; i <= m; ++i)
            printf("%d\n", pool[i * 2 - 1].w + l[i]);
    } else
        puts("NO");
    return 0;
}

int dinic() {
    int ret = 0;
    while (bfs())
        ret += dfs(S, INF);
    return ret;
}

bool bfs() {
    memset(vis, 0, sizeof(vis));
    queue<int> q;
    q.push(S);
    while (!q.empty()) {
        int u = q.front();
        q.pop();
        vis[u] = true;
        for (edge* p = g[u]; p; p = p->next)
            if (!vis[p->v] && p->w) {
                level[p->v] = level[u] + 1;
                q.push(p->v);
            }
    }
    return vis[T];
}

int dfs(int u, int lim) {
    if (u == T)
        return lim;
    int ret = 0;
    for (edge* p = g[u]; p && lim; p = p->next)
        if (level[u] < level[p->v] && p->w) {
            int f = dfs(p->v, min(lim, p->w));
            lim -= f;
            p->w -= f;
            p->rev->w += f;
            ret += f;
        }
    if (!ret)
        level[u] = -1;
    return ret;
}

void link(int u, int v, int w) {
    edge *p = add_edge(u, v, w);
    edge *q = add_edge(v, u, 0);
    p->rev = q;
    q->rev = p;
}

edge* add_edge(int u, int v, int w) {
    static edge* p = pool;
    p->v = v;
    p->w = w;
    p->next = g[u];
    g[u] = p;
    return p++;
}