import java.io.{BufferedReader, InputStream, InputStreamReader, PrintWriter}
import java.util.StringTokenizer

import scala.collection.mutable
import scala.util.Sorting
import math.{abs, max, min}
import scala.collection.mutable.{ArrayBuffer, ListBuffer}
import scala.reflect.ClassTag

object Main {
  val MOD = 1000000007
  val out = new PrintWriter(System.out)
  def solve(): Unit = {
    val sc = new InputReader(System.in)
    val n, m = sc.nextInt()
    val s, t = sc.nextInt() - 1
    val u, v, a, b = Array.ofDim[Int](m)
    rep(m) { i =>
      u(i) = sc.nextInt() - 1
      v(i) = sc.nextInt() - 1
      a(i) = sc.nextInt()
      b(i) = sc.nextInt()
    }
    val g1 = packWUGraph(n, u, v, a)
    val g2 = packWUGraph(n, u, v, b)

    def dijk(g: WUGraph, start: Int): Array[Long] = {
      val d = Array.fill[Long](n)(Long.MaxValue / 2)
      type Visit = (Int, Long)
      val queue = mutable.PriorityQueue.empty[Visit](Ordering.by[Visit, Long](_._2).reverse)
      d(start) = 0
      queue.enqueue((start, 0))

      while(queue.nonEmpty) {
        val (v, c0) = queue.dequeue()
        if (d(v) == c0) {
          g(v) foreach { e =>
            val u = e(0)
            val c1 = e(1)
            if (d(u) > c0 + c1) {
              d(u) = c0 + c1
              queue.enqueue((u, c0 + c1))
            }
          }
        }
      }

      d
    }

    val d1 = dijk(g1, s)
    val d2 = dijk(g2, t)

    val money = 1e15.toLong
    val ans = map(n)(i => money - d1(i) - d2(i))
    rep_r(n - 1)(i => ans(i) = max(ans(i), ans(i + 1)))
    rep(n)(i => out.println(ans(i)))
  }


  def main(args: Array[String]): Unit = {
    solve()
    out.flush()
  }


  class InputReader(val stream: InputStream) {
    private val reader = new BufferedReader(new InputStreamReader(stream), 32768)
    private var tokenizer: StringTokenizer = null

    def next: String = {
      while (tokenizer == null || !tokenizer.hasMoreTokens)
        tokenizer = new StringTokenizer(reader.readLine)
      tokenizer.nextToken
    }

    def nextInt(): Int = next.toInt
    def nextLong(): Long = next.toLong
    def nextChar(): Char = next.charAt(0)
  }

  private def rep(n: Int)(f: Int => Unit): Unit = (0 until n) foreach f
  private def rep_r(n: Int)(f: Int => Unit): Unit = (0 until n).reverse foreach f

  private def map[@specialized A: ClassTag](n: Int)(f: Int => A): Array[A] = {
    val res = Array.ofDim[A](n)
    (0 until n) foreach (i => res(i) = f(i))
    res
  }

  private implicit class ArrayOpts[A](val as: Array[A]) extends AnyVal {
    def maxByOpt[B: Ordering](f: A => B): Option[A] = {
      if (as.nonEmpty) Some(as.maxBy(f)) else None
    }

    def grpBy[K](f: A => K): mutable.Map[K, ArrayBuffer[A]] = {
      val map = mutable.Map.empty[K, ArrayBuffer[A]]
      rep(a => map.getOrElseUpdate(f(a), ArrayBuffer()) += a)
      map
    }

    def rep(f: A => Unit): Unit = {
      as.indices foreach (i => f(as(i)))
    }

    def sumBy[B](f: A => B)(implicit num: Numeric[B]): B = {
      var sum = num.zero
      rep(a => sum = num.plus(sum, f(a)))
      sum
    }

    def minByEx[B](f: A => B, ixRange: Range = as.indices)(implicit cmp: Ordering[B]): (A, B) = {
      limit(f, ixRange)(cmp.lt)
    }

    def maxByEx[B](f: A => B, ixRange: Range = as.indices)(implicit cmp: Ordering[B]): (A, B) = {
      limit(f, ixRange)(cmp.gt)
    }

    private def limit[B](f: A => B, ixRange: Range)(cmp: (B, B) => Boolean): (A, B) = {
      var limA = as(ixRange.head)
      var limB = f(limA)

      for (i <- ixRange.tail) {
        val a = as(i)
        val b = f(a)
        if (cmp(b, limB)) {
          limA = a
          limB = b
        }
      }
      (limA, limB)
    }
  }

  private implicit class IterableOpts[A](val as: Iterable[A]) extends AnyVal {
    def sumBy[B](f: A => B)(implicit num: Numeric[B]): B = {
      as.foldLeft(num.zero)((acc, a) => num.plus(acc, f(a)))
    }
  }

  type WUGraph = Array[Array[Array[Int]]]
  /**
    * uwiのぱくり
    */
  def packWUGraph(n: Int, from: Array[Int], to: Array[Int], w: Array[Int]): WUGraph = {
    val g = new Array[Array[Array[Int]]](n)
    val p = new Array[Int](n)
    for (f <- from) p(f) += 1
    for (t <- to) p(t) += 1
    rep(n)(i => g(i) = Array.ofDim[Int](p(i), 2))
    rep(from.length) { i =>
      p(from(i)) -= 1
      g(from(i))(p(from(i)))(0) = to(i)
      g(from(i))(p(from(i)))(1) = w(i)
      p(to(i)) -= 1
      g(to(i))(p(to(i)))(0) = from(i)
      g(to(i))(p(to(i)))(1) = w(i)
    }
    g
  }
}


Measured memory_bytes: 134340