/**
 * Created by default on 21.10.14.
 */

import java.io.*;
import java.util.*;

public class path {

    FastScanner in;
    PrintWriter out;

    int vertices;
    int start;
    int edges;
    long [] dist;
    boolean [] accessible;
    boolean [] wasted;
    ArrayList<Edge> edgeList;
    ArrayList<ArrayList<Integer>> graph;

    public static final long INF = 5000000000000000000L;

    public void run() {
        try {
            in = new FastScanner(new FileInputStream("path.in"));
            out = new PrintWriter(new FileOutputStream("path.out"));
            solve();
            out.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    public void solve() throws IOException {

        try {

            vertices = in.nextInt();
            edges = in.nextInt();
            start = in.nextInt() - 1;
            wasted = new boolean[vertices];
            Arrays.fill(wasted, false);
            dist = new long[vertices];
            graph = new ArrayList<ArrayList<Integer>>();
            edgeList = new ArrayList<Edge>();
            accessible = new boolean[vertices];

            init_graph();
            fordBellman(start);

            for (int i = 0; i < vertices; i++) {
                if (wasted[i])
                    out.print("-");
                else if (dist[i] == INF)
                    out.print("*");
                else
                    out.print(dist[i]);
                out.print("\n");
            }
        } catch (Exception e){}

    }

    public void fordBellman(int vertex) {
        bfs(vertex);
        Arrays.fill(dist, INF);
        dist[vertex] = 0;
        for (int i = 0; i < vertices - 1; i++)
            for (Edge e : edgeList)
                if (dist[e.end] > dist[e.start] + e.weight) {
                    dist[e.end] = Math.max(-INF, dist[e.start] + e.weight);
                }

        for (Edge e : edgeList)
            if (dist[e.end] > dist[e.start] + e.weight && accessible[e.end])
                dfs(e.end);

    }

    public void dfs(int vertex) {
        wasted[vertex] = true;
        for (int v : graph.get(vertex))
            if (!wasted[v])
                dfs(v);
    }

    public void bfs(int vertex) {
        Deque<Integer> queue = new ArrayDeque<Integer>();
        queue.add(vertex);
        accessible[vertex] = true;
        while (!queue.isEmpty()) {
            for (int v : graph.get(queue.pollFirst())) {
                if (!accessible[v]) {
                    accessible[v] = true;
                    queue.add(v);
                }
            }
        }
    }

    public void init_graph() throws IOException {

        for (int i = 0; i < vertices; i++) {
            graph.add(new ArrayList<Integer>());
        }

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

            int edge_start = in.nextInt() - 1;
            int edge_end = in.nextInt() - 1;
            int weight = in.nextInt();

            edgeList.add(new Edge(edge_start, edge_end, weight));
            graph.get(edge_start).add(edge_end);

        }
    }

    public static class FastScanner {
        private BufferedReader reader;
        private StringTokenizer tokenizer;
        public boolean hasMoreTokens() throws IOException{
            while (tokenizer == null || !tokenizer.hasMoreTokens()) {
                String s = nextLine();
                if (s == null) return false;
                tokenizer = new StringTokenizer(s);
            }
            return true;
        }
        FastScanner(InputStream inputStream) {
            reader = new BufferedReader(new InputStreamReader(inputStream));
        }

        public String nextLine() throws IOException {
            StringBuilder sb = new StringBuilder();
            while (tokenizer != null && tokenizer.hasMoreTokens()) {
                sb.append(" ");
                sb.append(tokenizer.nextToken());
            }
            if (sb.length() == 0) {
                return reader.readLine();
            }
            return sb.toString();
        }


        public String next() throws IOException {
            while (tokenizer == null || !tokenizer.hasMoreTokens())
                tokenizer = new StringTokenizer(nextLine());
            return tokenizer.nextToken();
        }

        public int nextInt() throws NumberFormatException, IOException {
            return Integer.parseInt(next());
        }
        public long nextLong() throws NumberFormatException, IOException {
            return Long.parseLong(next());
        }


        public double nextDouble() throws NumberFormatException, IOException {
            return Double.parseDouble(next());
        }

    }

    public static void main(String[] args) {
        new path().run();
    }

    public class Edge {
        int start;
        int end;
        long weight;

        public Edge(int start, int end, long weight) {
            this.start = start;
            this.end = end;
            this.weight = weight;
        }
    }
}