As you know, an undirected connected graph with n nodes and n - 1 edges is called a tree. You are given an integer d and a tree consisting of n nodes. Each node i has a value ai associated with it.

We call a set S of tree nodes valid if following conditions are satisfied:

  1. S is non-empty.
  2. S is connected. In other words, if nodes u and v are in S, then all nodes lying on the simple path between u and v should also be presented in S.
  3. <image>.



Your task is to count the number of valid sets. Since the result can be very large, you must print its remainder modulo 1000000007 (109 + 7).

Input

The first line contains two space-separated integers d (0 ≤ d ≤ 2000) and n (1 ≤ n ≤ 2000).

The second line contains n space-separated positive integers a1, a2, ..., an(1 ≤ ai ≤ 2000).

Then the next n - 1 line each contain pair of integers u and v (1 ≤ u, v ≤ n) denoting that there is an edge between u and v. It is guaranteed that these edges form a tree.

Output

Print the number of valid sets modulo 1000000007.

Examples

Input

1 4
2 1 3 2
1 2
1 3
3 4


Output

8


Input

0 3
1 2 3
1 2
2 3


Output

3


Input

4 8
7 8 7 5 4 6 4 10
1 6
1 2
5 8
1 3
3 5
6 7
3 4


Output

41

Note

In the first sample, there are exactly 8 valid sets: {1}, {2}, {3}, {4}, {1, 2}, {1, 3}, {3, 4} and {1, 3, 4}. Set {1, 2, 3, 4} is not valid, because the third condition isn't satisfied. Set {1, 4} satisfies the third condition, but conflicts with the second condition.
import static java.lang.Math.* ;

import java.util.*;
import java.io.*;

public class Main
{
    ArrayList<Integer> [] adjList ;
    int [] a ;
    final int MOD = (int)1e9 + 7 ;

    int dfs(int u , int p , int min, int d)
    {
        long ans = 1;
        for(int v : adjList[u])
            if(v != p && !(a[min] == a[v] && v < min) && (a[v] >= a[min] && a[v] - a[min] <= d))
            {
                ans *= 1 + dfs(v , u , min , d) ;
                ans %= MOD ;
            }
        return (int)ans ;
    }

    void main() throws Exception
    {
        Scanner sc = new Scanner(System.in) ;
        PrintWriter out = new PrintWriter(System.out) ;
        int d = sc.nextInt() ;
        int n = sc.nextInt() ;
        a = new int [n] ;
        for(int i = 0 ; i < n ; i++)
            a[i] = sc.nextInt() ;
        adjList = new ArrayList[n] ;
        for(int i  = 0 ;i < n ; i++)
            adjList[i] = new ArrayList<>() ;
        int ans = 0 ;
        for(int i = 0 ; i < n - 1 ; i ++)
        {
            int u = sc.nextInt() - 1 , v = sc.nextInt() - 1 ;
            adjList[u].add(v) ;
            adjList[v].add(u) ;
        }
        for(int u = 0 ; u < n ; u++)
        {
            ans += dfs(u , -1 , u , d) ;
            ans %= MOD ;
        }
        out.println(ans);
        out.flush();
        out.close();
    }

    class Scanner
    {
        BufferedReader br;
        StringTokenizer st;

        Scanner(InputStream in)
        {
            br = new BufferedReader(new InputStreamReader(System.in));
        }

        Scanner(String path) throws Exception
        {
            br = new BufferedReader(new FileReader(path)) ;
        }
        String next() throws Exception
        {
            while (st == null || !st.hasMoreTokens())
                st = new StringTokenizer(br.readLine());
            return st.nextToken();
        }
        int nextInt() throws Exception { return Integer.parseInt(next()); }

        long nextLong() throws Exception { return Long.parseLong(next()); }

        double nextDouble() throws Exception { return Double.parseDouble(next());}
    }

    public static void main (String [] args) throws Exception {(new Main()).main();}

}