#include<iostream>

#include<cstdio>

#include<cmath>

#include<cstdlib>

#include<cstring>

#include<algorithm>

#include<cassert>

using namespace std;

#define ll long long

#define N 200010

#define inf 2100000000

char getc(){char c=getchar();while ((c<'A'||c>'Z')&&(c<'a'||c>'z')&&(c<''||c>'')) c=getchar();return c;}

int gcd(int n,int m){return m==?n:gcd(m,n%m);}

int read()

{

    int x=,f=;char c=getchar();

    while (c<''||c>'') {if (c=='-') f=-;c=getchar();}

    while (c>=''&&c<='') x=(x<<)+(x<<)+(c^),c=getchar();

    return x*f;

}

int n,m,l,r,p[N],a[N],mxdeep[N],colordeep[N],deep[N],size[N],len[N],f[N],g[N],q[N][],Q[N],t,ans=-inf;

bool flag[N];

struct data{int to,nxt,color;

}edge[N<<];

struct data2

{

    int x,y;

    bool operator <(const data2&a) const

    {

        return colordeep[y]<colordeep[a.y]||colordeep[y]==colordeep[a.y]&&y<a.y||colordeep[y]==colordeep[a.y]&&y==a.y&&mxdeep[x]<mxdeep[a.x];

    }

}v[N];

void addedge(int x,int y,int z){t++;edge[t].to=y,edge[t].nxt=p[x],edge[t].color=z,p[x]=t;}

void make(int k,int from)

{

    size[k]=;

    for (int i=p[k];i;i=edge[i].nxt)

    if (edge[i].to!=from&&!flag[edge[i].to])

    {

        deep[edge[i].to]=deep[k]+;

        make(edge[i].to,k);

        size[k]+=size[edge[i].to];

    }

}

int findroot(int k,int s)

{

    int mx=;

    for (int i=p[k];i;i=edge[i].nxt)

    if (size[edge[i].to]<size[k]&&size[edge[i].to]>size[mx]&&!flag[edge[i].to]) mx=edge[i].to;

    if ((size[mx]<<)>s) return findroot(mx,s);

    else return k;

}

void findmx(int k,int from,int root)

{

    mxdeep[root]=max(mxdeep[root],deep[k]);

    for (int i=p[k];i;i=edge[i].nxt)

    if (edge[i].to!=from&&!flag[edge[i].to]) findmx(edge[i].to,k,root);

}

inline void ins(int k,int &head,int &tail,int *f){while (head<=tail&&f[Q[tail]]<f[k]) tail--;Q[++tail]=k;}

inline void pop(int k,int &head,int &tail){while (head<=tail&&Q[head]>k) head++;}

void bfs(int k,int last,int v,int d)

{

    int head=,tail=;q[][]=k,q[][]=last;

    int h=,t=;for (int i=min(d,r);i>=l;i--) ins(i,h,t,g);

    do

    {

        int x=q[++head][];if (deep[x]>=l&&deep[x]<=r) ans=max(ans,len[x]);

        if (deep[x]>deep[q[head-][]])

        {

            pop(r-deep[x],h,t);

            if (l-deep[x]>=&&l-deep[x]<=d) ins(l-deep[x],h,t,g);

        }

        if (h<=t) ans=max(ans,len[x]+g[Q[h]]+v);

        for (int i=p[x];i;i=edge[i].nxt)

        if (deep[edge[i].to]>deep[x]&&!flag[edge[i].to])

        {

            len[edge[i].to]=len[x];

            if (edge[i].color!=q[head][]) len[edge[i].to]+=a[edge[i].color];

            q[++tail][]=edge[i].to,q[tail][]=edge[i].color;

        }

    }while (head<tail);

}

void update(int k,int from)

{

    g[deep[k]]=max(g[deep[k]],len[k]);

    for (int i=p[k];i;i=edge[i].nxt)

    if (edge[i].to!=from&&!flag[edge[i].to]) update(edge[i].to,k);

}

void solve(int k)

{

    make(k,k);k=findroot(k,size[k]);

    flag[k]=;deep[k]=;make(k,k);

    int cnt=;

    for (int i=p[k];i;i=edge[i].nxt)

    if (!flag[edge[i].to])

    {

        colordeep[edge[i].color]=mxdeep[edge[i].to]=,findmx(edge[i].to,edge[i].to,edge[i].to);

        cnt++,v[cnt].x=edge[i].to,v[cnt].y=edge[i].color;

    }

    for (int i=p[k];i;i=edge[i].nxt)

    if (!flag[edge[i].to]) colordeep[edge[i].color]=max(colordeep[edge[i].color],mxdeep[edge[i].to]);

    sort(v+,v+cnt+);

    for (int i=;i<=cnt;i++)

    {

        int t=i-,d=;

        while (t<cnt&&v[t+].y==v[i].y)

        {

            len[v[++t].x]=a[v[i].y];

            bfs(v[t].x,v[t].y,-a[v[i].y],d);

            update(v[t].x,v[t].x);d=mxdeep[v[t].x];

        }

        int H=,T=;for (int j=min(colordeep[v[i-].y],r);j>=l;j--) ins(j,H,T,f);

        for (int j=;j<=d;j++)

        {

            pop(r-j,H,T);

            if (l>=j&&l-j<=d) ins(l-j,H,T,f);

            if (H<=T) ans=max(ans,g[j]+f[Q[H]]);

        }

        for (int j=;j<=d;j++) f[j]=max(f[j],g[j]),g[j]=-inf;

        i=t;

    }

    for (int i=;i<=mxdeep[v[cnt].x];i++) f[i]=-inf;

    for (int i=p[k];i;i=edge[i].nxt)

    if (!flag[edge[i].to]) solve(edge[i].to);

}

int main()

{

#ifndef ONLINE_JUDGE

    freopen("bzoj4860.in","r",stdin);

    freopen("bzoj4860.out","w",stdout);

    const char LL[]="%I64d\n";

#else

    const char LL[]="%lld\n";

#endif

    n=read(),m=read(),l=read(),r=read();

    for (int i=;i<=n;i++) f[i]=g[i]=-inf;

    for (int i=;i<=m;i++) a[i]=read();

    for (int i=;i<n;i++)

    {

        int x=read(),y=read(),z=read();

        addedge(x,y,z),addedge(y,x,z);

    }

    solve();

    cout<<ans;

    return ;

}