#include<cstdio>
#include<queue>
#include<cstring>
using namespace std;
#define ll long long
const int Maxn = 1550,Maxm = 6e5 + 50;
const int INF = 0x7f7f7f7f;
int n,m,s1,e1,s2,e2;
int vis[Maxn],dir[Maxn][Maxn][5],map[Maxn][Maxn],min_t[Maxn][5],time[5],head[Maxn],indeg[Maxn],ans[Maxn][5],vis1[Maxn][Maxn],judge[Maxn],head1[Maxn][5],indeg1[Maxn][5];

int max(int x,int y){
    return x > y ? x : y;
}

struct Side{
    int w;
    int e;
    int next;
    int last;
    Side(){
        next = 0;
        last = 0;
    }
}side[Maxm],side1[Maxm][5];

void add(int s,int e,int w,int t){
    side[t].w = w;
    side[t].e = e;
    side[t].next = head[s];
    side[head[s]].last = t;
    head[s] = t;
}

void del(int x,int s){
    if(x == head[s]){
        head[s] = side[x].next;
    }else{
        side[side[x].last].next = side[x].next;
    }
}

struct Node{
    int w;
    int e;
    int operator < (const Node &x) const &{
        return x.w < w;
    }
};

priority_queue<Node> Q;

void dijkstra(int s,int x){
    int i,t;
    Node cur;
    memset(vis,0,sizeof(vis));
    Q.push((Node){0,s});
    while(!Q.empty()){
        cur = Q.top();
        Q.pop();
        t = cur.e;
        if(vis[t])continue;
        vis[t] = 1;
        for(i = head[t];i;i = side[i].next){
            if(min_t[side[i].e][x] > min_t[t][x] + side[i].w){
                min_t[side[i].e][x] = min_t[t][x] + side[i].w;
                if(!vis[side[i].e]){
                    Q.push((Node){min_t[side[i].e][x],side[i].e});
                }
            }
        }
    }
}

queue<int> Q1;
void clear(){
    while(!Q1.empty())Q1.pop();
}

void Set(int s){
    memset(vis,0,sizeof(vis));
    memset(indeg,0,sizeof(indeg));
    clear();
    Q1.push(s);
    int i,cur;
    while(!Q1.empty()){
        cur = Q1.front();
        Q1.pop();
        if(vis[cur])continue;
        vis[cur] = 1;
        for(i = head[cur];i;i = side[i].next){
            if(!vis[side[i].e]){
                ++indeg[side[i].e];
                Q1.push(side[i].e);
            }
        }
    }
}

void add1(int s,int e,int w,int t,int f){
    side1[t][f].w = w;
    side1[t][f].e = e;
    side1[t][f].next = head1[s][f];
    head1[s][f] = t;
    indeg1[e][f] += 1;
}

void Topsort1(int s){
    Set(s);
    int i,cur,cnt1 = 0,cnt2 = 0;
    clear();
    Q1.push(s);
    while(!Q1.empty()){
        cur = Q1.front();
        Q1.pop();
        for(i = head[cur];i;i = side[i].next){
            --indeg[side[i].e];
            if(!indeg[side[i].e])Q1.push(side[i].e);
            if(vis1[cur][side[i].e])continue;
            vis1[cur][side[i].e] = 1;
            vis1[side[i].e][cur] = 1;
            if((side[i].w + min_t[cur][0] + min_t[side[i].e][2] == time[1]) && side[i].w + min_t[cur][1] + min_t[side[i].e][3] == time[2]){
                ++cnt1;
                add1(cur,side[i].e,side[i].w,cnt1,1);
            }
            if((side[i].w + min_t[cur][0] + min_t[side[i].e][2] == time[1]) && side[i].w + min_t[side[i].e][1] + min_t[cur][3] == time[2]){
                ++cnt2;
                add1(cur,side[i].e,side[i].w,cnt2,2);
            }
        }
    }
}

void Topsort2(int f){
    int i,cur;
    clear();
    for(i = 1;i <= n;++i){
        if(!indeg1[i][f])Q1.push(i);
    }
    while(!Q1.empty()){
        cur = Q1.front();
        Q1.pop();
        for(i = head1[cur][f];i;i = side1[i][f].next){
            ans[side1[i][f].e][f] = max(ans[side1[i][f].e][f],ans[cur][f] + side1[i][f].w);
            --indeg1[side1[i][f].e][f];
            if(!indeg1[side1[i][f].e][f]){
                Q1.push(side1[i][f].e);
            }
        }
    }
}

int main(){
    int i,j,t1,t2,t3,top,res = 0;
    scanf("%d %d",&n,&m);
    scanf("%d %d %d %d",&s1,&e1,&s2,&e2);
    for(i = 1;i <= n;++i){
        min_t[i][0] = INF;
        min_t[i][1] = INF;
        min_t[i][2] = INF;
        min_t[i][3] = INF;
    }
    min_t[s1][0] = 0;
    min_t[s2][1] = 0;
    min_t[e1][2] = 0;
    min_t[e2][3] = 0;
    for(i = 0;i < m;++i){
        scanf("%d %d %d",&t1,&t2,&t3);
        add(t1,t2,t3,i*2+1);
        add(t2,t1,t3,i*2+2);
    }
    dijkstra(s1,0);
    dijkstra(s2,1);
    dijkstra(e1,2);
    dijkstra(e2,3);
    time[1] = min_t[e1][0];
    time[2] = min_t[e2][1];
    memset(vis1,0,sizeof(vis1));
    Topsort1(s1);
    memset(vis1,0,sizeof(vis1));
    Topsort2(1);
    Topsort2(2);
    for(i = 1;i <= n;++i){
        res = max(res,max(ans[i][1],ans[i][2]));
    }
    printf("%d",res);
    scanf("%d %d",&n,&m);
    return 0;
}

/*
9 9
1 6 4 9
1 2 1
2 3 9
3 4 1
3 5 1
5 6 1
5 7 1
8 7 2
2 8 7
8 9 1

3
*/