stablegradients/pie-gem5-pairs huggingface dataset:
// Slower C++ solution:
#include <queue>

#include <vector>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <iostream>

#include <algorithm>

const int INF=0x3f3f3f3f;

using namespace std;

struct edge{

    int to,cost,w;

};

int V,d[10005],dis[10005];

vector<edge> G[20005];

typedef pair<int,int> P;

void dijkstra(int s){

    int i,v;

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

	fill(d,d+V+1,INF);

	fill(dis,dis+V+1,INF);

	d[s]=dis[s]=0;

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

	while(!que.empty()){

		P p=que.top(); que.pop();

		v=p.second;

		if(d[v]<p.first)

        continue;

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

			edge e=G[v][i];

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

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

                dis[e.to]=e.w;

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

			}

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

            dis[e.to]=min(dis[e.to],e.w);

		}

	}

}

int main(){

    int m,st,en,i,j,x,y,z,q,ans;

    edge temp;

    while(scanf("%d%d",&V,&m)!=EOF&&(V||m)){

        for(i=0;i<=V;i++)

        G[i].clear();

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

            scanf("%d%d%d%d",&x,&y,&z,&q);

            temp.to=y;temp.cost=z;temp.w=q;

            G[x].push_back(temp);

            temp.to=x;

            G[y].push_back(temp);

        }

        dijkstra(1);

        ans=0;

        for(i=1;i<=V;i++)

        ans+=dis[i];

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

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.193491169793423x):
#include <cstdio>

#include <iostream>

#include <cstring>

#include <string>

#include <algorithm>

#include <vector>

#include <queue>

const int maxn = 10007;

const int inf =1e9;

using namespace std;

struct node{

	int to,d,c;

	node(){}

	node (int to,int d,int c):to(to),d(d),c(c){}

};

vector<node>mp[maxn];

int dis[maxn],cost[maxn],n,m,ans = 0;

void init(){

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

	{

		mp[i].clear();

		dis[i] = inf;

		cost[i]  = 0;

	}

}

void add(int u,int v,int d,int c)

{

	mp[u].push_back(node(v,d,c));

}

int main(){

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

	{

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

		init();

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

		{

			int u,v,d,c;

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

			add(u,v,d,c);

			add(v,u,d,c);

		}

		priority_queue<pair<int,int> >q;

		dis[1]=0;

		cost[1]=0;

		

		q.push (make_pair(-dis[1],1)) ;

		while(!q.empty())

		{

			int now = q.top().second;

			q.pop();

			for(int i=0;i<mp[now].size();i++)

			{

				int v=mp[now][i].to;

				int d=mp[now][i].d;

				int c=mp[now][i].c;

				if(dis[v]>dis[now]+d)

				{

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

					//ans -=cost[v];

					//cost[v] = cost[now]+c;

					//ans +=cost[v];

					q.push (make_pair(-dis[v],v));

				}

			}

		}

		ans = 0;

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

		{

			int minc = inf;

			for(int j=0;j<mp[i].size();j++)

			{

				node tmp = mp[i][j];

				if(tmp.d+dis[tmp.to]==dis[i]&&minc>tmp.c)

				{

					minc = mp[i][j].c;

				}

			}

			ans += minc;

		}

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

	}

	return 0;

}
// Slower C++ solution:
#include<iostream>

#include<vector>

#include<queue>

#include<algorithm>

#include<cstring>

using namespace std;

const int maxn  = 1e4+10;

const int INF = 0x3f3f3f3f;

typedef pair<int,int> P;

struct edge{

	int to,dis,cost;

		

};



int d[maxn];

int value[maxn];



int N,M;



int dijkstra(vector<edge>G[])

{



	memset(d,INF,sizeof(d));

	//memset(value,INF,sizeof(value));

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

		

	d[1] = 0;

	value[1] = 0;

	que.push(P(d[1],1));

	

	int res = 0;

	while(!que.empty())

	{

		P p  = que.top(); que.pop();

		

		int v = p.second;

		if(d[v] < p.first)

			continue;

			

		res += value[v];

		

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

		{

			edge e = G[v][i];

			if(d[e.to] == d[v] + e.dis)

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

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

			{

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

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

				

				value[e.to] = e.cost;

			}

		}

	}

	return res;

	

}



int main()

{



	//freopen("c:\\users\\administrator\\desktop\\in.txt","r",stdin);

	while(cin >> N >> M, N||M)

	{

		

		vector<edge> G[maxn];

		for(int i =0; i < M; i++)

		{

			int u,v,d,c;

			edge e;

			cin >> u >> v >> d >> c;

			e.to= v, e.dis= d, e.cost =c;

			G[u].push_back(e);

			e.to= u;

			G[v].push_back(e);	

		}

		

		int res = dijkstra(G);

		cout << res <<endl;

	}		

} 

// Faster C++ solution for the same problem (measured speedup: 1.1432239521130418x):
#include <cstdio>

#include <iostream>

#include <cstring>

#include <string>

#include <algorithm>

#include <vector>

#include <queue>

const int maxn = 10007;

const int inf =1e9;

using namespace std;

struct node{

	int to,d,c;

	node(){}

	node (int to,int d,int c):to(to),d(d),c(c){}

};

vector<node>mp[maxn];

int dis[maxn],cost[maxn],n,m,ans = 0;

void init(){

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

	{

		mp[i].clear();

		dis[i] = inf;

		cost[i]  = 0;

	}

}

void add(int u,int v,int d,int c)

{

	mp[u].push_back(node(v,d,c));

}

int main(){

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

	{

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

		init();

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

		{

			int u,v,d,c;

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

			add(u,v,d,c);

			add(v,u,d,c);

		}

		priority_queue<pair<int,int> >q;

		dis[1]=0;

		cost[1]=0;

		

		q.push (make_pair(-dis[1],1)) ;

		while(!q.empty())

		{

			int now = q.top().second;

			q.pop();

			for(int i=0;i<mp[now].size();i++)

			{

				int v=mp[now][i].to;

				int d=mp[now][i].d;

				int c=mp[now][i].c;

				if(dis[v]>dis[now]+d)

				{

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

					//ans -=cost[v];

					//cost[v] = cost[now]+c;

					//ans +=cost[v];

					q.push (make_pair(-dis[v],v));

				}

			}

		}

		ans = 0;

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

		{

			int minc = inf;

			for(int j=0;j<mp[i].size();j++)

			{

				node tmp = mp[i][j];

				if(tmp.d+dis[tmp.to]==dis[i]&&minc>tmp.c)

				{

					minc = mp[i][j].c;

				}

			}

			ans += minc;

		}

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

	}

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;

struct node{

    int next,d,c;

};

const int maxn=10005;

int n,m;

int d[maxn],c[maxn];

bool vis[maxn];

void init()

{

    for(int i=0;i<maxn;i++)

        d[i]=c[i]=1e9,vis[i]=0;

}

int main()

{

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

    {

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

        init();vector<node> v[maxn];

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

        {

            int x,y,d,c;

            scanf("%d%d%d%d",&x,&y,&d,&c);

            v[x].push_back(node{y,d,c});

            v[y].push_back(node{x,d,c});

        }

        queue<int> q;

        q.push(1);

        d[1]=c[1]=0;vis[1]=1;

        while(!q.empty())

        {

            int u=q.front();q.pop();vis[u]=0;

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

            {

                int nx=v[u][i].next;

                if(d[nx]==d[u]+v[u][i].d&&c[nx]>v[u][i].c){

                        c[nx]=v[u][i].c;

                }

                if(d[nx]>d[u]+v[u][i].d)

                {

                    d[nx]=d[u]+v[u][i].d;

                    c[nx]=v[u][i].c;

                    if(vis[nx]) continue;

                    vis[nx]=1;

                    q.push(nx);

                }

            }

        }

        int ans=0;

        for(int i=2;i<=n;i++) ans+=c[i];

        cout<<ans<<endl;

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.1900078467965658x):
#include <cstdio>

#include <iostream>

#include <cstring>

#include <string>

#include <algorithm>

#include <vector>

#include <queue>

const int maxn = 10007;

const int inf =1e9;

using namespace std;

struct node{

	int to,d,c;

	node(){}

	node (int to,int d,int c):to(to),d(d),c(c){}

};

vector<node>mp[maxn];

int dis[maxn],cost[maxn],n,m,ans = 0;

void init(){

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

	{

		mp[i].clear();

		dis[i] = inf;

		cost[i]  = 0;

	}

}

void add(int u,int v,int d,int c)

{

	mp[u].push_back(node(v,d,c));

}

int main(){

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

	{

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

		init();

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

		{

			int u,v,d,c;

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

			add(u,v,d,c);

			add(v,u,d,c);

		}

		priority_queue<pair<int,int> >q;

		dis[1]=0;

		cost[1]=0;

		

		q.push (make_pair(-dis[1],1)) ;

		while(!q.empty())

		{

			int now = q.top().second;

			q.pop();

			for(int i=0;i<mp[now].size();i++)

			{

				int v=mp[now][i].to;

				int d=mp[now][i].d;

				int c=mp[now][i].c;

				if(dis[v]>dis[now]+d)

				{

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

					//ans -=cost[v];

					//cost[v] = cost[now]+c;

					//ans +=cost[v];

					q.push (make_pair(-dis[v],v));

				}

			}

		}

		ans = 0;

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

		{

			int minc = inf;

			for(int j=0;j<mp[i].size();j++)

			{

				node tmp = mp[i][j];

				if(tmp.d+dis[tmp.to]==dis[i]&&minc>tmp.c)

				{

					minc = mp[i][j].c;

				}

			}

			ans += minc;

		}

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

	}

	return 0;

}
// Slower C++ solution:
#include "cstring"

#include "cstdio"

#include "vector"

#include "queue"

using namespace std;



const int maxn=11000;



struct edge{int to,d,c;};

edge edges[4100000];

int p;



vector<int>g[maxn];



int dis[maxn],vis[maxn],cos[maxn];

int n,m,sn;



void add(int u,int v,int d,int c)

{

	edges[++p].d=d;

	edges[p].to=v;

	edges[p].c=c;

	g[u].push_back(p);

}



int spfa(int s)

{

	memset(cos,0x3f3f3f3f,sizeof(cos));

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

	memset(vis,0,sizeof(vis));

	

	queue<int>qn;

	qn.push(s);

	dis[s]=0;

	cos[s]=0;

	vis[s]=1;

	

	while(!qn.empty())

	{

		int nn=qn.front();qn.pop();

		vis[nn]=0;

		for(int i=0,d=g[nn].size();i<d;i++)

		{

			edge &e= edges[g[nn][i]];

			if(dis[e.to]>dis[nn]+e.d || ((dis[e.to]==dis[nn]+e.d) && cos[e.to]>e.c))

			{

				dis[e.to]=dis[nn]+e.d;

				cos[e.to]=e.c;

				

				if(!vis[e.to])

				{

					qn.push(e.to);

					vis[e.to]=1;

				}

			}

		}	

	}

	return 0;

}



int main()

{

	//freopen("q.txt","r",stdin);

	int u,v,d,c;

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

	{

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

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

			g[i].clear();

		p=0;

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

		{

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

			add(u,v,d,c);

			add(v,u,d,c);

		}

		int ans=0;

		spfa(1);

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

			ans+=cos[i];

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

	}

	return 0;

} 


// Faster C++ solution for the same problem (measured speedup: 1.0979186920646173x):
#include <cstdio>

#include <iostream>

#include <cstring>

#include <string>

#include <algorithm>

#include <vector>

#include <queue>

const int maxn = 10007;

const int inf =1e9;

using namespace std;

struct node{

	int to,d,c;

	node(){}

	node (int to,int d,int c):to(to),d(d),c(c){}

};

vector<node>mp[maxn];

int dis[maxn],cost[maxn],n,m,ans = 0;

void init(){

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

	{

		mp[i].clear();

		dis[i] = inf;

		cost[i]  = 0;

	}

}

void add(int u,int v,int d,int c)

{

	mp[u].push_back(node(v,d,c));

}

int main(){

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

	{

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

		init();

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

		{

			int u,v,d,c;

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

			add(u,v,d,c);

			add(v,u,d,c);

		}

		priority_queue<pair<int,int> >q;

		dis[1]=0;

		cost[1]=0;

		

		q.push (make_pair(-dis[1],1)) ;

		while(!q.empty())

		{

			int now = q.top().second;

			q.pop();

			for(int i=0;i<mp[now].size();i++)

			{

				int v=mp[now][i].to;

				int d=mp[now][i].d;

				int c=mp[now][i].c;

				if(dis[v]>dis[now]+d)

				{

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

					//ans -=cost[v];

					//cost[v] = cost[now]+c;

					//ans +=cost[v];

					q.push (make_pair(-dis[v],v));

				}

			}

		}

		ans = 0;

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

		{

			int minc = inf;

			for(int j=0;j<mp[i].size();j++)

			{

				node tmp = mp[i][j];

				if(tmp.d+dis[tmp.to]==dis[i]&&minc>tmp.c)

				{

					minc = mp[i][j].c;

				}

			}

			ans += minc;

		}

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

	}

	return 0;

}
// Slower C++ solution:
#include <queue>

#include <vector>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <iostream>

#include <algorithm>

const int INF=0x3f3f3f3f;

using namespace std;

struct edge{

    int to,cost,w;

};

int V,d[10005],dis[10005];

vector<edge> G[20005];

typedef pair<int,int> P;

void dijkstra(int s){

    int i,v;

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

	fill(d,d+V+1,INF);

	fill(dis,dis+V+1,INF);

	d[s]=dis[s]=0;

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

	while(!que.empty()){

		P p=que.top(); que.pop();

		v=p.second;

		if(d[v]<p.first)

        continue;

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

			edge e=G[v][i];

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

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

                dis[e.to]=e.w;

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

			}

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

            dis[e.to]=min(dis[e.to],e.w);

		}

	}

}

int main(){

    int m,st,en,i,j,x,y,z,q,ans;

    edge temp;

    while(scanf("%d%d",&V,&m)!=EOF&&(V||m)){

        for(i=0;i<=V;i++)

        G[i].clear();

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

            scanf("%d%d%d%d",&x,&y,&z,&q);

            temp.to=y;temp.cost=z;temp.w=q;

            G[x].push_back(temp);

            temp.to=x;

            G[y].push_back(temp);

        }

        dijkstra(1);

        ans=0;

        for(i=1;i<=V;i++)

        ans+=dis[i];

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

    }

    return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.3496942400132628x):
#include<cstdio>

#include<algorithm>

#include<queue>

#include<iostream>

#include<cstring>

using namespace std;

const int maxn = 10050, maxe = 2005000, inf = 1e9;

struct node {

	int to;

	int w;

	int c;

	int next;

};

node edge[maxe];

int head[maxn];

int ip;

void init()

{

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

	ip = 0;

}

void addedge(int u, int v, int w, int c)

{

	edge[ip].to = v;

	edge[ip].c = c;

	edge[ip].w = w;

	edge[ip].next = head[u];

	head[u] = ip++;

}

int cost[maxn], dis[maxn], vis[maxn];

queue<int>q;

void spfa(int s, int n)

{

	while (!q.empty())

		q.pop();

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

		dis[i] = cost[i] = inf;

	memset(vis, 0, sizeof(vis));

	dis[s] = 0, cost[s] = 0, vis[s] = 1;

	q.push(s);

	while (q.size())

	{

		int u = q.front();

		q.pop();

		vis[u] = 0;

		for (int i = head[u]; i != -1; i = edge[i].next)

		{

			int to = edge[i].to, val = edge[i].w;

			if (dis[to] > dis[u] + val || (dis[to] == dis[u] + val&&cost[to] > edge[i].c))

			{

				dis[to] = dis[u] + val;

				cost[to] = edge[i].c;

				if (!vis[to])

				{

					q.push(to);

					vis[to] = 1;

				}

			}

		}

	}

}

int main()

{

	int n, m, u, v, w, c;

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

	{

		init();

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

		{

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

			addedge(u, v, w, c);

			addedge(v, u, w, c);

		}

		spfa(1, n);

		int ans = 0;

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

			ans += cost[i];

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

	}

	return 0;

}
// Slower C++ solution:
#include <bits/stdc++.h>

using namespace std;



typedef long long ll;

const int N = 10005;

const int M = 1000000007;



int n, m;

typedef int wtype;

struct Edge { int v; wtype d, c; };

vector<Edge> e[N];

wtype dist[N], cost[N];

int pre[N];

bool vis[N];

int SPFA(int src) {

  memset(dist, 0x3f, sizeof(dist)); dist[src] = 0;

  memset(cost, 0x3f, sizeof(cost)); cost[src] = 0;

  memset(vis, 0, sizeof(vis)); vis[src] = true;

  stack<int> que; que.push(src);

  while (!que.empty()) {

    int u = que.top(); que.pop();

    vis[u] = false;

    for (int i = 0; i < (int)e[u].size(); i++) {

      int v = e[u][i].v; wtype d = e[u][i].d, c = e[u][i].c;

      if (dist[v] > dist[u] + d || (dist[v] == dist[u] + d && cost[v] != 0x3f3f3f3f && cost[v] > c)) {

        dist[v] = dist[u] + d; cost[v] = c;

        if (!vis[v]) { vis[v] = true; que.push(v); }

      }

    }

  }

  int ret = 0;

  for (int i = 1; i <= n; i++) { ret += cost[i]; }

  return ret;

}



int main() {

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

    for (int i = 1; i <= n; i++) { e[i].clear(); }

    for (int i = 0, u, v, d, c; i < m; i++) {

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

      e[u].push_back((Edge) {v, d, c});

      e[v].push_back((Edge) {u, d, c});

    }

    printf("%d\n", SPFA(1));

  }

}

// Faster C++ solution for the same problem (measured speedup: 1.2348887414324237x):
#include<cstdio>

#include<algorithm>

#include<queue>

#include<iostream>

#include<cstring>

using namespace std;

const int maxn = 10050, maxe = 2005000, inf = 1e9;

struct node {

	int to;

	int w;

	int c;

	int next;

};

node edge[maxe];

int head[maxn];

int ip;

void init()

{

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

	ip = 0;

}

void addedge(int u, int v, int w, int c)

{

	edge[ip].to = v;

	edge[ip].c = c;

	edge[ip].w = w;

	edge[ip].next = head[u];

	head[u] = ip++;

}

int cost[maxn], dis[maxn], vis[maxn];

queue<int>q;

void spfa(int s, int n)

{

	while (!q.empty())

		q.pop();

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

		dis[i] = cost[i] = inf;

	memset(vis, 0, sizeof(vis));

	dis[s] = 0, cost[s] = 0, vis[s] = 1;

	q.push(s);

	while (q.size())

	{

		int u = q.front();

		q.pop();

		vis[u] = 0;

		for (int i = head[u]; i != -1; i = edge[i].next)

		{

			int to = edge[i].to, val = edge[i].w;

			if (dis[to] > dis[u] + val || (dis[to] == dis[u] + val&&cost[to] > edge[i].c))

			{

				dis[to] = dis[u] + val;

				cost[to] = edge[i].c;

				if (!vis[to])

				{

					q.push(to);

					vis[to] = 1;

				}

			}

		}

	}

}

int main()

{

	int n, m, u, v, w, c;

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

	{

		init();

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

		{

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

			addedge(u, v, w, c);

			addedge(v, u, w, c);

		}

		spfa(1, n);

		int ans = 0;

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

			ans += cost[i];

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

	}

	return 0;

}
// Slower C++ solution:
#include <iostream>

#include <queue>

#include <functional>

#include <cstring>

using namespace std;

#define MAX_V 10240

 

// 从?点from指向?点to的???cost的?

typedef struct edge

{

	int to, distance, cost;

	edge(){}

	edge(int to, int distance, int cost) : to(to), distance(distance), cost(cost){}

	bool operator > (const edge & b) const

	{

		return distance != b.distance  ? distance > b.distance : cost > b.cost;

	}

} P;

 

// first 最短路径，second?点?号

 

// ?

vector<edge> G[MAX_V];

 

// V是?点数

int V;

bool visited[MAX_V];

 

// 求解从?点s出?到所有点的最短花?

int dijkstra(int s)

{

	int result = 0;

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

	memset(visited, 0, V * sizeof(bool));

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

 

	while (!que.empty())

	{

		P p = que.top(); que.pop();

		int v = p.to;

		if (visited[v]) continue;

		visited[v] = true;

		result += p.cost;

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

		{

			edge e = G[v][i];

			que.push(P(G[v][i].to, p.distance + G[v][i].distance, G[v][i].cost));

		}

	}

 

	return result;

}

 

///////////////////////////SubMain//////////////////////////////////

int main(int argc, char *argv[])

{

	int /*N = V,*/ M;

	while (cin >> V >> M && V)

	{

		for (int i = 0; i < V; ++i)

		{

			G[i].clear();

		}

		for (int i = 0; i < M; ++i)

		{

			int u, v, d, c;

			cin >> u >> v >> d >> c;

			--u, --v;

			G[u].push_back(edge(v, d, c));

			G[v].push_back(edge(u, d, c));

		}

 

		cout << dijkstra(0) << endl;

	}

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 1.15481500853767x):
#include<cstdio>

#include<algorithm>

#include<queue>

#include<iostream>

#include<cstring>

using namespace std;

const int maxn = 10050, maxe = 2005000, inf = 1e9;

struct node {

	int to;

	int w;

	int c;

	int next;

};

node edge[maxe];

int head[maxn];

int ip;

void init()

{

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

	ip = 0;

}

void addedge(int u, int v, int w, int c)

{

	edge[ip].to = v;

	edge[ip].c = c;

	edge[ip].w = w;

	edge[ip].next = head[u];

	head[u] = ip++;

}

int cost[maxn], dis[maxn], vis[maxn];

queue<int>q;

void spfa(int s, int n)

{

	while (!q.empty())

		q.pop();

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

		dis[i] = cost[i] = inf;

	memset(vis, 0, sizeof(vis));

	dis[s] = 0, cost[s] = 0, vis[s] = 1;

	q.push(s);

	while (q.size())

	{

		int u = q.front();

		q.pop();

		vis[u] = 0;

		for (int i = head[u]; i != -1; i = edge[i].next)

		{

			int to = edge[i].to, val = edge[i].w;

			if (dis[to] > dis[u] + val || (dis[to] == dis[u] + val&&cost[to] > edge[i].c))

			{

				dis[to] = dis[u] + val;

				cost[to] = edge[i].c;

				if (!vis[to])

				{

					q.push(to);

					vis[to] = 1;

				}

			}

		}

	}

}

int main()

{

	int n, m, u, v, w, c;

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

	{

		init();

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

		{

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

			addedge(u, v, w, c);

			addedge(v, u, w, c);

		}

		spfa(1, n);

		int ans = 0;

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

			ans += cost[i];

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

	}

	return 0;

}
// Slower C++ solution:
#include<iostream>

#include<vector>

#include<queue>

#include<algorithm>

#include<cstring>

using namespace std;

const int maxn  = 1e4+10;

const int INF = 0x3f3f3f3f;

typedef pair<int,int> P;

struct edge{

	int to,dis,cost;

		

};



int d[maxn];

int value[maxn];



int N,M;



int dijkstra(vector<edge>G[])

{



	memset(d,INF,sizeof(d));

	//memset(value,INF,sizeof(value));

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

		

	d[1] = 0;

	value[1] = 0;

	que.push(P(d[1],1));

	

	int res = 0;

	while(!que.empty())

	{

		P p  = que.top(); que.pop();

		

		int v = p.second;

		if(d[v] < p.first)

			continue;

			

		res += value[v];

		

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

		{

			edge e = G[v][i];

			if(d[e.to] == d[v] + e.dis)

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

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

			{

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

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

				

				value[e.to] = e.cost;

			}

		}

	}

	return res;

	

}



int main()

{



	//freopen("c:\\users\\administrator\\desktop\\in.txt","r",stdin);

	while(cin >> N >> M, N||M)

	{

		

		vector<edge> G[maxn];

		for(int i =0; i < M; i++)

		{

			int u,v,d,c;

			edge e;

			cin >> u >> v >> d >> c;

			e.to= v, e.dis= d, e.cost =c;

			G[u].push_back(e);

			e.to= u;

			G[v].push_back(e);	

		}

		

		int res = dijkstra(G);

		cout << res <<endl;

	}		

} 

// Faster C++ solution for the same problem (measured speedup: 1.2928480932785145x):
#include<cstdio>

#include<algorithm>

#include<queue>

#include<iostream>

#include<cstring>

using namespace std;

const int maxn = 10050, maxe = 2005000, inf = 1e9;

struct node {

	int to;

	int w;

	int c;

	int next;

};

node edge[maxe];

int head[maxn];

int ip;

void init()

{

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

	ip = 0;

}

void addedge(int u, int v, int w, int c)

{

	edge[ip].to = v;

	edge[ip].c = c;

	edge[ip].w = w;

	edge[ip].next = head[u];

	head[u] = ip++;

}

int cost[maxn], dis[maxn], vis[maxn];

queue<int>q;

void spfa(int s, int n)

{

	while (!q.empty())

		q.pop();

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

		dis[i] = cost[i] = inf;

	memset(vis, 0, sizeof(vis));

	dis[s] = 0, cost[s] = 0, vis[s] = 1;

	q.push(s);

	while (q.size())

	{

		int u = q.front();

		q.pop();

		vis[u] = 0;

		for (int i = head[u]; i != -1; i = edge[i].next)

		{

			int to = edge[i].to, val = edge[i].w;

			if (dis[to] > dis[u] + val || (dis[to] == dis[u] + val&&cost[to] > edge[i].c))

			{

				dis[to] = dis[u] + val;

				cost[to] = edge[i].c;

				if (!vis[to])

				{

					q.push(to);

					vis[to] = 1;

				}

			}

		}

	}

}

int main()

{

	int n, m, u, v, w, c;

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

	{

		init();

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

		{

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

			addedge(u, v, w, c);

			addedge(v, u, w, c);

		}

		spfa(1, n);

		int ans = 0;

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

			ans += cost[i];

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

	}

	return 0;

}