#include <bits/stdc++.h>
#define all(x) (x).begin(),(x).end()
using namespace std;

using ll = long long;
using ld = long double;

//#define int ll
#define sz(x) ((int)(x).size())

using pii = pair<int,int>;
using tii = tuple<int,int,int>;

const int nmax = 5e4 + 5;

vector<pii> g[nmax];
int color[nmax];

void fill(int node, int C) {
   if(color[node] != 0) return;
   color[node] = C;
   //cerr << node << ' ' << C << '\n';
   for(auto [x, w] : g[node]) fill(x, C);
}

namespace DSU {
   int dsu[nmax];
   int cc;
   ll stdcost, supra;
   void init(int n) {
      cc = n;
      stdcost = 0;
      supra = 0;
      for(int i = 1; i <= n; i++) dsu[i] = i;
      return;
   }
   int f(int x) { return dsu[x] == x? x : dsu[x] = f(dsu[x]); }
   bool unite(int x, int y, int w) {
      x = f(x);
      y = f(y);
      if(x == y) {
         supra += w;
         return 0;
      }
      
      stdcost += w;
      dsu[x] = y;
      cc--;
      return 1;
   }
   
   void flowback() {
      stdcost += supra;
      supra = 0;
   }
}

signed main() {
   cin.tie(0) -> sync_with_stdio(0);
   int n, m, k, s;
   cin >> n >> m >> k >> s;
   
   vector<tii> edgs;
   
   for(int i = 0, x, y, w; i < m; i++) {
      cin >> x >> y >> w;
      if(y == s) swap(x, y);
      else if(x != s && x > y) swap(x, y);
      edgs.emplace_back(x, y, w);
   }
   
   pii prv = {-1, -1};
   sort(all(edgs));
   for(auto [x, y, w] : edgs) {
      if(prv == make_pair(x, y) && x == s) continue;
      g[x].emplace_back(y, w);
      g[y].emplace_back(x, w);
      prv = pii{x, y};
   }
   
   color[s] = -1;
   int C = 1;
   for(int i = 1; i <= n; i++) {
      if(color[i] == 0) fill(i, C++);
   }
   C--;
   
   //cerr << sz(g[s]) << '\n';
   
   if(sz(g[s]) < k) {
      cout << "nonnondayo\n";
      return 0;
   }
   if(!([&]() {
      vector<int> found_colors(C, 0);
      for(auto [x, w] : g[s]) found_colors[color[x] - 1] = 1;
      
      //for(auto x : found_colors) cout << x << ' ';
      
      if((accumulate(all(found_colors), 0) != C) || C > k) return false;
      return true;
   }())) {
      cout << "nonnondayo\n";
      return 0;
   }
   
   sort(all(g[s]), [&](auto a, auto b) { return a.second < b.second; });
   vector<int> occ(C + 1, 0);
   k -= C;
   
   DSU::init(n);
   int mxS = -1;
   for(auto [x, w] : g[s]) {
      if(occ[color[x]] == 0) {
         mxS = w;
         occ[color[x]] = 1;
         DSU::unite(s, x, w);
      }
      else {
         if(k > 0) {
            mxS = w;
            DSU::unite(s, x, w);
            k--;
         }
      }
   }
   DSU::flowback();
   
   for(int i = 0; i < sz(edgs); i++) {
      if(get<0>(edgs[i]) == s) {
         swap(edgs[i], edgs.back());
         edgs.pop_back();
         i--;
      }
   }
   
   
   sort(all(edgs), [&](auto a, auto b) { return get<2>(a) < get<2>(b); });
   int lastw = -1;
   for(auto [x, y, w] : edgs) {
      if(w < mxS) {
         DSU::unite(x, y, w);
         //DSU::flowback();
      }
      else {
         if(w != lastw) {
            if(DSU::cc == 1)
               break;
            //DSU::flowback();
            lastw = w;
         }
         DSU::unite(x, y, w);
      }
   }
   
   if(DSU::cc == 1);
   else {
      cout << "nonnnondayo\n";
      return 0;
   }
   
   cout << DSU::stdcost << '\n';
}

/**
      Istenem! Nu poate fi real.
-- Surse verificate
*/