#![allow(non_snake_case, unused_must_use, unused_imports)]
use std::io::{self, prelude::*};

fn main() {
    let (stdin, stdout) = (io::read_to_string(io::stdin()).unwrap(), io::stdout());
    let (mut stdin, mut buffer) = (stdin.split_whitespace(), io::BufWriter::new(stdout.lock()));

    macro_rules! input {
        ($t: tt, $n: expr) => {
            (0..$n).map(|_| input!($t)).collect::<Vec<_>>()
        };
        (Chars) => {
            input!(String).chars().collect::<Vec<_>>()
        };
        (Usize1) => {
            stdin.next().unwrap().parse::<usize>().unwrap() - 1
        };
        ($t: ty) => {
            stdin.next().unwrap().parse::<$t>().unwrap()
        };
    }

    let N = input!(usize);
    let M = input!(usize);
    let C = input!(usize);

    let mut edges = vec![];

    let mut edges2 = vec![];

    for _ in 0..M {
        let u = input!(Usize1);
        let v = input!(Usize1);
        let w = input!(usize);

        edges2.push((u, v, w + C));
        edges2.push((v, u, w + C));

        edges.push((u, v, w + C));
        edges.push((v, u, w + C));
        edges.push((u + N, v + N, w + C));
        edges.push((v + N, u + N, w + C));
        edges.push((u, v + N, C));
        edges.push((v, u + N, C));
    }

    let dist1 = dijkstras_algorithm(2 * N, &edges, N - 1);
    let dist2 = dijkstras_algorithm(2 * N, &edges2, 0);

    for i in 1..N {
        let ans2 = dist2[N - 1].unwrap();

        let ans1 = dist2[i].unwrap() + dist1[i + N].unwrap();

        writeln!(buffer, "{}", std::cmp::min(ans1, ans2));
    }
}

pub fn dijkstras_algorithm<
    W: Sized + std::ops::Add<Output = W> + PartialOrd + Ord + Default + Clone + Copy,
>(
    size: usize,
    edges: &[(usize, usize, W)],
    start: usize,
) -> Vec<Option<W>> {
    assert!(start < size);

    let graph = {
        let mut g = vec![vec![]; size];
        for &(from, to, weight) in edges.iter() {
            assert!(from < size && to < size);
            g[from].push((to, weight));
        }
        g
    };

    let mut dist = vec![None; size];
    dist[start] = Some(W::default());

    let mut hq = std::collections::BinaryHeap::new();

    hq.push((std::cmp::Reverse(W::default()), start));

    while let Some((_, now)) = hq.pop() {
        for &(nxt, weight) in graph[now].iter() {
            match dist[nxt] {
                Some(prev_dist) => {
                    if dist[now].unwrap() + weight < prev_dist {
                        let d = dist[now].unwrap() + weight;
                        dist[nxt] = Some(d);
                        hq.push((std::cmp::Reverse(d), nxt));
                    }
                }
                None => {
                    let d = dist[now].unwrap() + weight;
                    dist[nxt] = Some(d);
                    hq.push((std::cmp::Reverse(d), nxt));
                }
            }
        }
    }

    dist
}