#include <cassert>
#include <cmath>
#include <cstdint>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
#include <bitset>
#include <complex>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <sstream>
#include <string>
#include <unordered_map>
#include <unordered_set>
#include <utility>
#include <vector>

using namespace std;

using Int = long long;

template <class T1, class T2> ostream &operator<<(ostream &os, const pair<T1, T2> &a) { return os << "(" << a.first << ", " << a.second << ")"; };
template <class T> ostream &operator<<(ostream &os, const vector<T> &as) { const int sz = as.size(); os << "["; for (int i = 0; i < sz; ++i) { if (i >= 256) { os << ", ..."; break; } if (i > 0) { os << ", "; } os << as[i]; } return os << "]"; }
template <class T> void pv(T a, T b) { for (T i = a; i != b; ++i) cerr << *i << " "; cerr << endl; }
template <class T> bool chmin(T &t, const T &f) { if (t > f) { t = f; return true; } return false; }
template <class T> bool chmax(T &t, const T &f) { if (t < f) { t = f; return true; } return false; }
#define COLOR(s) ("\x1b[" s "m")


// Link-Cut Tree, with subtree information
//   solid path as BST; left: root side
//   Modify update() for other data.
struct Tree {
  Tree *l, *r, *p;
  // int sz;
  int id;
  int val, sum;
  int light;
  explicit Tree(int id_ = -1, int val_ = 0) : id(id_), val(val_), sum(val_) {
  // explicit Tree(int id_ = -1) : id(id_) {
    l = r = p = nullptr;
    // sz = 1;
    light = 0;
  }
  void update() {
    // sz = (l ? l->sz : 0) + 1 + (r ? r->sz : 0);
    // sz = (l ? l->sz : 0) + 1 + (r ? r->sz : 0) + light;
    sum = (l ? l->sum : 0) + val + (r ? r->sum : 0) + light;
  }
  bool isRoot() const {
    return (!p || (p->l != this && p->r != this));
  }
  void rotate() {
         if (p->l == this) { if (r) { r->p = p; } p->l = r; r = p; }
    else if (p->r == this) { if (l) { l->p = p; } p->r = l; l = p; }
    Tree *pp = p->p;
    if (pp) {
           if (pp->l == p) pp->l = this;
      else if (pp->r == p) pp->r = this;
    }
    p->update(); p->p = this; p = pp;
  }
  void splay() {
    for (; !isRoot(); rotate()) {
      if (!p->isRoot()) ((p->l == this) == (p->p->l == p)) ? p->rotate() : rotate();
    }
    update();
  }

  // Makes the path from v to the root solid
  // Returns the node where it entered the last solid path
  Tree *expose() {
    Tree *u = this, *v = nullptr;
    // for (; u; u = u->p) { u->splay(); u->r = v; u->update(); v = u; }
    for (; u; u = u->p) {
      u->splay();
      if (u->r) u->light += u->r->sum;
      u->r = v;
      if (u->r) u->light -= u->r->sum;
      u->update();
      v = u;
    }
    splay();
    return v;
  }

  // parent of this := u
  void link(Tree *u) {
    expose(); u->expose(); p = u; u->r = this; u->update();
  }

  // parent of this := null
  void cut() {
    expose(); l->p = nullptr; l = nullptr; update();
  }

  // the root of the tree this belongs
  Tree *root() {
    expose();
    for (Tree *u = this; ; u = u->l) if (!u->l) { u->splay(); return u; }
  }

  // LCA of this and u
  //   Assumes this->root == u->root
  Tree *lca(Tree *u) {
    expose(); return u->expose();
  }
};

////////////////////////////////////////////////////////////////////////////////


vector<int> uf;
int root(int u) {
  return (uf[u] < 0) ? u : (uf[u] = root(uf[u]));
}
bool connect(int u, int v) {
  u = root(u);
  v = root(v);
  if (u == v) return false;
  if (uf[u] > uf[v]) swap(u, v);
  uf[u] += uf[v];
  uf[v] = u;
  return true;
}


int N, M, K, S;
vector<pair<int, pair<int, int>>> E;
vector<int> A, B, C;

vector<vector<int>> G;
vector<int> vis;
void dfs(int u, int p) {
  vis[u] = 1;
  for (const int i : G[u]) {
    const int v = A[i] ^ B[i] ^ u;
    if (p != v) {
      if (B[i] == u) {
        swap(A[i], B[i]);
      }
// cerr<<A[i]<<" <- "<<B[i]<<endl;
      dfs(v, u);
    }
  }
}

vector<Tree> nodes;
int degS, numComps;

int main() {
  for (; ~scanf("%d%d%d%d", &N, &M, &K, &S); ) {
    --S;
    E.resize(M);
    for (int i = 0; i < M; ++i) {
      int a, b, c;
      scanf("%d%d%d", &a, &b, &c);
      --a;
      --b;
      if (b == S) {
        swap(a, b);
      }
      E[i] = make_pair(c, make_pair(a, b));
    }
    sort(E.begin(), E.end());
    A.resize(M);
    B.resize(M);
    C.resize(M);
    for (int i = 0; i < M; ++i) {
      A[i] = E[i].second.first;
      B[i] = E[i].second.second;
      C[i] = E[i].first;
    }
// cerr<<"E = "<<E<<endl;
    
    /*
      - no multi-edge from S
      - not in MST other than S
    */
    vector<int> ban(M, 0);
    vector<int> used(N, 0);
    {
      for (int i = 0; i < M; ++i) if (A[i] == S) {
        if (used[B[i]]) ban[i] = 1;
        used[B[i]] = 1;
      }
    }
    {
      uf.assign(N, -1);
      for (int i = 0; i < M; ++i) if (A[i] != S) {
        if (!connect(A[i], B[i])) {
          ban[i] = 1;
        }
      }
    }
    
    vector<int> on(M);
    for (int i = 0; i < M; ++i) {
      on[i] = ban[i] ^ 1;
    }
    
    nodes.resize(N);
    for (int u = 0; u < N; ++u) {
      nodes[u] = Tree(u, used[u]);
    }
    
    G.assign(N, {});
    for (int i = 0; i < M; ++i) if (on[i]) if (A[i] != S) {
      G[A[i]].push_back(i);
      G[B[i]].push_back(i);
    }
    vis.assign(N, 0);
    vector<int> rs;
    for (int u = 0; u < N; ++u) if (u != S) if (!vis[u]) {
      rs.push_back(u);
      dfs(u, -1);
    }
    for (int i = 0; i < M; ++i) if (on[i]) if (A[i] != S) {
      nodes[B[i]].link(&nodes[A[i]]);
    }
    
    bool ok = true;
    degS = 0;
    for (int i = 0; i < M; ++i) if (on[i]) if (A[i] == S) {
      ++degS;
    }
    ok = ok && (degS >= K);
    numComps = rs.size();
    for (const int r : rs) {
      nodes[r].expose();
// cerr<<"r = "<<r<<": "<<nodes[r].sum<<endl;
      ok = ok && (nodes[r].sum >= 1);
    }
    ok = ok && (numComps <= K);
cerr<<"degS = "<<degS<<", numComps = "<<numComps<<endl;
    
    if (ok) {
      for (int i = M; --i >= 0; ) if (!ban[i]) {
        auto checkOff = [&]() -> bool {
          if (A[i] == S) {
            if (degS - 1 >= K && nodes[B[i]].root()->sum - 1 >= 1) {
              --degS;
              nodes[B[i]].expose();
              nodes[B[i]].val -= 1;
              nodes[B[i]].update();
              return true;
            } else {
              return false;
            }
          } else {
            ++numComps;
            nodes[B[i]].cut();
            if (numComps <= K && nodes[A[i]].root()->sum >= 1 && nodes[B[i]].root()->sum >= 1) {
              return true;
            } else {
              --numComps;
              nodes[B[i]].link(&nodes[A[i]]);
              return false;
            }
          }
        };
        if (checkOff()) {
          on[i] = 0;
        }
      }
      Int ans = 0;
      for (int i = 0; i < M; ++i) if (on[i]) {
        ans += C[i];
      }
      printf("%lld\n", ans);
    } else {
      puts("nonnondayo");
    }
  }
  return 0;
}