#include<stdio.h>
#include<stdlib.h>
#define INF 1000000000000001
#define NMAX 100000
#define MIN(a, b) ((a) < (b) ? (a) : (b))
struct node {
  int id;
  int weight[2];
  struct node *next;
};
struct node *list[NMAX];
int heap[NMAX], heap_index[NMAX], heapsize;
long long int dist[2][NMAX];
void Insert(int, int, int, int);
void downheap(int, int);
void upheap(int, int);
void PQ_Init(int, int);
void DijkstraPQ(int, int, int);
int main(void)
{
  int i, j, n, m, s, t, u, v, a, b;
  long long int ans[NMAX];
  scanf("%d %d %d %d", &n, &m, &s, &t);
  for (i = 0; i < n; i++) list[i] = NULL;
  for (i = 0; i < m; i++) {
    scanf("%d %d %d %d", &u, &v, &a, &b);
    Insert(u - 1, v - 1, a, b);
  }
  DijkstraPQ(s - 1, t - 1, n);
  ans[n-1] = dist[0][n-1] + dist[1][n-1];
  for (i = n - 2; i >= 0; i--) ans[i] = MIN(ans[i+1], dist[0][i] + dist[1][i]);
  for (i = 0; i < n; i++) {
    struct node *p, *q;
    printf("%lld\n", INF - ans[i] - 1);
    if (list[i] != NULL) {
      for (q = list[i], p = q->next; p != NULL; q = p, p = p->next) {
        q->next = p->next;
        free(p);
      }
      free(list[i]);
    }
  }
}
void Insert(int a, int b, int weight1, int weight2)
{
  struct node *p = (struct node*)malloc(sizeof(struct node));
  p->id = b;
  p->weight[0] = weight1;
  p->weight[1] = weight2;
  p->next = list[a];
  list[a] = p;
  p = (struct node*)malloc(sizeof(struct node));
  p->id = a;
  p->weight[0] = weight1;
  p->weight[1] = weight2;
  p->next = list[b];
  list[b] = p;
}
void downheap(int k, int index)
{
  int j, v = heap[k];
  while (k < heapsize / 2) {
    j = 2 * k + 1;
    if (j < heapsize - 1 && dist[index][heap[j]] > dist[index][heap[j + 1]]) j++;
    if (dist[index][v] <= dist[index][heap[j]]) break;
    heap[k] = heap[j];
    heap_index[heap[j]] = k;
    k = j;
  }
  heap[k] = v;
  heap_index[v] = k;
}
void upheap(int j, int index)
{
  int k, v = heap[j];
  while (j > 0) {
    k = (j + 1) / 2 - 1;
    if (dist[index][v] >= dist[index][heap[k]]) break;
    heap[j] = heap[k];
    heap_index[heap[k]] = j;
    j = k;
  }
  heap[j] = v;
  heap_index[v] = j;
}
void PQ_Init(int size, int index)
{
  int i;
  heapsize = size;
  for (i = 0; i < size; i++) {
    heap[i] = i;
    heap_index[i] = i;
  }
  for (i = size / 2 - 1; i >= 0; i--) downheap(i, index);
}
void DijkstraPQ(int p, int q, int size)
{
  int i;
  for (i = 0; i < size; i++) dist[0][i] = INF;
  dist[0][p] = 0;
  PQ_Init(size, 0);
  while (heapsize > 0) {
    struct node *n;
    int u = heap[0];
    heap[0] = heap[heapsize - 1];
    heap_index[heap[heapsize - 1]] = 0;
    heapsize--;
    downheap(0, 0);
    for (n = list[u]; n != NULL; n = n->next) {
      int w = n->weight[0];
      long long int newlen = dist[0][u] + w;
      if (newlen < dist[0][n->id]) {
        dist[0][n->id] = newlen;
        upheap(heap_index[n->id], 0);
      }
    }
  }
  for (i = 0; i < size; i++) dist[1][i] = INF;
  dist[1][q] = 0;
  PQ_Init(size, 1);
  while (heapsize > 0) {
    struct node *n;
    int u = heap[0];
    heap[0] = heap[heapsize - 1];
    heap_index[heap[heapsize - 1]] = 0;
    heapsize--;
    downheap(0, 1);
    for (n = list[u]; n != NULL; n = n->next) {
      int w = n->weight[1];
      long long int newlen = dist[1][u] + w;
      if (newlen < dist[1][n->id]) {
        dist[1][n->id] = newlen;
        upheap(heap_index[n->id], 1);
      }
    }
  }
}

Measured memory_bytes: 11904