package main

import (
	"bufio"
	"fmt"
	"os"
)

type Pair struct {
	dist int
	id   int
}

func compare(a, b Pair) int {
	if a.dist != b.dist {
		return a.dist - b.dist
	}
	return a.id - b.id
}

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func main() {
	in := bufio.NewReader(os.Stdin)
	var n, m_edges int
	if _, err := fmt.Fscan(in, &n, &m_edges); err != nil {
		return
	}

	dist := make([][]int, n+1)
	for i := 1; i <= n; i++ {
		dist[i] = make([]int, n+1)
		for j := 1; j <= n; j++ {
			if i == j {
				dist[i][j] = 0
			} else {
				dist[i][j] = 1e7
			}
		}
	}

	for i := 0; i < m_edges; i++ {
		var u, v, c int
		fmt.Fscan(in, &u, &v, &c)
		dist[u][v] = c
		dist[v][u] = c
	}

	var g1, g2, s1, s2 int
	fmt.Fscan(in, &g1, &g2, &s1, &s2)

	for k := 1; k <= n; k++ {
		for i := 1; i <= n; i++ {
			for j := 1; j <= n; j++ {
				if dist[i][k]+dist[k][j] < dist[i][j] {
					dist[i][j] = dist[i][k] + dist[k][j]
				}
			}
		}
	}

	P := make([][]Pair, n+1)
	minP := make([]Pair, n+1)
	maxP := make([]Pair, n+1)

	for i := 1; i <= n; i++ {
		P[i] = make([]Pair, 0, n-1)
		for j := 1; j <= n; j++ {
			if i != j {
				P[i] = append(P[i], Pair{dist[i][j], i})
			}
		}
		min_p := P[i][0]
		max_p := P[i][0]
		for _, p := range P[i] {
			if compare(p, min_p) < 0 {
				min_p = p
			}
			if compare(p, max_p) > 0 {
				max_p = p
			}
		}
		minP[i] = min_p
		maxP[i] = max_p
	}

	ans := int64(0)
	var dp [55][55]int64

	for u := 1; u <= n; u++ {
		for v := 1; v <= n; v++ {
			if u == v {
				continue
			}
			if compare(minP[u], maxP[v]) >= 0 {
				continue
			}

			possible := true
			mask := make([]int, n+1)
			for i := 1; i <= n; i++ {
				if i == u {
					mask[i] = 1
				} else if i == v {
					mask[i] = 4
				} else {
					m := 0
					if compare(minP[i], minP[u]) < 0 {
						m |= 1
					}
					if compare(maxP[i], maxP[v]) > 0 {
						m |= 4
					}
					for _, p := range P[i] {
						if compare(minP[u], p) < 0 && compare(p, maxP[v]) < 0 {
							m |= 2
							break
						}
					}
					mask[i] = m
					if m == 0 {
						possible = false
						break
					}
				}
			}
			if !possible {
				continue
			}

			for j := 0; j <= g2; j++ {
				for k := 0; k <= s2; k++ {
					dp[j][k] = 0
				}
			}
			dp[0][0] = 1

			for i := 1; i <= n; i++ {
				m := mask[i]
				for j := min(i-1, g2); j >= 0; j-- {
					for k := min(i-1-j, s2); k >= 0; k-- {
						val := dp[j][k]
						if val == 0 {
							continue
						}
						dp[j][k] = 0
						if m&4 != 0 {
							dp[j][k] += val
						}
						if m&1 != 0 && j+1 <= g2 {
							dp[j+1][k] += val
						}
						if m&2 != 0 && k+1 <= s2 {
							dp[j][k+1] += val
						}
					}
				}
			}

			for j := g1; j <= g2; j++ {
				for k := s1; k <= s2; k++ {
					ans += dp[j][k]
				}
			}
		}
	}

	fmt.Println(ans)
}