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

int io_=[](){ ios::sync_with_stdio(false); cin.tie(nullptr); return 0; }();

using LL = long long;
using ULL = unsigned long long;
using LD = long double;
using PII = pair<int, int>;
using VI = vector<int>;
using MII = map<int, int>;

template<typename T> void cmin(T &x,const T &y) { if(y<x) x=y; }
template<typename T> void cmax(T &x,const T &y) { if(x<y) x=y; }
template<typename T> bool ckmin(T &x,const T &y) { 
    return y<x ? (x=y, true) : false; }
template<typename T> bool ckmax(T &x,const T &y) { 
    return x<y ? (x=y, true) : false; }
template<typename T> void cmin(T &x,T &y,const T &z) {// x<=y<=z 
    if(z<x) { y=x; x=z; } else if(z<y) y=z; }
template<typename T> void cmax(T &x,T &y,const T &z) {// x>=y>=z
    if(x<z) { y=x; x=z; } else if(y<z) y=z; }

// mt19937 rnd(chrono::system_clock::now().time_since_epoch().count());
// mt19937_64 rnd_64(chrono::system_clock::now().time_since_epoch().count());
template<typename Func> struct YCombinatorResult {
  Func func;
  template<typename T>
  explicit YCombinatorResult(T &&func) : func(std::forward<T>(func)) {}
  template<class ...Args> decltype(auto) operator()(Args &&...args) {
    return func(std::ref(*this), std::forward<Args>(args)...);
  }
};
template<typename Func> decltype(auto) y_comb(Func &&fun) {
  return YCombinatorResult<std::decay_t<Func>>(std::forward<Func>(fun));
}
/*
---------1---------2---------3---------4---------5---------6---------7---------
1234567890123456789012345678901234567890123456789012345678901234567890123456789
*/

typedef pair<LL, int> PLI;
const LL INF = 0x3f3f3f3f3f3f3f3f;

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

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

  vector<LL> dis(n, INF);
  vector<int> vis(n);
  priority_queue<PLI, vector<PLI>, greater<PLI>> qu;
  qu.push({0LL, 0});
  dis[0] = 0;

  while (!qu.empty()) {
    auto [_, u] = qu.top(); qu.pop();

    if (vis[u]) continue;
    vis[u] = 1;

    for (auto [v, w, _] : g[u]) {
      if (vis[v]) continue;
      if (dis[v] <= dis[u] + w) continue;
      dis[v] = dis[u] + w;
      qu.push({dis[v], v});
    }
  }

  // for (LL i : dis) cerr << i << ' ';
  // cerr << endl;

  vector<int> valid(m);

  fill(vis.begin(), vis.end(), 0);

  y_comb([&](auto dfs, int u) -> void {
    for (auto [v, w, id] : g[u]) {
      if (vis[v]) continue;
      if (dis[v] == dis[u] + w && k) {
        valid[id] = 1;
        k--;
        vis[v] = 1;
        dfs(v);
      }
    }
  })(0);

  int e = 0;
  for (int i = 0; i < m; i++) {
    if (valid[i]) e++;
  }
  cout << e << '\n';
  int fi = 1;
  for (int i = 0; i < m; i++) {
    if (!valid[i]) continue;
    if (fi) fi = 0;
    else cout << ' ';
    cout << (i + 1);
  }
  cout << '\n';
}

int main() {
  int t = 1; 
  // cin >> t;
  while (t--) {
    solve();
  }
  return 0;
}