import java.util.Scanner

import scala.collection.Searching._
import scala.annotation.tailrec
import scala.collection.mutable
import scala.collection.immutable._
import scala.io.StdIn.readLine

class IUnionFind(val size: Int) {

  private case class Node(var parent: Option[Int], var treeSize: Int)

  private val nodes = Array.fill[Node](size)(new Node(None, 1))

  def union(t1: Int, t2: Int): IUnionFind = {
    if (t1 == t2) return this

    val root1 = root(t1)
    val root2 = root(t2)
    if (root1 == root2) return this

    val node1 = nodes(root1)
    val node2 = nodes(root2)

    if (node1.treeSize < node2.treeSize) {
      node1.parent = Some(t2)
      node2.treeSize += node1.treeSize
    } else {
      node2.parent = Some(t1)
      node1.treeSize += node2.treeSize
    }
    this
  }

  def connected(t1: Int, t2: Int): Boolean = t1 == t2 || root(t1) == root(t2)

  def root(t: Int): Int = nodes(t).parent match {
    case None => t
    case Some(p) => root(p)
  }
}

object Main {
  def solve(sc: => Scanner): Unit = {
    val V, E = sc.nextInt
    val start = sc.nextInt
    val que = new mutable.PriorityQueue[(Long, Int)]
    que.enqueue((0L, start))
    val A = Array.fill(V)(List[(Int, Long)]())
    for (_ <- Range(0, E)) {
      val key = sc.nextInt
      val goal = sc.nextInt
      if (!A.contains(key)) {
        A(key) = List[(Int, Long)]()
      }
      A(key) :+= (goal, sc.nextLong)
    }
    val Ans = Array.fill(V)(1L << 60)
    Ans(start) = 0
    while (que.size != 0) {
      val now = que.dequeue()
      if (Ans(now._2) == now._1) {
        if (A.contains(now._2)) {
          for (one <- A(now._2)) {
            if (Ans(one._1) > Ans(now._2) + one._2) {
              Ans(one._1) = Ans(now._2) + one._2
              que.enqueue((Ans(one._1), one._1))
            }
          }
        }
      }
    }
    println(Ans.map(x => if (x == (1L << 60)) ("INF") else (x)).mkString("\n"))
  }

  def gcd(i: Long, j: Long): Long = {
    if (i < j) (gcd(j, i)) else (if (j == 0) (i) else (gcd(j, i % j)))
  }

  def main(args: Array[String]): Unit = {
    val sc: Scanner = new Scanner(System.in)
    solve(sc)
  }
}
