#include<stdio.h>
#include<stdlib.h>
#include<string.h>

typedef struct binaryHeap{
  void *h;
  int heapSize;
  size_t size;
  int (*cmp)(const void *,const void *);
} heap;

heap* newHeap(int maxSize,size_t size,int (*cmpF)(const void *,const void *)){
  heap *res=(heap *)malloc(sizeof(heap));
  res->h=malloc(size*(maxSize+1));
  res->heapSize=0;
  res->size=size;
  res->cmp=cmpF;
  return res;
}

int isEmpty(heap *h){
  return h->heapSize==0;
}

inline void heapFunc_swap(void * restrict a,void * restrict b,void * restrict tmp,size_t size){
  memcpy(tmp,a,size);
  memcpy(a,b,size);
  memcpy(b,tmp,size);
  return;
}

void push(heap *q,void *p){
  q->heapSize+=1;
  void *h=q->h;
  int k=q->heapSize;
  size_t size=q->size;
  int (*cmp)(const void *,const void *)=q->cmp;
  memcpy(h+k*size,p,size);
  while(k>1){
    if(cmp(h+(k/2)*size,h+k*size)) return;
    heapFunc_swap(h+(k/2)*size,h+k*size,h,size);
    k/=2;
  }
  return;
}

void pop(heap *q,void *res){
  void *h=q->h;
  size_t size=q->size;
  memcpy(res,h+size,size);
  memcpy(h+size,h+size*q->heapSize,size);
  q->heapSize-=1;
  int (*cmp)(const void *,const void *)=q->cmp;
  int n=q->heapSize;
  int k=1;
  while(2*k+1<=n){
    int next=cmp(h+2*k*size,h+(2*k+1)*size)?2*k:2*k+1;
    if(cmp(h+k*size,h+next*size)) return;
    heapFunc_swap(h+k*size,h+next*size,h,size);
    k=next;
  }
  if(2*k<=n && cmp(h+2*k*size,h+k*size)) heapFunc_swap(h+k*size,h+2*k*size,h,size);
  return;
}

typedef long long int int64;

typedef struct costNode{
  int index;
  int64 cost;
} node;

int cmp(const void *a,const void *b){
  return ((node *)a)->cost<=((node *)b)->cost;
}

heap *h=NULL;
void dijkstra(int from,int *vertex,int *cost,int *next,int *start,int64 *dp,int n){
  const int64 inf=1000000000000000LL;
  int i;
  for(i=0;i<n;i++) dp[i]=inf;
  dp[from]=0;
  push(h,&((node){from,0}));
  while(!isEmpty(h)){
    node t;
    pop(h,&t);
    int v=t.index;
    if(dp[v]<t.cost) continue;
    int p;
    for(p=start[v];p!=-1;p=next[p]){
      int u=vertex[p];
      int64 m=dp[v]+cost[p];
      if(m>=dp[u]) continue;
      dp[u]=m;
      push(h,&((node){u,m}));
    }
  }
  return;
}

#define ADD(u,v,a,b,index) do{vertex[index]=u;costA[index]=a;costB[index]=b;next[index]=start[v];start[v]=index;}while(0)
void run(void){
  int n,m,s,t;
  scanf("%d%d%d%d",&n,&m,&s,&t);
  s--;t--;
  int *vertex=(int *)malloc(sizeof(int)*2*m);
  int *next=(int *)malloc(sizeof(int)*2*m);
  int *costA=(int *)malloc(sizeof(int)*2*m);
  int *costB=(int *)malloc(sizeof(int)*2*m);
  int *start=(int *)malloc(sizeof(int)*n);
  int i;
  for(i=0;i<n;i++) start[i]=-1;
  for(i=0;i<m;i++){
    int u,v,a,b;
    scanf("%d%d%d%d",&u,&v,&a,&b);
    u--;v--;
    ADD(u,v,a,b,2*i);
    ADD(v,u,a,b,2*i+1);
  }
  int64 *dpA=(int64 *)malloc(sizeof(int64)*n);
  int64 *dpB=(int64 *)malloc(sizeof(int64)*n);
  h=newHeap(n+m,sizeof(node),cmp);
  dijkstra(s,vertex,costA,next,start,dpA,n);
  dijkstra(t,vertex,costB,next,start,dpB,n);
  int64 *ans=(int64 *)malloc(sizeof(int64)*n);
  const int64 ini=1000000000000000LL;
  ans[n-1]=ini-(dpA[n-1]+dpB[n-1]);
  for(i=n-2;i>=0;i--){
    int64 m=ini-(dpA[i]+dpB[i]);
    ans[i]=m>=ans[i+1]?m:ans[i+1];
  }
  for(i=0;i<n;i++) printf("%lld\n",ans[i]);
}

int main(void){
  run();
  return 0;
}


Measured memory_bytes: 9856