import heapq, sys



n, m, s, t = list(map(int, input().split()))



yen_edge = [[] for _ in range(n)]

snuke_edge = [[] for _ in range(n)]



for _ in range(m):

	u, v, a, b = list(map(int, input().split()))

	yen_edge[u - 1].append([v - 1, a])

	yen_edge[v - 1].append([u - 1, a])

	snuke_edge[u - 1].append([v - 1, b])

	snuke_edge[v - 1].append([u - 1, b])



class DijkstraList():

    #隣接リスト版

    #同一頂点の複数回探索を防ぐため訪問した頂点数を変数cntで持つ

    def __init__(self, adj, start):

        self.list = adj

        self.start = start

        self.size = len(adj)



    def solve(self):

        self.dist = [float("inf") for _ in range(self.size)]

        self.dist[self.start] = 0

        self.prev = [-1 for _ in range(self.size)]

        self.q = []

        self.cnt = 0



        heapq.heappush(self.q, (0, self.start))



        while self.q and self.cnt < self.size:

            u_dist, u = heapq.heappop(self.q)

            if self.dist[u] < u_dist:

                continue

            for v, w in self.list[u]:

                if self.dist[v] > u_dist + w:

                    self.dist[v] = u_dist + w

                    self.prev[v] = u

                    heapq.heappush(self.q, (self.dist[v], v))



            self.cnt += 1



        return



    def distance(self, goal):

        return self.dist[goal]



    def path(self, goal):

        self.path = [goal]

        while self.path[-1] != self.start:

            self.path.append(self.prev[self.path[-1]])

        return self.path[::-1]



yen = DijkstraList(yen_edge, s - 1)

snuke = DijkstraList(snuke_edge, t - 1)

yen.solve()

snuke.solve()

ans_list = []



for i in range(n):

	ans_list.append(yen.distance(i) + snuke.distance(i))



ans = []



ans.append(10 ** 15 - ans_list[n - 1])



for i in range(1, n):

	if ans_list[n - i - 1] > ans_list[n - i]:

		ans_list[n - i - 1] = ans_list[n - i]

	ans.append(10 ** 15 - ans_list[n - i - 1])



for i in range(n - 1, -1, -1):

	print((ans[i]))
import heapq, sys

def input():

    return sys.stdin.readline()[:-1]



n, m, s, t = list(map(int, input().split()))



yen_edge = [[] for _ in range(n)]

snuke_edge = [[] for _ in range(n)]



for _ in range(m):

	u, v, a, b = list(map(int, input().split()))

	yen_edge[u - 1].append([v - 1, a])

	yen_edge[v - 1].append([u - 1, a])

	snuke_edge[u - 1].append([v - 1, b])

	snuke_edge[v - 1].append([u - 1, b])



class DijkstraList():

    #隣接リスト版

    #同一頂点の複数回探索を防ぐため訪問した頂点数を変数cntで持つ

    def __init__(self, adj, start):

        self.list = adj

        self.start = start

        self.size = len(adj)



    def solve(self):

        self.dist = [10**30 for _ in range(self.size)]

        self.dist[self.start] = 0

        #self.prev = [-1 for _ in range(self.size)]

        self.q = []

        self.cnt = 0



        heapq.heappush(self.q, (0, self.start))



        while self.q and self.cnt < self.size:

            u_dist, u = heapq.heappop(self.q)

            if self.dist[u] < u_dist:

                continue

            for v, w in self.list[u]:

                if self.dist[v] > u_dist + w:

                    self.dist[v] = u_dist + w

                    #self.prev[v] = u

                    heapq.heappush(self.q, (self.dist[v], v))



            self.cnt += 1



        return



    def distance(self, goal):

        return self.dist[goal]



yen = DijkstraList(yen_edge, s - 1)

snuke = DijkstraList(snuke_edge, t - 1)

yen.solve()

snuke.solve()

ans_list = []



for i in range(n):

	ans_list.append(yen.distance(i) + snuke.distance(i))



ans = []



ans.append(10 ** 15 - ans_list[n - 1])



for i in range(1, n):

	if ans_list[n - i - 1] > ans_list[n - i]:

		ans_list[n - i - 1] = ans_list[n - i]

	ans.append(10 ** 15 - ans_list[n - i - 1])



for i in range(n - 1, -1, -1):

	print((ans[i]))
import heapq, sys

n, m, s, t = list(map(int, input().split()))
yen_edge = [[] for _ in range(n)]
snuke_edge = [[] for _ in range(n)]
for _ in range(m):
    u, v, a, b = list(map(int, input().split()))
    yen_edge[u - 1].append([v - 1, a])
    yen_edge[v - 1].append([u - 1, a])
    snuke_edge[u - 1].append([v - 1, b])
    snuke_edge[v - 1].append([u - 1, b])


class DijkstraList:
    # 隣接リスト版
    # 同一頂点の複数回探索を防ぐため訪問した頂点数を変数cntで持つ
    def __init__(self, adj, start):
        self.list = adj
        self.start = start
        self.size = len(adj)

    def solve(self):
        self.dist = [float("inf") for _ in range(self.size)]
        self.dist[self.start] = 0
        self.prev = [-1 for _ in range(self.size)]
        self.q = []
        self.cnt = 0
        heapq.heappush(self.q, (0, self.start))
        while self.q and self.cnt < self.size:
            u_dist, u = heapq.heappop(self.q)
            if self.dist[u] < u_dist:
                continue
            for v, w in self.list[u]:
                if self.dist[v] > u_dist + w:
                    self.dist[v] = u_dist + w
                    self.prev[v] = u
                    heapq.heappush(self.q, (self.dist[v], v))
            self.cnt += 1
        return

    def distance(self, goal):
        return self.dist[goal]

    def path(self, goal):
        self.path = [goal]
        while self.path[-1] != self.start:
            self.path.append(self.prev[self.path[-1]])
        return self.path[::-1]


yen = DijkstraList(yen_edge, s - 1)
snuke = DijkstraList(snuke_edge, t - 1)
yen.solve()
snuke.solve()
ans_list = []
for i in range(n):
    ans_list.append(yen.distance(i) + snuke.distance(i))
ans = []
ans.append(10**15 - ans_list[n - 1])
for i in range(1, n):
    if ans_list[n - i - 1] > ans_list[n - i]:
        ans_list[n - i - 1] = ans_list[n - i]
    ans.append(10**15 - ans_list[n - i - 1])
for i in range(n - 1, -1, -1):
    print((ans[i]))

import heapq, sys


def input():
    return sys.stdin.readline()[:-1]


n, m, s, t = list(map(int, input().split()))
yen_edge = [[] for _ in range(n)]
snuke_edge = [[] for _ in range(n)]
for _ in range(m):
    u, v, a, b = list(map(int, input().split()))
    yen_edge[u - 1].append([v - 1, a])
    yen_edge[v - 1].append([u - 1, a])
    snuke_edge[u - 1].append([v - 1, b])
    snuke_edge[v - 1].append([u - 1, b])


class DijkstraList:
    # 隣接リスト版
    # 同一頂点の複数回探索を防ぐため訪問した頂点数を変数cntで持つ
    def __init__(self, adj, start):
        self.list = adj
        self.start = start
        self.size = len(adj)

    def solve(self):
        self.dist = [10**30 for _ in range(self.size)]
        self.dist[self.start] = 0
        # self.prev = [-1 for _ in range(self.size)]
        self.q = []
        self.cnt = 0
        heapq.heappush(self.q, (0, self.start))
        while self.q and self.cnt < self.size:
            u_dist, u = heapq.heappop(self.q)
            if self.dist[u] < u_dist:
                continue
            for v, w in self.list[u]:
                if self.dist[v] > u_dist + w:
                    self.dist[v] = u_dist + w
                    # self.prev[v] = u
                    heapq.heappush(self.q, (self.dist[v], v))
            self.cnt += 1
        return

    def distance(self, goal):
        return self.dist[goal]


yen = DijkstraList(yen_edge, s - 1)
snuke = DijkstraList(snuke_edge, t - 1)
yen.solve()
snuke.solve()
ans_list = []
for i in range(n):
    ans_list.append(yen.distance(i) + snuke.distance(i))
ans = []
ans.append(10**15 - ans_list[n - 1])
for i in range(1, n):
    if ans_list[n - i - 1] > ans_list[n - i]:
        ans_list[n - i - 1] = ans_list[n - i]
    ans.append(10**15 - ans_list[n - i - 1])
for i in range(n - 1, -1, -1):
    print((ans[i]))

+ + +def input(): +    return sys.stdin.readline()[:-1] + -        self.dist = [float("inf") for _ in range(self.size)] +        self.dist = [10**30 for _ in range(self.size)] -        self.prev = [-1 for _ in range(self.size)] +        # self.prev = [-1 for _ in range(self.size)] -                    self.prev[v] = u +                    # self.prev[v] = u - -    def path(self, goal): -        self.path = [goal] -        while self.path[-1] != self.start: -            self.path.append(self.prev[self.path[-1]]) -        return self.path[::-1]