#include <bits/stdc++.h>

using namespace std;

struct edge {
  int id;
  int u, v, w;

  bool operator<(const edge &o) const { 
	if (w == o.w) {
		return id < o.id;
	}
	return w < o.w; 
  }
};

struct dsu {
  vector<int> parent, subtree;

  void init(int n) {
    parent.resize(n);
    subtree.resize(n);

    for (int i = 0; i < n; i++) {
      subtree[i] = 1;
      parent[i] = i;
    }
  }

  int findParent(int x) {
    if (parent[x] == x)
      return x;
    else {
      parent[x] = findParent(parent[x]);
      return parent[x];
    }
  }

  void unite(int parX, int parY) {
    if (subtree[parX] < subtree[parY]) {
      parent[parX] = parY;
      subtree[parY] += subtree[parX];
    } else {
      parent[parY] = parX;
      subtree[parX] += subtree[parY];
    }
  }
};

int64_t findMst(int n, const vector<edge> &edges, int edgeId) {
  dsu d;
  d.init(n);

  int64_t ans = 0;
  for (auto e : edges) {
    if (e.id == edgeId) {
      ans += e.w;
      d.unite(e.u, e.v);
    }
  }

  for (auto e : edges) {
    if (e.id == edgeId) {
      continue;
    }

    int parX = d.findParent(e.u);
    int parY = d.findParent(e.v);

    if (parX != parY) {
      ans += e.w;
      d.unite(parX, parY);
    }
  }

  return ans;
}

int findReplacement(int n, const vector<edge> &edges, vector<bool>& forced) {
  dsu d;
  d.init(n);

  for (auto e : edges) {
    if (forced[e.id]) {
      d.unite(e.u, e.v);
    }
  }

  for (auto e : edges) {
    if (forced[e.id]) {
      continue;
    }

    int parX = d.findParent(e.u);
    int parY = d.findParent(e.v);

    if (parX != parY) {
	  return e.id;
    }
  }

  assert(false);
}

int main() {
  ios_base::sync_with_stdio(false);
  cin.tie(nullptr);

  int n, m;
  cin >> n >> m;

  vector<edge> edges(m);
  for (int i = 0; i < m; i++) {
    int u, v, w;
    cin >> u >> v >> w;

    u--;
    v--;

    edges[i] = {i, u, v, w};
  }

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

  int64_t globalMst = findMst(n, edges, -1);

  vector<bool> keep(n - 1, false);

  {
	dsu d;
	d.init(n);

	int64_t ans = 0;

	for (auto e : edges) {
		int parX = d.findParent(e.u);
		int parY = d.findParent(e.v);

		if (parX != parY) {
			ans += e.w;
			d.unite(parX, parY);
			if (e.id < n - 1) {
				keep[e.id] = true;
			}
		}
	}
  }

  vector<bool> forced(m);
  vector<int> removals;
  for (int i = 0; i < n - 1; i++) {
	forced[i] = true;
	if (!keep[i]) {
		removals.push_back(i);
	}
  }

  vector<pair<int, int>> changes;
  while (!removals.empty()) {
	int id = removals.back();
	removals.pop_back();

	forced[id] = false;
	int replacement = findReplacement(n, edges, forced);
	forced[replacement] = true;
	changes.push_back({id, replacement});
  }

  int64_t newMst = 0;
  for (int i = 0; i < m; i++) {
	edge e = edges[i];
	if (forced[e.id]) {
		newMst += e.w;
	}
  }

//   if (newMst != globalMst) {
// 	assert(false);
//   }

  cout << changes.size() << endl;
  for (auto [x, y] : changes) {
    cout << x + 1 << " " << y + 1 << endl;
  }
}