#include<algorithm>
#include<vector>

using namespace std;
#define N_MAX 200005
#define ll long long
#define INF 1LL*1<<62

int H[N_MAX],poz[N_MAX],dimHeap;
ll cost[N_MAX],profit[N_MAX];
bool inArb[N_MAX],ut[N_MAX];
int ind[N_MAX];

int n,m,x,y,i,j;
ll co,pr;

struct nod_s
{
	int y,i;
	ll cost,profit;
	
	nod_s()
	{
	}
	
	nod_s(const int &y,const ll &cost,const ll &profit,const int &i)
	{
		this->y=y;
		this->cost=cost;
		this->profit=profit;
		this->i=i;
	}
};

vector <nod_s> a[N_MAX];
vector <nod_s> ::iterator it;

inline bool cmp(int a,int b)
{
	return cost[a]<cost[b]||cost[a]==cost[b]&&profit[a]>profit[b];
}

void upHeap(int nod)
{
	while(nod>1&&cmp(H[nod],H[nod>>1]))
	{
		swap(poz[ H[nod>>1] ],poz[ H[nod] ]);
		swap(H[nod>>1],H[nod]);
		nod>>=1;
	}
}

void downHeap(int nod)
{
	int st=(nod<<1);
	int dr=(nod<<1)+1;
	int minim=nod;
	
	if(st<=dimHeap&&cmp(H[st],H[minim]))
		minim=st;
	if(dr<=dimHeap&&cmp(H[dr],H[minim]))
		minim=dr;
	
	if(nod!=minim)
	{
		swap(poz[ H[nod] ],poz[ H[minim] ]);
		swap(H[nod],H[minim]);
		downHeap(minim);
	}
}

void sterge(int nod)
{
	swap(poz[ H[nod] ],poz[ H[dimHeap] ]);
	swap(H[nod],H[dimHeap]);
	
	dimHeap--;
	
	if(cmp(H[nod>>1],H[nod]))
		downHeap(nod);
	else
		upHeap(nod);
}

int main()
{
	freopen("lazy.in","r",stdin);
	freopen("lazy.out","w",stdout);
	
	scanf("%d%d",&n,&m);
	
	for(i=1;i<=m;i++)
	{
		scanf("%d%d%lld%lld",&x,&y,&co,&pr);
		a[x].push_back(nod_s(y,co,1LL*co*pr,i));
		a[y].push_back(nod_s(x,co,1LL*co*pr,i));
	}
	
	for(i=1;i<=n;i++)
	{
		cost[i]=INF;
		profit[i]=-INF;
	}
	
	dimHeap=1;
	inArb[1]=1;	H[1]=1;	poz[1]=1;
	
	for(i=1;i<n;i++)
	{
		int nod=H[1];
		sterge(1);
		inArb[nod]=1;
		
		for(it=a[nod].begin();it!=a[nod].end();it++)
		{
			if(inArb[it->y])
				continue;
			
			if(cost[it->y]>it->cost)
			{
				cost[it->y]=it->cost;
				profit[it->y]=it->profit;
				
				ind[it->y]=it->i;
			}
			else
				if(cost[it->y]==it->cost&&profit[it->y]<it->profit)
				{
					profit[it->y]=it->profit;
					
					ind[it->y]=it->i;
				}
					
			if(ut[it->y])
				upHeap(poz[it->y]);
			else
			{
				dimHeap++;
				poz[it->y]=dimHeap;
				H[dimHeap]=it->y;
				ut[it->y]=1;
				upHeap(dimHeap);
			}
		}
	}
	
	for(i=2;i<=n;i++)
		printf("%d\n",ind[i]);
	
	return 0;
}