#include <bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 8005;

int fa[N],dep[N],fw[N];
int eu[N],ev[N],w[N];
vector <pair <int,int> > G[N];

int n,m;
int in[N];

void dfs(int u,int f){
    fa[u] = f;
    dep[u] = dep[f] + 1;
    for(auto [v,ew] : G[u]){
        if(v == f) continue;
        dfs(v,u);
        fw[v] = ew;
    }
}

int get_max(int u,int v){
    int ret = -1;
    if(dep[u] < dep[v]) swap(u,v);
    while(dep[u] > dep[v]){
        if(!in[fw[u]] && fw[u] < n) ret = fw[u];
        u = fa[u];
    }
    while(u != v){
        if(!in[fw[u]] && fw[u] < n) ret = fw[u];
        if(!in[fw[v]] && fw[v] < n) ret = fw[v];
        u = fa[u]; v = fa[v];
    }
    assert(ret != -1);
    return ret;
}

struct edge{
    int u,v,w,id;
    bool operator < (const edge &nd)const{
        return w < nd.w;
    }
}e[N];

int ffa[N];
int getf(int x){
    if(ffa[x] == x) return x;
    return ffa[x] = getf(ffa[x]);
}

void kruscal(){
    for(int i = 1;i <= n;i ++) ffa[i] = i;
    sort(e + 1,e + 1 + m);
    for(int i = 1;i <= m;i ++){
        int u = getf(e[i].u);
        int v = getf(e[i].v);
        if(u == v) continue;
        ffa[u] = v;
        in[e[i].id] = 1;
    }
}

void solve(){
    cin >> n >> m;
    for(int i = 1;i <= m;i ++){
        cin >> e[i].u >> e[i].v >> e[i].w;
        e[i].id = i;
        eu[i] = e[i].u; ev[i] = e[i].v; w[i] = e[i].w;

        e[i].w = 10000ll * e[i].w;
        if(i >= n) e[i].w ++;
    }
    kruscal();

    vector <pair <int,int> > ans;
    for(int u,v,i = 1;i < n;i ++){
        u = eu[i]; v = ev[i];
        G[u].push_back({v,i});
        G[v].push_back({u,i});
    }
    for(int i = n;i <= m;i ++){
        int u,v;
        u = eu[i]; v = ev[i];
        if(!in[i]) continue;

        dfs(1,0);
        int id = get_max(u,v);

        ans.push_back({id,i});

        for(int j = 0;j < G[eu[id]].size();j ++){
            if(G[eu[id]][j].first == ev[id]){
                swap(G[eu[id]][j],G[eu[id]].back());
            }
        }
        for(int j = 0;j < G[ev[id]].size();j ++){
            if(G[ev[id]][j].first == eu[id]){
                swap(G[ev[id]][j],G[ev[id]].back());
            }
        }
        G[eu[id]].pop_back();
        G[ev[id]].pop_back();

        G[u].push_back({v,i});
        G[v].push_back({u,i});
    }
    cout << ans.size() << '\n';
    for(auto [u,v] : ans) cout << u << ' ' << v << '\n';
}

signed main(){
    ios::sync_with_stdio(false);
    solve();
    return 0;
}