// Slower C++ solution:
/*************************************************************************

	> File Name: roadconstruction.cpp

	> Author: 

	> Mail: 

	> Created Time: Mon 09 Jul 2018 11:08:56 AM CST

 ************************************************************************/



#include<cstdio>

#include<vector>

#include<queue>

#include<cstring>

#include<algorithm>

using namespace std;



const int INF = 1e9;



struct edge{

    int to,value,cost;

    edge(){}

    edge(int a,int b,int c):to(a),value(b),cost(c){}

};



typedef pair<int,int> P;

vector<vector<edge> > G(20001);

int d[20001];

int dc[20001];

int V,E;

int sum = 0;



void dijkstra(int s){

    priority_queue<P, vector<P>, greater<P> > que;

    fill(d,d+20001,INF);

    fill(dc,dc+20001,INF);

    d[s] = 0;

    que.push(P(0,s));

    while(!que.empty()){

        P p = que.top();

        que.pop();

        int v = p.second;

        if(d[v]<p.first)continue;

        for(int i=0;i<G[v].size();i++){

            edge e = G[v][i];

            if(d[e.to]>d[v]+e.value){

                d[e.to] = d[v] + e.value;

                que.push(P(d[e.to],e.to));

                dc[e.to] = e.cost; 

            }

            else if(d[e.to]==d[v]+e.value){

                dc[e.to] = min(dc[e.to],e.cost);

            }

        }

    }

}



int main(){

    while(scanf("%d%d",&V,&E)!=-1){

        if(V==0&&E==0)break;

        for(int i=0;i<20001;i++)G[i].clear();

        sum = 0;

        for(int i=0;i<E;i++){

            int a,b,c,d;

            scanf("%d%d%d%d",&a,&b,&c,&d);

            a--;

            b--;

            G[a].push_back(edge(b,c,d));

            G[b].push_back(edge(a,c,d));

        }

        dijkstra(0);

        for(int i=1;i<V;i++)sum+=dc[i];

        printf("%d\n",sum);

    }

    return 0;

}




// Faster C++ solution for the same problem (measured speedup: 1.2281671848459221x):
#include <bits/stdc++.h>

using namespace std;

const int maxn = 2e4+9;

const int inf = 0x3f3f3f3f;

typedef long long int ll;

typedef pair<int,int> pi;

struct {

    int v,nex,d,c;

}e[maxn*2];

int in[maxn];

int dis[maxn];

int head[maxn];

int tot;

void addedge(int u,int v,int d,int c){

    e[tot] ={v,head[u],d,c};

    head[u] = tot++;

}

int dd[maxn];

priority_queue<pi> qq;

int main()

{

    int n,m;

    while(scanf("%d%d",&n,&m)){

            tot =0;

        if(n==0 && m==0 ) break;

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

        memset(dd,0x3f,sizeof(dd));

        memset(dis,0x3f,sizeof(dis));

        memset(in,0,sizeof(in));



        while(!qq.empty()){

            qq.pop();

        }

        qq.push(pi(0,1));

        dis[1] =0;

        dd[1] = 0;



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

            int u,v,d,c;

            scanf("%d%d%d%d",&u,&v,&d,&c);

            addedge(u,v,d,c);

            addedge(v,u,d,c);

        }

        while(!qq.empty()){

            pi now = qq.top();

            qq.pop();

            int pp = now.second;

            if(in[pp]==1) continue;

            in[pp] = 1;

            for(int i=head[pp];i!=-1;i=e[i].nex){

                int v= e[i].v;

                int d = e[i].d;

                if(in[v]==1) continue;

                if( dis[pp]+d<dis[v]){

                    dis[v] = dis[pp]+d;

                    dd[v] = e[i].c;

                    qq.push(pi(-dis[v],v));

                }else if(dis[pp]+d==dis[v]){

                    dd[v] = min(dd[v],e[i].c);

                }

            }

        }

        int ans = 0;

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

            ans+=dd[i];

        }

        printf("%d\n",ans);

    }

    return 0;

}