Problem: In the good old Hachioji railroad station located in the west of Tokyo, there are several parking lines, and lots of freight trains come and go every day.

All freight trains travel at night, so these trains containing various types of cars are settled in your parking lines early in the morning. Then, during the daytime, you must reorganize cars in these trains according to the request of the railroad clients, so that every line contains the “right” train, i.e. the right number of cars of the right types, in the right order.

As shown in Figure 7, all parking lines run in the East-West direction. There are exchange lines connecting them through which you can move cars. An exchange line connects two ends of different parking lines. Note that an end of a parking line can be connected to many ends of other lines. Also note that an exchange line may connect the East-end of a parking line and the West-end of another.

<image>

Cars of the same type are not discriminated between each other. The cars are symmetric, so directions of cars don’t matter either.

You can divide a train at an arbitrary position to make two sub-trains and move one of them through an exchange line connected to the end of its side. Alternatively, you may move a whole train as is without dividing it. Anyway, when a (sub-) train arrives at the destination parking line and the line already has another train in it, they are coupled to form a longer train.

Your superautomatic train organization system can do these without any help of locomotive engines. Due to the limitation of the system, trains cannot stay on exchange lines; when you start moving a (sub-) train, it must arrive at the destination parking line before moving another train.

In what follows, a letter represents a car type and a train is expressed as a sequence of letters. For example in Figure 8, from an initial state having a train "aabbccdee" on line 0 and no trains on other lines, you can make "bbaadeecc" on line 2 with the four moves shown in the figure.

<image>

To cut the cost out, your boss wants to minimize the number of (sub-) train movements. For example, in the case of Figure 8, the number of movements is 4 and this is the minimum.

Given the configurations of the train cars in the morning (arrival state) and evening (departure state), your job is to write a program to find the optimal train reconfiguration plan.



Input

The input consists of one or more datasets. A dataset has the following format:


x y
p1 P1 q1 Q1
p2 P2 q2 Q2
.
.
.
py Py qy Qy
s0
s1
.
.
.
sx-1
t0
t1
.
.
.
tx-1


x is the number of parking lines, which are numbered from 0 to x-1. y is the number of exchange lines. Then y lines of the exchange line data follow, each describing two ends connected by the exchange line; pi and qi are integers between 0 and x - 1 which indicate parking line numbers, and Pi and Qi are either "E" (East) or "W" (West) which indicate the ends of the parking lines.

Then x lines of the arrival (initial) configuration data, s0, ... , sx-1, and x lines of the departure (target) configuration data, t0, ... tx-1, follow. Each of these lines contains one or more lowercase letters "a", "b", ..., "z", which indicate types of cars of the train in the corresponding parking line, in west to east order, or alternatively, a single "-" when the parking line is empty.

You may assume that x does not exceed 4, the total number of cars contained in all the trains does not exceed 10, and every parking line has sufficient length to park all the cars.

You may also assume that each dataset has at least one solution and that the minimum number of moves is between one and six, inclusive.

Two zeros in a line indicate the end of the input.

Output

For each dataset, output the number of moves for an optimal reconfiguration plan, in a separate line.

Example

Input

3 5
0W 1W
0W 2W
0W 2E
0E 1E
1E 2E
aabbccdee
-
-
-
-
bbaadeecc
3 3
0E 1W
1E 2W
2E 0W
aabb
bbcc
aa
bbbb
cc
aaaa
3 4
0E 1W
0E 2E
1E 2W
2E 0W
ababab
-
-
aaabbb
-
-
0 0


Output

4
2
5

Solution (in CPP):

Solution:
#include <algorithm>
#include <array>
#include <cstdlib>
#include <iostream>
#include <queue>
#include <unordered_map>
#include <vector>
using namespace std;

template<class T> inline void chmin(T &a, const T &b) { if(a > b) a = b; }

typedef array<int, 2> A;
typedef pair<A, A> E;
typedef unsigned hash_t;

hash_t rolling_hash(const string &s) {
	static constexpr hash_t base = 1000000007;
	hash_t res = 0;
	for(const auto &c : s) {
		res = res * base + c;
	}
	return res;
}
 
string to_str(const vector<string> &state) {
	string res = "";
	for(const auto &s : state) {
		res += s + ":";
	}
	return res;
}
 
unordered_map<hash_t, int> bfs(int limit, const vector<string> &start, const vector<E> &exchanges) {
	unordered_map<hash_t, int> res;
	queue<vector<string>> que;
 
	res.insert({rolling_hash(to_str(start)), 0});
	que.push(start);
 
	while(!que.empty()) {
		vector<string> state = que.front();
		que.pop();
		const int d = res.at(rolling_hash(to_str(state)));
 
		if(d == limit) break;
 
		for(const auto &element : exchanges) {
			const A &pos = element.first;
			const A &dir = element.second;
			const array<string, 2> train{move(state[pos.front()]), move(state[pos.back()])};

			for(int i = 0; i <= 1; ++i) {
				const int from = i;
				const int to = 1 - i;

				const int &p1 = pos[from];
				const int &p2 = pos[to];
				const int &d1 = dir[from];
				const int &d2 = dir[to];
				const string &t1 = train[from];
				const string &t2 = train[to];

				for(int num = 1; num <= t1.size(); ++num) {
					string tmp = (d1 ? t1.substr(0, num) : t1.substr(t1.size() - num));
					if(d1 == d2) reverse(tmp.begin(), tmp.end());
					state[p1] = (d1 ? t1.substr(num) : t1.substr(0, t1.size() - num));
					state[p2] = (d2 ? tmp + t2 : t2 + tmp);
 
					const hash_t h = rolling_hash(to_str(state));
					if(!res.count(h)) {
						res.insert({h, d + 1});
						que.push(state);
					}
				}
			}
 
			state[pos.front()] = move(train.front());
			state[pos.back()] = move(train.back());
		}
	}
 
	return res;
}
 
int main(){
	cin.tie(nullptr);
	ios::sync_with_stdio(false);
 
	for(int x, y; cin >> x >> y && x;) {
		vector<E> exchanges;
		exchanges.reserve(y);
 
		for(int i = 0; i < y; ++i) {
			string a, b;
			cin >> a >> b;
 
			const int p1 = a[0] - '0';
			const int d1 = (a[1] == 'W');
			const int p2 = b[0] - '0';
			const int d2 = (b[1] == 'W');
 
			exchanges.emplace_back(A{p1, p2}, A{d1, d2});
		}
 
		vector<string> lines(x), goal(x);
 
		for(auto &e : lines) {
			cin >> e;
			if(e == "-") e = "";
		}
 
		for(auto &e : goal) {
			cin >> e;
			if(e == "-") e = "";
		}
     
		const auto d1 = bfs(3, lines, exchanges);
		const auto d2 = bfs(2, goal, exchanges);
 
		int ans = 6;
		for(const auto &e1 : d2) {
			if(ans <= e1.second) continue;
 
			if(d1.count(e1.first)) {
				chmin(ans, e1.second + d1.at(e1.first));
			}
		}
 
		cout << ans << endl;
	}
 
	return EXIT_SUCCESS;
}