#include<cstdio>

#include<iostream>

#include<cmath>

#include<cstring>

#include<algorithm>

using namespace std;

const int N=;

const int M=;

const int INF=;

inline int read(){

    int X=,w=;char ch=;

    while(!isdigit(ch)){w|=ch=='-';ch=getchar();}

    while(isdigit(ch))X=(X<<)+(X<<)+(ch^),ch=getchar();

    return w?-X:X;

}

struct node{

    int nxt;

    int to;

    int w;

}edge[M];

int head[*N],low[M],out[N],in[N],cnt=-;

inline void add(int u,int v,int w){

    cnt++;

    edge[cnt].to=v;

    edge[cnt].w=w;

    edge[cnt].nxt=head[u];

    head[u]=cnt;

    return;

}

int lev[N],cur[N];

bool bfs(int m){//强制1为源点，m为汇点

    int dui[m],r=;

    for(int i=;i<=m;i++){

        lev[i]=-;

        cur[i]=head[i];

    }

    dui[]=,lev[]=;

    int u,v;

    for(int l=;l<=r;l++){

        u=dui[l];

        for(int e=head[u];e!=-;e=edge[e].nxt){

            v=edge[e].to;

            if(edge[e].w>&&lev[v]==-){

                lev[v]=lev[u]+;

                r++;

                dui[r]=v;

                if(v==m)return ;

            }

        }

    }

    return ;

}

int dinic(int u,int flow,int m){

    if(u==m)return flow;

    int res=,delta;

    for(int &e=cur[u];e!=-;e=edge[e].nxt){

        int v=edge[e].to;

        if(edge[e].w>&&lev[u]<lev[v]){

            delta=dinic(v,min(edge[e].w,flow-res),m);

            if(delta>){

                edge[e].w-=delta;

                edge[e^].w+=delta;

                res+=delta;

                if(res==flow)break;

            }

        }

    }

    if(res!=flow)lev[u]=-;

    return res;

}

inline void init(){

    memset(head,-,sizeof(head));

    memset(in,,sizeof(in));

    memset(out,,sizeof(out));

    cnt=-;

    return;

}

int main(){

    int t=read(),num=;

    while(t--){

    init();num++;

    if(num>)puts("");

    int n=read(),m=read();

    for(int i=;i<=m;i++){

        int u=read()+,v=read()+;

        low[i]=read();

        int up=read();

        add(u,v,up-low[i]);

        add(v,u,);

        out[u]+=low[i];

        in[v]+=low[i];

    }

    int st=,ed=n+,ans=,full=;

    for(int i=;i<=n+;i++){

        if(out[i]<in[i]){

        add(st,i,in[i]-out[i]);

        add(i,st,);

        full+=in[i]-out[i];

        }else{

        add(i,ed,out[i]-in[i]);

        add(ed,i,);

        }

    }

    while(bfs(ed)==)ans+=dinic(st,INF,ed);

    if(ans!=full)puts("NO");

    else{

        puts("YES");

        for(int i=;i<m;i++){

        printf("%d\n",edge[i*+].w+low[i+]);

        }

    }

    }

    return ;

}