Mark and his crew are sailing across the sea of Aeolus (in Greek mythology Aeolus was the keeper of the winds). They have the map which represents the NxM matrix with land and sea fields and they want to get to the port (the port is considered as sea field). They are in a hurry because the wind there is very strong and changeable and they have the food for only K days on the sea (that is the maximum that they can carry on the ship). John, the guy from Mark's crew, knows how to predict the direction of the wind on daily basis for W days which is enough time for them to reach the port or to run out of the food. Mark can move the ship in four directions (north, east, south, west) by one field for one day, but he can also stay in the same place. Wind can blow in four directions (north, east, south, west) or just not blow that day. The wind is so strong at the sea of Aeolus that it moves the ship for one whole field in the direction which it blows at. The ship's resulting movement is the sum of the ship's action and wind from that day. Mark must be careful in order to keep the ship on the sea, the resulting movement must end on the sea field and there must be a 4-connected path through the sea from the starting field. A 4-connected path is a path where you can go from one cell to another only if they share a side.

For example in the following image, the ship can't move to the port as there is no 4-connected path through the sea. 

<image>

In the next image, the ship can move to the port as there is a 4-connected path through the sea as shown with the red arrow. Furthermore, the ship can move to the port in one move if one of the following happens. Wind is blowing east and Mark moves the ship north, or wind is blowing north and Mark moves the ship east. In either of these scenarios the ship will end up in the port in one move. 

<image>

Mark must also keep the ship on the map because he doesn't know what is outside. Lucky for Mark and his crew, there are T fish shops at the sea where they can replenish their food supplies to the maximum, but each shop is working on only one day. That means that Mark and his crew must be at the shop's position on the exact working day in order to replenish their food supplies. Help Mark to find the minimum of days that he and his crew need to reach the port or print -1 if that is impossible with the food supplies that they have.

Input

First line contains two integer numbers N and M (1 ≤ N, M ≤ 200) - representing the number of rows and number of columns of the map. 

Second line contains three integers, K (0 ≤ K ≤ 200) which is the number of days with the available food supplies, T (0 ≤ T ≤ 20) which is the number of fields with additional food supplies and W (0 ≤ W ≤ 10^6) which is the number of days with wind information.

Next is the NxM char matrix filled with the values of 'L', 'S', 'P' or 'M'. 'L' is for the land and 'S' is for the sea parts. 'P' is for the port field and 'M' is the starting field for the ship.

Next line contains W chars with the wind direction information for every day. The possible inputs are 'N' - north, 'S' - south, 'E' - east, 'W' - west and 'C' - no wind. If Mark's crew can reach the port, it is guaranteed that they will not need more than W days to reach it.

In the end there are T lines with the food supplies positions. Each line contains three integers, Y_i and X_i (0 ≤ Y_i < N, 0 ≤ X_i < M) representing the coordinates (Y is row number and X is column number) of the food supply and F_i (0 ≤ F_i ≤ 10^6) representing the number of days from the starting day on which the food supply is available.

Output

One integer number representing the minimal days to reach the port or -1 if that is impossible.

Examples

Input


3 3
5 2 15
M S S
S S S
S S P
S W N N N N N N N N N N N N N
2 1 0
1 2 0


Output


-1

Input


3 3
5 2 15
M S S
S S S
S S P
S E N N N N N N N N N N N N N
2 1 0
1 2 0


Output


2

Input


5 5
4 1 15
M S S S S
S S S S L
S S S L L
S S S S S
S S S S P
C C C C S S E E C C C C C C C
0 1 4


Output


8
#include <bits/stdc++.h>
using namespace std;
inline int read() {
  int x = 0, f = 1;
  char ch = getchar();
  while (!isdigit(ch)) {
    if (ch == '-') f = -1;
    ch = getchar();
  }
  while (isdigit(ch)) {
    x = (x << 1) + (x << 3) + ch - '0';
    ch = getchar();
  }
  return x * f;
}
const int N = 2e2 + 10, M = 2e6 + 10, dx[] = {-1, 1, 0, 0, 0},
          dy[] = {0, 0, -1, 1, 0};
int n, m, k, t, w, W[M], f[M], sx, sy;
char mat[N][N];
bool vis[25][N][N][N];
vector<int> vec[N][N];
struct Node {
  int x, y, last, k;
};
map<char, int> mp = {{'N', 0}, {'S', 1}, {'W', 2}, {'E', 3}, {'C', 4}};
inline bool check(int x, int y) {
  if (x < 0 || y < 0 || x >= n || y >= m) return false;
  if (mat[x][y] == 'L') return false;
  return true;
}
inline void ha(Node x) { printf("ha:%d %d %d %d\n", x.x, x.y, x.last, x.k); }
inline int bfs() {
  queue<Node> q;
  q.push((Node){sx, sy, 0, k});
  while (!q.empty()) {
    Node u = q.front();
    q.pop();
    int x = u.x, y = u.y, last = u.last, cur = u.k, t = f[last] + k - cur;
    if (mat[x][y] == 'P') return t;
    if (mat[x][y] == 'L') continue;
    if (vis[last][x][y][cur]) continue;
    vis[last][x][y][cur] = true;
    for (int i = 0; i < vec[x][y].size(); ++i)
      if (t == f[vec[x][y][i]]) {
        cur = k;
        last = vec[x][y][i];
      }
    if (cur == 0) continue;
    u = (Node){u.x + dx[W[t]], u.y + dy[W[t]], last, cur - 1};
    if (check(u.x, u.y)) q.push(u);
    for (int i = 0; i < 4; ++i) {
      int tx = x + dx[i] + dx[W[t]], ty = y + dy[i] + dy[W[t]];
      if ((check(x + dx[i], y + dy[i]) && check(tx, ty)) ||
          (check(x + dx[W[t]], y + dy[W[t]]) && check(tx, ty))) {
        u = (Node){tx, ty, last, cur - 1};
        if (!vis[last][tx][ty][cur - 1]) q.push(u);
      }
    }
  }
  return -1;
}
int main() {
  n = read();
  m = read();
  k = read();
  t = read();
  w = read();
  for (int i = 0; i < n; ++i)
    for (int j = 0; j < m; ++j) {
      cin >> mat[i][j];
      if (mat[i][j] == 'M') {
        sx = i;
        sy = j;
      }
    }
  for (int i = 0; i < w; ++i) {
    char ch;
    cin >> ch;
    W[i] = mp[ch];
  }
  for (int i = 1; i <= t; ++i) {
    int x = read(), y = read();
    vec[x][y].push_back(i);
    f[i] = read();
  }
  printf("%d\n", bfs());
  return 0;
}
