#include <bits/stdc++.h>
using namespace std;

#ifdef CKISEKI
#define safe cerr << __PRETTY_FUNCTION__ << " line " << __LINE__ << " safe\n"
#define debug(a...) debug_(#a, a)
#define orange(a...) orange_(#a, a)
template <typename ...T>
void debug_(const char *s, T ...a) {
    cerr << "\e[1;32m(" << s << ") = (";
    int cnt = sizeof...(T);
    (..., (cerr << a << (--cnt ? ", " : ")\e[0m\n")));
}
template <typename I>
void orange_(const char *s, I L, I R) {
    cerr << "\e[1;32m[ " << s << " ] = [ ";
    for (int f = 0; L != R; ++L)
        cerr << (f++ ? ", " : "") << *L;
    cerr << " ]\e[0m\n";
}
#else
#define safe ((void)0)
#define debug(...) ((void)0)
#define orange(...) ((void)0)
#endif

using edge = tuple<int,int,int>;

struct Dsu {
    vector<int> pa;
    Dsu(int n) : pa(n) {
        iota(pa.begin(), pa.end(), 0);
    }
    int anc(int x) {
        return x==pa[x] ? x : pa[x]=anc(pa[x]);
    }
    bool join(int x, int y) {
        x = anc(x);
        y = anc(y);
        if (x == y) return false;
        pa[x] = y;
        return true;
    }
};

int main() {
    cin.tie(nullptr)->sync_with_stdio(false);
    int n, m;
    cin >> n >> m;

    map<int, array<vector<edge>, 2>> mp;
        // w -> (u,v,i);

    vector<edge> edges(m); // u, v, w
    for (int i = 0; i < m; i++) {
        auto &[u, v, w] = edges[i];
        cin >> u >> v >> w;
        mp[w][ (i < n - 1) ].emplace_back(u, v, i);
    }

    vector<int> removed(m);
    for (int i = n-1; i < m; i++)
        removed[i] = true;

    vector<pair<int,int>> ans;
    map<int,bool> over;
    vector<int> pa(n + 1), dep(n + 1);
    vector<int> pa_edge(n + 1);

    const auto Build = [&]() {
        over.clear();

        vector<vector<pair<int,int>>> g(n + 1);
        map<int,array<int,2>> cnt;
        vector<edge> cur, mst;
        for (int i = 0; i < m; i++) {
            auto [u, v, w] = edges[i];
            if (!removed[i]) {
                g[u].emplace_back(v, i);
                g[v].emplace_back(u, i);
                cur.emplace_back(w, u, v);
            }
            mst.emplace_back(w, u, v);
        }
        sort(cur.begin(), cur.end());
        sort(mst.begin(), mst.end());
        Dsu dsu1(n + 1), dsu2(n + 1);
        for (auto [w, u, v]: cur) {
            if (dsu1.join(u, v))
                ++cnt[w][0];
        }
        for (auto [w, u, v]: mst) {
            if (dsu2.join(u, v))
                ++cnt[w][1];
        }
        for (auto [w, arr]: cnt)
            over[w] = arr[0] > arr[1];

        const auto dfs = [&](auto self, int i, int f) -> void {
            for (auto [j, eid]: g[i]) {
                if (j == f) continue;
                pa[j] = i;
                dep[j] = dep[i] + 1;
                pa_edge[j] = eid;
                self(self, j, i);
            }
        };
        dep[1] = 0;
        dfs(dfs, 1, 0);
    };

    const auto path = [&](int a, int b) {
        vector<int> res;
        while (a != b) {
            if (dep[a] > dep[b]) swap(a, b);
            res.emplace_back(pa_edge[b]);
            b = pa[b];
        }
        return res;
    };

    const auto Swap = [&](int a, int b) {
        assert (!removed[a] && removed[b]);
        swap(removed[a], removed[b]);
        ans.emplace_back(a, b);
        Build();
    };
    Build();

    Dsu dsu(n + 1);

    for (auto [_, vv]: mp) {
        for (auto [u, v, eid]: vv[1]) {
            if (removed[eid]) continue;
            dsu.join(u, v);
        }
        
        // bool swapped = false;
        for (auto [u, v, eid]: vv[0]) {
            if (dsu.join(u, v)) {
                for (int onpath: path(u, v)) {
                    int w = get<2>(edges[onpath]);
                    if (over[w]) {
                        // swapped += 1;
                        Swap(onpath, eid);
                        break;
                    }
                }
                // if (swapped)
                //     break;
            }
        }
    }

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

}