import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.*;

class Node{
    public int number;
    public Map<Node, Integer> neighbors = new HashMap<>();

    public Node(int number){
        this.number = number;
    }

    public void add(Node n, int type){
        if(neighbors.containsKey(n)){
            return;
        }
        neighbors.put(n, type);
        n.add(this, type);
    }
}

class Edge{
    public int from;
    public int to;
    public int weight;

    public Edge(int from, int to, int weight) {
        this.from = from;
        this.to = to;
        this.weight = weight;
    }
}

public class Offices {
    public static void BellmanFord(List<Edge> edges, List<Integer> dist, int src, int V)
    {
        int E = edges.size();

        // Step 1: Initialize distances from src to all other
        // vertices as INFINITE
        for (int i = 0; i < V; ++i)
            dist.set(i, Integer.MAX_VALUE);
        dist.set(src, 0);

        // Step 2: Relax all edges |V| - 1 times. A simple
        // shortest path from src to any other vertex can
        // have at-most |V| - 1 edges
        for (int i = 1; i < V; ++i) {
            for (int j = 0; j < E; ++j) {
                int u = edges.get(j).from;
                int v = edges.get(j).to;
                int weight = edges.get(j).weight;
                if (dist.get(u) != Integer.MAX_VALUE && dist.get(u) + weight < dist.get(v))
                    dist.set(v, dist.get(u) + weight);
            }
        }

        int sum = 0;
        for(int i=0; i<V; i++){
            if(dist.get(i) != Integer.MAX_VALUE){
                sum += dist.get(i);
            }
        }
        System.out.println(sum);

    }

    public static void main(String[] args) throws IOException {
        BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
        String line = reader.readLine();
        StringTokenizer tokenizer = new StringTokenizer(line, " ");

        int n = Integer.parseInt(tokenizer.nextToken());
        int m = Integer.parseInt(tokenizer.nextToken());
        int r = Integer.parseInt(tokenizer.nextToken());
        int o = Integer.parseInt(tokenizer.nextToken());
        int q = Integer.parseInt(tokenizer.nextToken());

        int[] cables = new int[2];
        cables[0] = o;
        cables[1] = q;
        List<Node> nodes = new ArrayList<>();
        List<Edge> edges = new ArrayList<>();
        List<Integer> dist = new ArrayList<>();

        for(int i=0; i<n; i++){
            nodes.add(new Node(i));
            dist.add(Integer.MAX_VALUE);
        }

        for(int i=0; i<m; i++){
            line = reader.readLine();
            tokenizer = new StringTokenizer(line, " ");
            int from = Integer.parseInt(tokenizer.nextToken());
            int to = Integer.parseInt(tokenizer.nextToken());
            String type = tokenizer.nextToken();

            if(type.equals("O")){
                nodes.get(from).add(nodes.get(to), 0);
                edges.add(new Edge(from, to, cables[0]));
                edges.add(new Edge(to, from, cables[0]));
            }
            else {
                nodes.get(from).add(nodes.get(to), 1);
                edges.add(new Edge(from, to, cables[1]));
                edges.add(new Edge(to, from, cables[1]));
            }

        }

        for(int i=0; i<r; i++){
            line = reader.readLine();
            tokenizer = new StringTokenizer(line, " ");

            int technical = Integer.parseInt(tokenizer.nextToken());
            int social = Integer.parseInt(tokenizer.nextToken());

            Set<Node> possible = new HashSet<>();
            Node technicalOffice = nodes.get(technical);
            Node socialOffice = nodes.get(social);

            possible.addAll(technicalOffice.neighbors.keySet());
            possible.addAll(socialOffice.neighbors.keySet());

            Node newNode = new Node(nodes.size());
            for(Node node : possible){
                if(node.neighbors.containsKey(technicalOffice)){
                    int type1 = node.neighbors.get(technicalOffice);
                    if(node.neighbors.containsKey(socialOffice)){
                        int type2 = 1 - node.neighbors.get(socialOffice);

                        if (type1 == type2) {
                            newNode.add(node, 1 - type1);
                            edges.add(new Edge(newNode.number, node.number, cables[1 - type1]));
                            edges.add(new Edge(node.number, newNode.number, cables[1 - type1]));
                        }
                        continue;
                    }
                    newNode.add(node, type1);
                    edges.add(new Edge(newNode.number, node.number, cables[type1]));
                    edges.add(new Edge(node.number, newNode.number, cables[type1]));
                }
                else{
                    int type = node.neighbors.get(socialOffice);
                    newNode.add(node, 1 - type);
                    edges.add(new Edge(newNode.number, node.number, cables[1 - type]));
                    edges.add(new Edge(node.number, newNode.number, cables[1 - type]));
                }
            }
            nodes.add(newNode);
            dist.add(Integer.MAX_VALUE);
            BellmanFord(edges,dist, 0, nodes.size());
        }

    }
}