#include <iostream>
#include <fstream>
#include <algorithm>
 
using namespace std;
 
#define Nmax 200005
 
struct edge
{
    int x;
    int y;
    int64_t c1;
    int64_t c2;
    int ind;
 
} v[Nmax];
 
class comp
{
    public:
    bool operator() ( const edge &a, const edge &b ) const
    {
        if ( a.c1 != b.c1 )
                return a.c1 < b.c1;
 
        return a.c2 > b.c2;
    }
};
 
int tata[Nmax], rang[Nmax];
 
int N, M;
 
void read()
{
    ifstream f("lazy.in");
 
    f >> N >> M;
 
    for ( int i = 1; i <= M; ++i )
    {
        int x, y;
        int64_t c1, c2;
 
        f >> x >> y >> c1 >> c2;
 
        v[i] = { x, y, c1, c2, i };
    }
 
    f.close();
}
 
void init()
{
    for ( int i = 1; i <= N; ++i )
            rang[i] = 1,
            tata[i] = i;
}
 
int FIND( int x )
{
    int y, R;
 
    for ( R = x; tata[R] != R; R = tata[R] );
 
    for ( ; tata[x] != x; )
    {
        y = tata[x];
        tata[x] = R;
        x = y;
    }
 
    return R;
}
 
void UNION( int x, int y )
{
    if ( rang[x] > rang[y] )
            tata[y] = x;
    else
            tata[x] = y;
 
    if ( rang[x] == rang[y] )
            rang[y]++;
}
 
void Kruskal()
{
    ofstream g("lazy.out");
 
    int use = 0;
 
    for ( int i = 1; i <= M && N - use > 1; ++i )
    {
        int x = FIND( v[i].x );
        int y = FIND( v[i].y );
 
        if ( x != y )
        {
            g << v[i].ind << "\n";
            use++;
 
            UNION( x, y );
        }
    }
 
    g.close();
}
 
int main()
{
    read();
    init();
    sort( v + 1, v + M + 1, comp() );
    Kruskal();
 
    return 0;
}