// Slower C++ solution:
#include <iostream>

#include <algorithm>

using namespace std;

 

#define INF 1e8

#define MAX_V 256

#define MAX_R 1024

int dl[MAX_V][MAX_V];	//	d[u][v]表示?e=(u,v)的??，不存在的?候等于无?大或者d[i][i] = 0

int ds[MAX_V][MAX_V];

int z[MAX_R];

int dp[MAX_R][MAX_V];	// dp[i][j] := 已?去了第i个?子后，船停在第j个?子里

int N;					//	?点数

 

///////////////////////////SubMain//////////////////////////////////

int main(int argc, char *argv[])

{

 

	int M;

	while (cin >> N >> M , N || M)

	{

// 		memset(dl, 0x3f, sizeof(dl));

// 		memset(ds, 0x3f, sizeof(ds));

		for (int i = 0; i < N; ++i)

		{

			for (int j = 0; j < N; ++j)

			{

				if (i == j)

				{

					dl[i][j] = ds[i][j] = 0;

				}

				else

				{

					dl[i][j] = ds[i][j] = INF;

				}

			}

		}

 

		for (int i = 0; i < M; ++i)

		{

			int x, y, t;

			char s;

			cin >> x >> y >> t >> s;

			--x; --y;

			if (s == 'L')

			{

				dl[x][y] = min(dl[x][y], t);

				dl[y][x] = dl[x][y];

			}

			else

			{

				ds[x][y] = min(ds[x][y], t);

				ds[y][x] = ds[x][y];

			}

		}

		

		int R;

		cin >> R;

		for (int i = 0; i < R; ++i)

		{

			cin >> z[i];

			--z[i];

		}

 

		// warshall_floyd

		for (int k = 0; k < N; ++k)

		{

			for (int i = 0; i < N; ++i)

			{

				for (int j = 0; j < N; ++j)

				{

					dl[i][j] = min(dl[i][j], dl[i][k] + dl[k][j]);

					ds[i][j] = min(ds[i][j], ds[i][k] + ds[k][j]);

				}

			}

		}

		// end of warshall_floyd

 

		// dp

		// 尼?3个0x3f3f3f3f加起来溢出了

		//memset(dp, 0x3f, sizeof(dp));

		for (int i = 0; i < R; ++i)

		{

			for (int j = 0; j < N; ++j)

			{

				dp[i][j] = INF;

			}

		}

		for (int i = 0; i < N; ++i)

		{

			// 去了首个?子后，船放在第i个?子里

						// 坐船去	 // 坐11路?回来

			dp[0][i] = ds[z[0]][i] + dl[i][z[0]];

		}

		for (int i = 1; i < R; ++i)

		{

			for (int j = 0; j < N; ++j)

			{

				for (int k = 0; k < N; ++k)

				{

					if (j != k)

					{

						//                          i-1站     + 从i-1站走旱路去j+ 从j走水路去k+从k走旱路去i

						dp[i][k] = min(dp[i][k], dp[i - 1][j] + dl[z[i - 1]][j] + ds[j][k] + dl[k][z[i]]);

					}

					else

					{

						// j == k                   i-1站     + 从i-1站走旱路去i

						dp[i][j] = min(dp[i][j], dp[i - 1][j] + dl[z[i - 1]][z[i]]);

					}

				}

			}

		}

 

		cout << *min_element(dp[R - 1], dp[R - 1] + N) << endl;

	}

 

	return 0;

}

// Faster C++ solution for the same problem (measured speedup: 4.99322084144218x):
#include<cstdio>

#include<cstring>

#include<algorithm>

using namespace std;

#define MAXN 205

#define MAXR 1005

#define MAXM 10005

int N,M,R;

int S[MAXN][MAXN],L[MAXN][MAXN];

int task[MAXR];

int dp[MAXR][MAXN];

int main()

{

	while(1)

	{

		scanf("%d%d",&N,&M);

		if(!N&&!M)break;

		for(int i=1;i<=N;i++)

			for(int j=1;j<=N;j++)

				S[i][j]=L[i][j]=1000000;

		for(int i=1;i<=N;i++)

			S[i][i]=L[i][i]=0;

		for(int i=1;i<=M;i++)

		{

			int a,b,t;char s[3];

			scanf("%d%d%d%s",&a,&b,&t,s);

			if(s[0]=='S')

			{

				S[a][b]=min(S[a][b],t);

				S[b][a]=min(S[b][a],t);

			}

			else

			{

				L[a][b]=min(L[a][b],t);

				L[b][a]=min(L[b][a],t);

			}

		}

		for(int k=1;k<=N;k++)

			for(int i=1;i<=N;i++)

				for(int j=1;j<=N;j++)

				{

					S[i][j]=min(S[i][j],S[i][k]+S[k][j]);

					L[i][j]=min(L[i][j],L[i][k]+L[k][j]);

				}

		scanf("%d",&R);

		for(int i=1;i<=R;i++)

			scanf("%d",task+i);

		for(int i=1;i<=R;i++)

			for(int j=1;j<=N;j++)

				dp[i][j]=1000000;

		dp[1][task[1]]=0;

		for(int i=2;i<=R;i++)//the Captain position

			for(int j=1;j<=N;j++)//the Ship position

			{

				dp[i][j]=min(dp[i][j],dp[i-1][j]+L[task[i-1]][task[i]]);

				for(int k=1;k<=N;k++)

					dp[i][k]=min(dp[i][k],dp[i-1][j]+L[task[i-1]][j]+S[j][k]+L[k][task[i]]);

			}

		int ans=0x7FFFFFFF;

		for(int i=1;i<=N;i++)

			ans=min(ans,dp[R][i]);

		printf("%d\n",ans);

	}

	return 0;

}