/* Shortest Path Vairant
 * Don't be scared!!!
 * Greedy strategy is still applied.
 * Just do it!
 */
 
#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
 
int  g[305][305],it[305],bt[305],pt[305],d[305],p[305];
int  src,dst,n,m;
bool used[305];
char ic[305];
 
void Current(int nowT, int at, char &fromC, int &remC)
{
	if(nowT<it[at]) {
		fromC=ic[at];
		remC=it[at]-nowT;
	} else {
		nowT-=it[at];
		nowT%=(bt[at]+pt[at]);
		if(ic[at]=='P') {	//Careful!
			if(nowT<bt[at]) {
				fromC='B'; remC=bt[at]-nowT;
			} else {
				fromC='P'; remC=pt[at]-(nowT-bt[at]);
			}
		} else {
			if(nowT<pt[at]) {
				fromC='P'; remC=pt[at]-nowT;
			} else {
				fromC='B'; remC=bt[at]-(nowT-pt[at]);
			}
		}
	}
}
 
int calWait(int nowT, int from, int to)
{
	char fromC,toC;
	int  fromR,toR,nextFT,nextTT,nnextFT,nnextTT;
	//printf("!!%d %d %d = %d\n",nowT,from,to);
	Current(nowT,from,fromC,fromR);
	//printf("--CurrentF %d %d %c %d\n",nowT,from,fromC,fromR);
	Current(nowT,to,toC,toR);
	//printf("--CurrentT %d %d %c %d\n",nowT,to,toC,toR);
	//printf("--%d %d %d %d\n",fromC, toC, fromR, toR);
	if(fromC==toC) return 0;
	else {
		if(fromR<toR) return fromR;
		else if(fromR>toR) return toR;
		else {
			if(fromC=='B') nextFT=pt[from]; else nextFT=bt[from];
			if(fromC=='B') nnextFT=bt[from]; else nnextFT=pt[from];
			if(toC=='B') nextTT=pt[to]; else nextTT=bt[to];
			if(toC=='B') nnextTT=bt[to]; else nnextTT=pt[to];
			if(nextTT+nnextTT==nextFT+nnextFT) return -1;
			if(nextTT==nextFT) return fromR+nextFT+min(nnextFT,nnextTT);
			else return fromR+min(nextFT,nextTT);			
		}
	}
}
 
void print(int x)
{
	if(p[x]!=x) print(p[x]);
	printf("%d ",x);
}
int main()
{
	char str[100];
	int u,v,w;
	scanf("%d %d",&src,&dst);
	scanf("%d %d",&n,&m); gets(str);
	for(int i=1;i<=n;i++)
	{
		scanf("%s %d %d %d",str,&it[i],&bt[i],&pt[i]);
		ic[i]=str[0];		
	}
 
	for(int i=1;i<=m;i++)
	{
		scanf("%d %d %d",&u,&v,&w);
		g[u][v]=g[v][u]=w;
	}
 
	memset(used,0,sizeof(used));
	for(int i=1;i<=n;i++) d[i]=1<<29;
	d[src]=0; p[src]=src;
	for(int cc=1;cc<n;cc++)
	{
		int md=1<<29,mp=0;
		for(int i=1;i<=n;i++)
			if(!used[i]&&d[i]<md) { md=d[i]; mp=i; }
		if(!mp) break; else used[mp]=true;
		for(int i=1;i<=n;i++) if(!used[i]&&g[mp][i])
		{
			int wait=calWait(d[mp],mp,i);
			//printf("wait=%d\n",wait);
			if(wait<0) continue;
			if(d[i]>wait+d[mp]+g[mp][i]) {
				d[i]=wait+d[mp]+g[mp][i];
				p[i]=mp;
			}
		}
	}
	//for(int i=1;i<=n;i++) printf("%d ",d[i]); printf("\n");
	if(d[dst]<(1<<29)) printf("%d\n",d[dst]);
	print(dst);
	return 0;
}

/* Hamiltonian Path Finding.
 * If each vertex of a simple graph has degree >= n/2
 * There must be Hamiltonian Path/Cycle
 * Algorithm go like this:
 * Step 1: Init a path, add start point in
 * Step 2: Find any unused vertex which is reachable 
 *         BOTH from the head of the path and the tail of the path !!Attention: BOTH!!
 *         and insert it front head or after tail
 * Step 3: Continue Step2 until cannot find any more
 * Step 4: The formed path can become a cycle, i.e. path = a[1]a[2]...a[m],
           there must exist ai, s.t. edge(a[1],a[i+1]) && edge(a[i],a[m])
		   The path can be changed to a[1]...a[i]a[m]...a[i+1]a[1]
 * Step 5: If the cycle contains all the vertices, we've done.
           Otherwise, for any unused point P, there must be some edge(a[k],P)
		   Reform the cycle to be a path like Pa[k]...a[end]a[begin]..a[k-1]
 * Step 6: Go to Step 2
 *
 * Linked List are used for faster reverse and insert
 * To Reverse a linked list, simply swap each node's (Previous, Next)
 * Good Practice!
 */
bool  m[1005][1005]={0};	//Graph Map m
int   vis[1005],n;			
int L[1005],R[1005],X[1005],root,count;
void FindHamiltonCycle()	//check connectivity first
{
	memset(vis,0,sizeof(vis));
	root=count=0;
	X[++count]=1;
	L[count]=root; R[root]=count;
	L[root]=count; R[count]=root;
	vis[1]=true;
 
	bool updated;
	int  head,headPos,newHead;
	int  tail,tailPos,newTail;
	int  start,addin,temp;
	while(1)
	{		
		do {
			head=X[R[root]]; headPos=R[root]; updated=false;
			tail=X[L[root]]; tailPos=L[root]; updated=false;
			for(int i=1;i<=n;i++) if(!vis[i]&&m[head][i]&&m[tail][i])
			{
				newHead=i;				
				vis[newHead]=updated=true;
				X[++count]=newHead;
				R[count]=headPos; L[headPos]=count;				
				L[count]=root; R[root]=count; 
				break;
			}			
		} while(updated);
 
		head=X[R[root]]; tail=X[L[root]]; 
		headPos=R[root]; tailPos=L[root];
		for(int ptr=R[root];ptr!=root;ptr=R[ptr])
		{
			if(m[head][X[R[ptr]]] && m[tail][X[ptr]]) {				
				start=R[ptr];
				while(1) {
					temp=L[start];
					L[start]=R[start];
					R[start]=temp;
					if(L[start]==root) {
						L[start]=ptr;
						R[R[ptr]]=root;
						L[root]=R[ptr];
						R[ptr]=start;
						break;
					} else start=L[start];
				}				
				break;
			}
		}		
		if(count==n) break;
		else {
			for(int i=1;i<=n;i++) if(!vis[i]) { addin=i; break; };
			for(int ptr=R[root];ptr!=root;ptr=R[ptr])
			{
				if(m[X[ptr]][addin]) {		
					X[++count]=addin;					
					vis[addin]=true;
					tailPos=L[root]; headPos=R[root];	
					R[root]=count; 
					if(L[ptr]!=root) { 
						L[root]=L[ptr]; R[L[ptr]]=root;
						R[tailPos]=headPos; L[headPos]=tailPos;
					}
					L[count]=root; R[count]=ptr;
					L[ptr]=count;					
					break;
				}
			}			
		}
	}
	printAns(1);
}