#include <bits/stdc++.h>

using namespace std;

#ifdef LOCAL
template <class... T> void dbg(T... x) { char e{}; ((cerr << e << x, e = ' '), ...); }
template <class T> void org(T l, T r) { while (l != r) cerr << ' ' << *l++; cerr << '\n'; }
#define debug(x...) dbg(#x, '=', x, '\n')
#define olist(x...) dbg(#x, '='), org(x)
#else
#define debug(...) ((void)0)
#define olist(...) ((void)0)
#endif
#define all(v) (v).begin(), (v).end()
#define rall(v) (v).rbegin(), (v).rend()
#define ff first
#define ss second

using u32 = unsigned int;
using i64 = long long;
using u64 = unsigned long long;
using i128 = __int128;
using u128 = unsigned __int128;
using Pt = pair<int, int>;

template <class T> inline constexpr T inf = numeric_limits<T>::max() / 2;
constexpr int mod = 1e9 + 7;

template<class T> bool chmin(T &a, T b) { return (b < a and (a = b, true)); }
template<class T> bool chmax(T &a, T b) { return (a < b and (a = b, true)); }
template<class... T> int add(T... x) { int t{}; return (((t += x) %= mod), ...), t; }
template<class... T> int mul(T... x) { i64 t{1}; return (((t *= x) %= mod), ...), t; }

struct DSU {
    vector<int> f;
    DSU(int n) : f(n, -1) {}
    int Find(int x) { return f[x] < 0 ? x : f[x] = Find(f[x]); }
    bool Union(int x, int y) {
        x = Find(x), y = Find(y);
        if (x == y) return false;
        f[x] = y;
        return true;
    }
};

void solve() {
    int n, m;
    cin >> n >> m;

    vector<array<int, 3>> edg(m);
    vector<vector<int>> G(n);
    
    for (int i = 0; i < m; i++) {
        int u, v, w;
        cin >> u >> v >> w;
        u--, v--;
        edg[i] = {u, v, w};
        G[u].push_back(i);
        G[v].push_back(i);
    }

    vector<bool> mst(m);
    DSU dsu(n);
    vector<int> ord(m);
    iota(all(ord), 0);
    sort(all(ord), [&](int a, int b) {
        return edg[a][2] == edg[b][2] ? a < b : edg[a][2] < edg[b][2];
    });
    for (int i : ord) {
        int u = edg[i][0];
        int v = edg[i][1];
        mst[i] = dsu.Union(u, v);
    }

    vector<pair<int, int>> ans;
    vector<bool> use(m);
    fill(use.begin(), use.begin() + n - 1, 1);

    olist(all(mst));
    olist(all(use));
    
    for (int i = 0; i < m; i++) if (mst[i] and !use[i]) {
        int x = edg[i][0];
        int y = edg[i][1];
        vector<int> path;
        auto dfs = [&](auto self, int u, int f) -> bool {
            if (u == y) return true;
            for (int e : G[u]) if (use[e]) {
                int v = edg[e][0] ^ edg[e][1] ^ u;
                if (v == f) continue;
                path.push_back(e);
                if (self(self, v, u))
                    return true;
                path.pop_back();
            }
            return false;
        };
        dfs(dfs, x, -1);
        for (int e : path) if (!mst[e]) {
            use[e] = 0;
            use[i] = 1;
            ans.emplace_back(e, i);
            break;
        }
    }

    cout << ans.size() << '\n';
    for (auto [a, b] : ans)
        cout << a + 1 << ' ' << b + 1 << '\n';
}

signed main() {
    cin.tie(0)->sync_with_stdio(false);
    cin.exceptions(cin.failbit);
    int T = 1;
    // cin >> T;
    while (T--) {
        solve();
    }
    return 0;
}