#include <bits/stdc++.h>

#define FOR(i,a,b) for(int i= (a); i<((int)b); ++i)
#define RFOR(i,a) for(int i=(a); i >= 0; --i)
#define FOE(i,a) for(auto i : a)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define DUMP(x)  cerr << #x << " = " << (x) << endl;
#define SUM(x) std::accumulate(ALL(x), 0LL)
#define MIN(v) *std::min_element(v.begin(), v.end())
#define MAX(v) *std::max_element(v.begin(), v.end())
#define EXIST(v,x) (std::find(v.begin(), v.end(), x) != v.end())
#define BIT(n) (1LL<<(n))
#define UNIQUE(v) v.erase(unique(v.begin(), v.end()), v.end());

typedef long long LL;
template<typename T> using V = std::vector<T>;
template<typename T> using VV = std::vector<std::vector<T>>;
template<typename T> using VVV = std::vector<std::vector<std::vector<T>>>;

template<class T> inline T ceil(T a, T b) { return (a + b - 1) / b; }
template<class T> inline void print(T x) { std::cout << x << std::endl; }
template<class T> inline void print_vec(const std::vector<T> &v) { for (int i = 0; i < v.size(); ++i) {  if (i != 0) {std::cout << " ";} std::cout << v[i];} std::cout << "\n"; }
template<class T> inline bool inside(T y, T x, T H, T W) {return 0 <= y and y < H and 0 <= x and x < W; }
template<class T> inline double euclidean_distance(T y1, T x1, T y2, T x2) { return sqrt((x1 - x2) * (x1 - x2) + (y1 - y2) * (y1 - y2)); }
template<class T> inline double manhattan_distance(T y1, T x1, T y2, T x2) { return abs(x1 - x2) + abs(y1 - y2); }

const int INF = 1L << 30;
const double EPS = 1e-9;
const std::string YES = "YES", Yes = "Yes", NO = "NO", No = "No";
const std::vector<int> dy4 = { 0, 1, 0, -1 }, dx4 = { 1, 0, -1, 0 };    // 4近傍（右, 下, 左, 上）
const std::vector<int> dy8 = { 0, -1, 0, 1, 1, -1, -1, 1 }, dx8 = { 1, 0, -1, 0, 1, 1, -1, -1 };

using namespace std;


/**
 * 全ノード間の最短距離をもとめる
 * matrix[i][j]には辺e=(i,j)のコスト(辺が存在しない場合はINT_MAX)
 * 負の閉路がある場合は空を返す
 * O(|V|^3)
 */
std::vector<std::vector<LL>> warshall_floyd(std::vector<std::vector<LL>> matrix) {
    const unsigned long num_node = matrix.size();

    // 自分の距離は0
    for (int i = 0; i < num_node; ++i) {
        matrix.at(i).at(i) = 0;
    }

    for (int m = 0; m < num_node; ++m) {
        for (int s = 0; s < num_node; ++s) {
            for (int e = 0; e < num_node; ++e) {
                // sからeへmを経由して到達可能
                if (matrix.at(s).at(m) != INT_MAX and matrix.at(m).at(e) != INT_MAX) {
                    matrix.at(s).at(e) = std::min(matrix.at(s).at(e), matrix.at(s).at(m) + matrix.at(m).at(e));
                }
            }
        }
    }

    // 負閉路チェック
    for (int u = 0; u < num_node; ++u) {
        if (matrix.at(u).at(u) < 0) {
            return {};
        }
    }

    return matrix;
}


int main() {
    cin.tie(0);
	ios::sync_with_stdio(false);

    while (true) {
        int N, M;
        cin >> N >> M;
        if (N == 0 and M == 0) {
            break;
        }

        vector<vector<LL>> matrix1(N, vector<LL>(N, INT_MAX)), matrix2(N, vector<LL>(N, INT_MAX));
        FOR(i, 0, M) {
            LL X, Y, T;
            char S;
            cin >> X >> Y >> T >> S;
            X--; Y--;
            if (S == 'L') {
                matrix1[X][Y] = min(matrix1[X][Y], T);
                matrix1[Y][X] = min(matrix1[Y][X], T);
            }
            else if (S == 'S') {
                matrix2[X][Y] = min(matrix2[X][Y], T);
                matrix2[Y][X] = min(matrix2[Y][X], T);
            }
        }

        int R;
        cin >> R;
        vector<int> route(R);
        FOR(i, 0, R) {
            cin >> route[i];
            route[i]--;
        }

        matrix1 = warshall_floyd(matrix1);
        matrix2 = warshall_floyd(matrix2);

        vector<vector<LL>> dp(R, vector<LL>(N, INF));
        dp[0][route[0]] = 0;

        FOR(i, 0, R - 1) {
            int now = route[i];
            int next = route[i + 1];

            FOR(j, 0, N) {
                if (dp[i][j] == INF) {
                    continue;
                }

                FOR(k, 0, N) {
                    // 船がjにあるとき、町nowから町jに陸路、町jから町kに海路、町kから町nextに陸路でいく
                    LL dist = dp[i][j] + matrix1[now][j] + matrix2[j][k] + matrix1[k][next];
                    dp[i + 1][k] = min(dp[i + 1][k], dist);

                    if (j == k) {
                        LL d = dp[i][j] + matrix1[now][next];
                        dp[i + 1][j] = min(dp[i + 1][j], d);
                    }

                }
            }
        }

        LL ans = INF;
        FOR(i, 0, N) {
            ans = min(ans, dp[R - 1][i]);
        }
        print(ans);
    }

	return 0;
}


Measured memory_bytes: 5228