#include <fstream>
#include <vector>
#include <algorithm>

using namespace std;


typedef long long int64;

ifstream fin ("lazy.in");
ofstream fout ("lazy.out");

const int Nmax = 200009;

int N; int M; int T[Nmax]; int R[Nmax];

bool Take[Nmax]; vector <int> Result;


struct Edge {

    int X;int Y; int64 C1; int64 C2; int Ind;

    Edge(int X, int Y, int64 C1, int64 C2, int Ind) {
        this -> Y = Y; this -> X = X;
        this -> C1 = C1; this -> C2 = C2;
        this -> Ind = Ind;
    }

    bool operator < (const Edge X) const {
        if(this -> C1 == X.C1)
            return this -> C2 > X.C2;
        return this -> C1 < X.C1;
    }
};

vector <Edge> E;

void Read() {

    fin >> N >> M;
    for(int i = 1; i <= M; ++i){

        int X; int Y; int64 C1; int64 C2;
        fin >> X >> Y >> C1 >> C2;
        E.push_back(Edge(X, Y, C1, C2, i));
    }
}


int Find(int X){

    return (X == T[X]) ? X : Find(T[X]);

}


void Union(int X, int Y) {

    if(R[X] == R[Y])
        T[X] = Y, R[Y]++;

    if(R[X] > R[Y])
        T[Y] = X;
    else T[X] = Y;


}

void Solve() {

    for(int i = 1; i <= N; ++i)
        T[i] = i;

    sort(E.begin(), E.end());

    for(unsigned i = 0; i < E.size(); ++i){

        int FindRight = Find(E[i].X);
        int FindLeft = Find(E[i].Y);

        if(FindLeft != FindRight) {

            Union(FindLeft, FindRight);
            Result.push_back(E[i].Ind);
        }
    }
}


void Print() {

    sort(Result.begin(), Result.end());

    for(unsigned i = 0 ;i < Result.size(); ++i)
        fout << Result[i] <<'\n';
}

int main() {

    Read ();

    Solve ();

    Print ();

    return 0;
}