module WeightedDirectedGraph
  (Vertex : sig
    type t
    val compare : t -> t -> int
  end)
  (Weight : sig
    type t
    val zero : t
    val ( + ) : t -> t -> t
    val compare : t -> t -> int
  end) :
sig
  val dijkstra :
    (* 隣接リスト *)
    (Vertex.t -> (Vertex.t * Weight.t) list) ->
    (* 始点 *)
    Vertex.t ->
    (* 始点から辿り着けなければNoneを返す *)
    (Vertex.t -> Weight.t option)
end =
struct
  module WMap = Map.Make (Weight)
  module VMap = Map.Make (Vertex)

  (* ダイクストラ法のメインループ *)
  (* d に入っていない頂点への距離は無限大とみなす *)
  let rec dijkstra_aux e (d, q) =
    match WMap.min_binding q with
    | exception Not_found -> d
    | (w, us) ->
        dijkstra_aux e @@ List.fold_left (fun (d, q) u ->
          if Weight.compare (VMap.find u d) w < 0
          (* 既に頂点uを訪れていた *)
          then (d, q)
          (* w = d.(u) *)
          else List.fold_left (fun (d, q) (v, c) ->
            let open Weight in
            if
              (* d.(v) <= d.(u) + c *)
              try Weight.compare (VMap.find v d) (w + c) <= 0
              with Not_found -> false (* d.(v) は無限大 *)
            then (d, q)
            else
              VMap.add v (w + c) d,
              WMap.add (w + c) (v :: try WMap.find (w + c) q with Not_found -> []) q)
          (d, q) (e u)) (d, WMap.remove w q) us

  let dijkstra e s =
    let d =
      dijkstra_aux e
        (VMap.singleton s Weight.zero, WMap.singleton Weight.zero [s]) in
    fun t -> try Some (VMap.find t d) with Not_found -> None
end

module Int = struct
  type t = int
  let zero = 0
  let ( + ) = ( + )
  let compare = compare
end

module G = WeightedDirectedGraph (Int) (Int)

let () = Scanf.scanf "%d %d %d %d\n" @@ fun n m s t ->
  let uvab = Array.init m @@ fun _ -> Scanf.scanf "%d %d %d %d\n" @@ fun u v a b -> u, v, a, b in
  let es_yen = Array.make n [] in
  let es_snuke = Array.make n [] in
  Array.iter (fun (u, v, a, b) ->
    es_yen.(u - 1) <- (v - 1, a) :: es_yen.(u - 1);
    es_yen.(v - 1) <- (u - 1, a) :: es_yen.(v - 1);
    es_snuke.(u - 1) <- (v - 1, b) :: es_snuke.(u - 1);
    es_snuke.(v - 1) <- (u - 1, b) :: es_snuke.(v - 1)) uvab;
  let d_yen = G.dijkstra (fun u -> es_yen.(u)) (s - 1) in
  let d_snuke = G.dijkstra (fun u -> es_snuke.(u)) (t - 1) in
  let ans = Array.make (n + 1) max_int in
  for i = n - 1 downto 0 do
    ans.(i) <- min ans.(i + 1) @@
      match d_yen i, d_snuke i with
      | None, _ -> max_int
      | _, None -> max_int
      | Some d, Some d' -> d + d'
  done;
  for i = 0 to n - 1 do
    Printf.printf "%d\n" @@
      (( - ) 1000000000000000) ans.(i)
  done
