There are b blocks of digits. Each one consisting of the same n digits, which are given to you in the input. Wet Shark must choose exactly one digit from each block and concatenate all of those digits together to form one large integer. For example, if he chooses digit 1 from the first block and digit 2 from the second block, he gets the integer 12. 

Wet Shark then takes this number modulo x. Please, tell him how many ways he can choose one digit from each block so that he gets exactly k as the final result. As this number may be too large, print it modulo 109 + 7.

Note, that the number of ways to choose some digit in the block is equal to the number of it's occurrences. For example, there are 3 ways to choose digit 5 from block 3 5 6 7 8 9 5 1 1 1 1 5.

Input

The first line of the input contains four space-separated integers, n, b, k and x (2 ≤ n ≤ 50 000, 1 ≤ b ≤ 109, 0 ≤ k < x ≤ 100, x ≥ 2) — the number of digits in one block, the number of blocks, interesting remainder modulo x and modulo x itself.

The next line contains n space separated integers ai (1 ≤ ai ≤ 9), that give the digits contained in each block.

Output

Print the number of ways to pick exactly one digit from each blocks, such that the resulting integer equals k modulo x.

Examples

Input

12 1 5 10
3 5 6 7 8 9 5 1 1 1 1 5


Output

3


Input

3 2 1 2
6 2 2


Output

0


Input

3 2 1 2
3 1 2


Output

6

Note

In the second sample possible integers are 22, 26, 62 and 66. None of them gives the remainder 1 modulo 2.

In the third sample integers 11, 13, 21, 23, 31 and 33 have remainder 1 modulo 2. There is exactly one way to obtain each of these integers, so the total answer is 6.

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

public class E {
	InputStream is;

	int __t__ = 1;
	int __f__ = 0;
	int __FILE_DEBUG_FLAG__ = __f__;
	String __DEBUG_FILE_NAME__ = "src/T";

	FastScanner in;
	PrintWriter out;

	static int MOD = 1000000007;
	// Matrix Calculator (long)
	static class Matrix_L {
		static long[][] add(long[][] a, long[][] b) {
			int n1 = a.length, m1 = a[0].length;
			int n2 = b.length, m2 = b[0].length;			
			if (n1 != n2 || m1 != m2) throw new RuntimeException();			

			long[][] res = new long[n1][m1];
			
			for (int i = 0; i < n1; i++) for (int j = 0; j < m1; j++) {
				res[i][j] = a[i][j] + b[i][j];
			}
			
			return res;
		}
		
		static long[][] sub(long[][] a, long[][] b) {
			int n1 = a.length, m1 = a[0].length;
			int n2 = b.length, m2 = b[0].length;			
			if (n1 != n2 || m1 != m2) throw new RuntimeException();			

			long[][] res = new long[n1][m1];
			
			for (int i = 0; i < n1; i++) for (int j = 0; j < m1; j++) {
				res[i][j] = a[i][j] - b[i][j];
			}
			
			return res;
		}
		
		static long[][] mult(long[][] a, long[][] b) {
			int n1 = a.length, m1 = a[0].length;
			int n2 = b.length, m2 = b[0].length;
			if (n1 != m2 || n2 != m1) throw new RuntimeException();			

			long[][] res = new long[n1][m2];
			
			for (int i = 0; i < n1; i++) for (int j = 0; j < m2; j++) {
				for (int k = 0; k < m1; k++) {
					res[i][j] = (res[i][j] + a[i][k] * b[k][j]) % MOD; 
				}
			}

			return res;
		}
		
		static long[][] pow(long[][] a, long N) {
			int n = a.length, m = a[0].length;
			if (n != m) throw new RuntimeException();
			
			long[][] tmp = new long[n][n];
			long[][] res = new long[n][n];
			
			for (int i = 0; i < n; i++) res[i][i] = 1;					
			for (int i = 0; i < n; i++) for (int j = 0; j < n; j++) 
				tmp[i][j] = a[i][j];
						
			while (N > 0) {
				if (N % 2 == 1) res = mult(res, a);
				
				N /= 2;
				a = mult(a, a);
			}
			
			return res;
		}
		
		static void debug(long[][] a) {
			for (int i = 0; i < a.length; i++) {
				for (int j = 0; j < a[i].length; j++) {
					System.out.print(a[i][j] + " ");
				}
				System.out.println();
			}
		}
	}
	
	public void solve() {
		int n = in.nextInt(), b = in.nextInt(), k = in.nextInt(), x = in.nextInt();
		int[] a = in.nextIntArray(n);
		long[][] mat = new long[x][x];
		int[] cnt = new int[10];
		for (int i = 0; i < n; i++) {
			cnt[a[i]]++;
		}
		for (int i = 0; i < x; i++) {
			for (int j = 0; j < 10; j++) {
				int y = (i * 10 + j) % x;
				mat[i][y] = (mat[i][y] + cnt[j]) % MOD;
			}
		}
		
		long[][] res = Matrix_L.pow(mat, b);
		System.out.println(res[0][k]);
	}

	public void run() {
		if (__FILE_DEBUG_FLAG__ == __t__) {
			try {
				is = new FileInputStream(__DEBUG_FILE_NAME__);
			} catch (FileNotFoundException e) {
				// TODO 自動生成された catch ブロック
				e.printStackTrace();
			}
			System.out.println("FILE_INPUT!");
		} else {
			is = System.in;
		}
		in = new FastScanner(is);
		out = new PrintWriter(System.out);

		solve();
	}

	public static void main(String[] args) {
		new E().run();
	}

	public void mapDebug(long[][] a) {
		System.out.println("--------map display---------");

		for (int i = 0; i < a.length; i++) {
			for (int j = 0; j < a[i].length; j++) {
				System.out.printf("%3d ", a[i][j]);
			}
			System.out.println();
		}

		System.out.println("----------------------------");
		System.out.println();
	}

	public void debug(Object... obj) {
		System.out.println(Arrays.deepToString(obj));
	}

	class FastScanner {
		private InputStream stream;
		private byte[] buf = new byte[1024];
		private int curChar;
		private int numChars;

		public FastScanner(InputStream stream) {
			this.stream = stream;
			//stream = new FileInputStream(new File("dec.in"));

		}

		int read() {
			if (numChars == -1)
				throw new InputMismatchException();
			if (curChar >= numChars) {
				curChar = 0;
				try {
					numChars = stream.read(buf);
				} catch (IOException e) {
					throw new InputMismatchException();
				}
				if (numChars <= 0)
					return -1;
			}
			return buf[curChar++];
		}

		boolean isSpaceChar(int c) {
			return c == ' ' || c == '\n' || c == '\r' || c == '\t' || c == -1;
		}

		boolean isEndline(int c) {
			return c == '\n' || c == '\r' || c == -1;
		}

		int nextInt() {
			return Integer.parseInt(next());
		}

		int[] nextIntArray(int n) {
			int[] array = new int[n];
			for (int i = 0; i < n; i++)
				array[i] = nextInt();

			return array;
		}

		int[][] nextIntMap(int n, int m) {
			int[][] map = new int[n][m];
			for (int i = 0; i < n; i++) {
				map[i] = in.nextIntArray(m);
			}
			return map;
		}

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

		long[] nextLongArray(int n) {
			long[] array = new long[n];
			for (int i = 0; i < n; i++)
				array[i] = nextLong();

			return array;
		}

		long[][] nextLongMap(int n, int m) {
			long[][] map = new long[n][m];
			for (int i = 0; i < n; i++) {
				map[i] = in.nextLongArray(m);
			}
			return map;
		}

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

		double[] nextDoubleArray(int n) {
			double[] array = new double[n];
			for (int i = 0; i < n; i++)
				array[i] = nextDouble();

			return array;
		}

		double[][] nextDoubleMap(int n, int m) {
			double[][] map = new double[n][m];
			for (int i = 0; i < n; i++) {
				map[i] = in.nextDoubleArray(m);
			}
			return map;
		}

		String next() {
			int c = read();
			while (isSpaceChar(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isSpaceChar(c));
			return res.toString();
		}

		String[] nextStringArray(int n) {
			String[] array = new String[n];
			for (int i = 0; i < n; i++)
				array[i] = next();

			return array;
		}

		String nextLine() {
			int c = read();
			while (isEndline(c))
				c = read();
			StringBuilder res = new StringBuilder();
			do {
				res.appendCodePoint(c);
				c = read();
			} while (!isEndline(c));
			return res.toString();
		}
	}
}

