using System;

using System.Collections.Generic;

using System.IO;

class Solution {

    static void Main(String[] args) {

        string[] s = Console.ReadLine().Split(' ');

        int numNodes = Int32.Parse(s[0]);

        int numEdges = Int32.Parse(s[1]);

        Node[] nodes = new Node[numNodes + 1];

        Edge[] edges = new Edge[numEdges + 1];

        bool[] connected = new bool[numNodes + 1];

        for (int i = 1; i <= numNodes; i++) {

            nodes[i] = new Node(i);

        }

        for (int i = 0; i < numEdges; i++) {

            s = Console.ReadLine().Split(' ');

            int nodeA = Int32.Parse(s[0]);

            int nodeB = Int32.Parse(s[1]);

            int weight = Int32.Parse(s[2]);

            Edge edge = new Edge(nodes[nodeA], nodes[nodeB], weight);

            nodes[nodeA].edges.Add(edge);

            nodes[nodeB].edges.Add(edge);

            edges[i] = edge;

        }

        int startNode = Int32.Parse(Console.ReadLine());

        int totalWeight = 0;

        HashSet<Edge> edgeOptions = new HashSet<Edge>();

        foreach (var edge in nodes[startNode].edges) {

            edgeOptions.Add(edge);

        }

​

        while(edgeOptions.Count > 0) {

            var newOptions = new HashSet<Edge>();

            Edge smallest = null;

            int minVal = Int32.MaxValue;

            foreach (var option in edgeOptions) {

                // Console.WriteLine("Option: " + option.weight);

                if (option.weight < minVal) {

                    if (! (connected[option.nodeA.value] && connected[option.nodeB.value])) {

                    smallest = option;

                    minVal = option.weight;    

                    }

                }

                if (! (connected[option.nodeA.value] && connected[option.nodeB.value])) {

                    // Console.WriteLine(" readded");

                    newOptions.Add(option);

                }

            }

            if (smallest == null) {

                break;

            }

            // Console.WriteLine("Smallest:" + smallest.weight);

            totalWeight += minVal;

            connected[smallest.nodeA.value] = true;

            connected[smallest.nodeB.value] = true;

            newOptions.Remove(smallest);

            foreach (var edge in smallest.nodeA.edges) {

                if (connected[edge.nodeA.value] && connected[edge.nodeB.value]) {

                    continue;

                } else {

                    newOptions.Add(edge);

                }

            }

            foreach (var edge in smallest.nodeB.edges) {

                if (connected[edge.nodeA.value] && connected[edge.nodeB.value]) {

                    continue;

                } else {

                    newOptions.Add(edge);

                }

            }

            edgeOptions = newOptions;

        }

        Console.WriteLine(totalWeight);

    }

}

​

public class Node {

    public Node(int value) {

        this.value = value;

        this.edges = new List<Edge>();

    }

    public int value { get; set; }

    public List<Edge> edges { get; set; }

}

​

public class Edge {

    public Edge(Node nodeA, Node nodeB, int weight) {

        this.weight = weight;

        this.nodeA = nodeA;

        this.nodeB = nodeB;

    }

    public int weight { get; set; }

    public Node nodeA { get; set; }

    public Node nodeB { get; set; }

}