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 java.io.*;
import java.util.*;

public class Task {
		
	public static void main(String[] args) throws IOException {
		new Task().solve();
	}
	
	PrintWriter out;
	int cnt = 0;
	int n;
	boolean[] used;
	int[] use;
	LinkedList<Integer>[] gr;
	ArrayList<Integer> tsort = new ArrayList<Integer>();
	int[] comp;
	int[] compsize;
	int[] mt;
	int[] a;
	int k;
	boolean[][] g;
	long dp[];
	int m;
	int[] list;
	int d;
	int ver = 0;
	int mod = 1000000007;
	void solve() throws IOException{
		Reader in = new Reader("output.txt");
		out = new PrintWriter( new BufferedWriter(new OutputStreamWriter(System.out)) );
		//out = new PrintWriter(new FileWriter(new File("output.txt"))); 
		
		d = in.nextInt();
		n = in.nextInt();
		
		g = new boolean[n][n];
		list = new int[n];
		
		for (int i = 0; i < n; i++)
			list[i] = in.nextInt();
		
		gr = new LinkedList[n];
		
		for (int i = 0; i < n; i++)
			gr[i] = new LinkedList<Integer>();
		
		for (int i = 0; i < n-1; i++)
		{
			int x = in.nextInt()-1;
			int y = in.nextInt()-1;
			g[x][y] = true;
			g[y][x] = true;
			gr[x].add(y);
			gr[y].add(x);
		}
		
		dp = new long[n];
		use = new int[n];
		
		long cnt = 0;
		
		
		for (int i = 0; i < n; i++) {
			ver = i;
			Arrays.fill(dp, 0);
			dfs(i, -1);
			cnt = (cnt+dp[i])%mod;
			
			//System.out.println();
		}
		
		out.print(cnt);
		out.flush();
		out.close();
		
	}
	
	void dfs(int v, int p) {
		//System.out.println(v+1);
		use[v] = 1;
		dp[v] = 1;
		for (int i : gr[v])
			if (i != p) {
				
					if (list[i] < list[ver] || list[i] > list[ver]+d) continue;
					if (list[i] == list[ver] && i < ver) continue;
					dfs(i, v);
					dp[v] = (dp[v]*(dp[i]+1))%mod;
			}
	}
	
	long pow(int x, int m) {
		if (m == 0)
			return 1;
		return x*pow(x, m-1);
	}

}
	
	class Pair implements Comparable<Pair> {
		
		int v;
		int i;
		
		Pair (int v, int i) {
			this.v = v;
			this.i = i;
		}

		@Override
		public int compareTo(Pair p) {
			if (v > p.v)
				return 1;
			if (v < p.v)
				return -1;
			return 0;
		}
		
	}

	class Item implements Comparable<Item> {

		int v;
		int l;
		int z;
		
		Item(int v, int l, int z) {
			this.v = v;
			this.l = l;
			this.z = z;
		}
		
		@Override
		public int compareTo(Item item) {
			
			if (l > item.l)
				return 1;
			else
			if (l < item.l)
				return -1;
			else {
				if (z > item.z)
					return 1;
				else
				if (z < item.z)
					return -1;
				return 0;
			}
						
		}
		
	}
	
	class Reader {
	    
	    StringTokenizer token;
	    BufferedReader in;
	    
	    public Reader(String file) throws IOException {
	        //in = new BufferedReader( new FileReader( file ) );
	        in = new BufferedReader( new InputStreamReader( System.in ) );
	    }
	    
	    public byte nextByte() throws IOException {
	        return Byte.parseByte(Next());
	    }
	    
	    public int nextInt() throws IOException {
	        return Integer.parseInt(Next());
	    }
	    
	    public long nextLong() throws IOException {
	        return Long.parseLong(Next());
	    }
	    
	    public String nextString() throws IOException {
	        return in.readLine();
	    }
	    
	    public String Next() throws IOException {
	        while (token == null || !token.hasMoreTokens()) {
	            token = new StringTokenizer(in.readLine());
	        }
	        return token.nextToken();
	    }

	    
	}

	
