// Original C++ solution (slower):
#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;

}

// Optimized solution to the same problem (faster):
#include<cstdio>

#include<cstring>

#include<algorithm>

#include<vector>

using namespace std;

int n,m,i,j,k,r,a[1005],ans,map[256][256][2],dp[10005][256];//map:0?路，1水路,dp[i][j]在送到i个?子船在j??的最少花?

int main()

{

	//freopen("1.in","r",stdin);

	//freopen("1.out","w",stdout);

	while(~scanf("%d %d",&n,&m)&&n&&m)

	{

		for(i=1;i<=n;i++)

		{

			for(j=1;j<=n;j++)

			{

				map[i][j][0]=1000000;

				map[i][j][1]=1000000;

			}

			map[i][i][0]=0;

			map[i][i][1]=0;

		}

		int x,y,t,o;

		char s;

		for(i=1;i<=m;i++)

		{

			scanf("\n%d %d %d %c",&x,&y,&t,&s);

			if(s=='L')

				o=0;

			if(s=='S')

				o=1;

			map[x][y][o]=min(map[x][y][o],t);

			map[y][x][o]=map[x][y][o];

		}

		for(k=1;k<=n;k++)

			for(i=1;i<=n;i++)

				for(j=1;j<=n;j++)

				{

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

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

				}

		scanf("%d",&r);

		for(i=1;i<=r;i++)

			scanf("%d",&a[i]);

		for(i=1;i<=r;i++)

			for(j=1;j<=n;j++)

				dp[i][j]=1000000;

		dp[1][a[1]]=0;

		for(i=1;i<=n;i++)

		{

			if(map[a[0]][i][1]<2147483647&&map[i][a[0]][0]<2147483647)

			dp[0][i]=map[a[0]][i][1]+map[i][a[0]][0];

		}

		for(i=2;i<=r;i++)

		{

			for(k=1;k<=n;k++)

			{

				dp[i][k]=min(dp[i][k],dp[i-1][k]+map[a[i-1]][a[i]][0]);

				for(j=1;j<=n;j++)

					dp[i][j]=min(dp[i][j],dp[i-1][k]+map[a[i-1]][k][0]+map[k][j][1]+map[j][a[i]][0]);

			}

		}

		ans=2147483647;

		for(i=1;i<=n;i++)

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

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

	}

}

// Fastest known solution for this problem: