import java.io.*;
import java.security.AlgorithmConstraints;
import java.util.*;

public class Problem5 {
	MyScanner input;
	PrintWriter output;

	class MyScanner {
		public BufferedReader input;
		private String buffer = "";
		private int bufPointer = 0;

		public MyScanner(String file) throws Exception {
			input = new BufferedReader(new FileReader(file));
			buffer = input.readLine();
		}

		private boolean readNewBuf() throws IOException {
			if (bufPointer >= buffer.length()) {
				bufPointer = 0;
				buffer = input.readLine();
				return true;
			}
			return false;
		}

		public String nextLine() throws Exception {
			while (readNewBuf()) {
			}
			if (bufPointer == 0) {
				String temp = buffer;
				bufPointer = buffer.length();
				readNewBuf();
				return temp;
			} else {
				String temp = "";
				for (; bufPointer < buffer.length(); bufPointer++) {
					temp += buffer.charAt(bufPointer);
				}
				readNewBuf();
				return temp;
			}
		}

		public int nextInt() throws Exception {
			readNewBuf();
			while (buffer.charAt(bufPointer) == ' ') {
				bufPointer++;
				readNewBuf();
			}

			int res = 0, plus = 1;
			if (buffer.charAt(bufPointer) == '-') {
				plus = -1;
				bufPointer++;
			}

			while (bufPointer < buffer.length()
					&& buffer.charAt(bufPointer) >= '0'
					&& buffer.charAt(bufPointer) <= '9') {
				res = res * 10 + buffer.charAt(bufPointer) - '0';
				bufPointer++;
			}

			return res * plus;
		}

		public char nextChar() throws Throwable {
			readNewBuf();
			while (buffer.charAt(bufPointer) == ' ') {
				bufPointer++;
				readNewBuf();
			}

			char res = buffer.charAt(bufPointer);
			bufPointer++;
			return res;
		}
	}

	private static final int ALPHABIT = 'z' - 'a' + 1;

	static class Vertex {
		boolean term;
		long[] words;

		List<Integer>[] edges = (LinkedList<Integer>[]) new LinkedList[AS];

		Vertex() {
			for (int i = 0; i < ALPHABIT; i++) {
				edges[i] = new LinkedList<Integer>();
			}
		}


	}

	static class NewVertex {
		public boolean term = false;
		public int num;
		public int[] edges = new int[ALPHABIT];
		public Set<Integer> name;
		public long[] words;

		public NewVertex(Set<Integer> name, int l, int num) {
			this.name = name;
			this.num = num;

			words = new long[l + 1];
		}

		public void add(int num, char by) {
			edges[by - 'a'] = by;
		}

		@Override
		public boolean equals(Object o) {
			if (o instanceof NewVertex) {
				return name.equals(((NewVertex) o).name);
			}

			return false;
		}
	}

	private void solve()  throws Throwable  {
		int n = input.nextInt();
		int m = input.nextInt();
		int k = input.nextInt();
		int l = input.nextInt();

		Vertex[] vert = new Vertex[n];
		for (int i = 0; i < n; i++) {
			vert[i] = new Vertex();
		}

		for (int i = 0; i < k; i++) {
			vert[input.nextInt() - 1].term= true;
		}

		int a, b;
		char c;
		for (int i = 0; i < m; i++) {
			a = input.nextInt() - 1;
			b = input.nextInt() - 1;
			c = input.nextChar();

			vert[a].add(b, c);
		}

		Queue<Set<Integer>> Q = new LinkedList<Set<Integer>>();
		LinkedList<Integer> from = new LinkedList<Integer>();
		LinkedList<Character> by  = new LinkedList<Character>();


		ArrayList<NewVertex> newQ = new ArrayList<NewVertex>();
		int num = 0;
		Set<Integer> temp = new HashSet<Integer>();
		temp.add(0);
		from.add(-1);
		by.add('0');
		Q.add(temp);

		while (!Q.isEmpty()) {

			Set<Integer> qd_Q = Q.poll();
			int qd_from = from.poll();
			char qd_by = by.poll();
			newQ.add(new NewVertex(qd_Q, l, num));

			if (qd_from != -1 ) {
				newQ.get(qd_from).add(num, qd_by);
			}

			num++;

			for (int i = 0; i < ALPHABIT; i++) {
				Set<Integer> pd = new HashSet<Integer>();

				for (int q : qd_Q) {
					pd.addALL(vertexes[q].edges[i]);
				}

				while(!pd.isEmpty()) {
					NewVertex v = new NewVertex(pd, -1, -1);
					if (newQ.contains(v)) {
						int to = newQ.indexOf(v);
						newQ.get(num - 1).edges[i] = to;
					} else {
						Q.add(pd);
						from.add(num - 1);
						char nn = (char)('a' + i);
						by.add(nn);
					}
				}
			}
		}
		for (NewVertex v : newQ) {
			boolean ans = false;
			for (int i: v.name) {
				if (vertexes[i].term) {
					ans = true;
					break;
				}
			}
			v.term = ans;
		}

		newQ.get(0).words[0] = 1;



		for (NewVertex v: newQ) {
			for (int i = 0; i < ALPHABIT; i++) {
				if (newQ.get(v).edges[i] != -1) {
					int u = newQ.get(v).edges[i];
					newQ.get(u).words[length] = (newVert.get(u).words[length] + newQ.get(v).words[length - 1]) % 1000000007;
				}
			}
		}


		long result = 0;

		for (int i = 0; i < newQ.size(); i++) {
			if (newQ.get(i).term) {
				result = (result + Math.max(newQ.get(i).words[l], 0)) % 1000000007;
			}
		}

		output.println(result);
	}


	private void run() throws Throwable {
		try {
			solve();
		} finally {
		}
	}

	public Problem5() throws Exception {
		input = new MyScanner("problem5.in");
		output = new PrintWriter("problem5.out");
	}

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

}