import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Queue;
import java.util.Scanner;
import java.util.Stack;

import org.omg.CORBA.INITIALIZE;

class GraphNode<E> {
	private int index;// index (reden broj) na temeto vo grafot
	private E info;
	private LinkedList<GraphNode<E>> neighbors;

	public GraphNode(int index, E info) {
		this.index = index;
		this.info = info;
		neighbors = new LinkedList<GraphNode<E>>();
	}

	boolean containsNeighbor(GraphNode<E> o) {
		return neighbors.contains(o);
	}

	void addNeighbor(GraphNode<E> o) {
		neighbors.add(o);
	}

	void removeNeighbor(GraphNode<E> o) {
		if (neighbors.contains(o))
			neighbors.remove(o);
	}

	@Override
	public String toString() {
		String ret = "INFO:" + index + " SOSEDI:";
		for (int i = 0; i < neighbors.size(); i++)
			ret += neighbors.get(i).index + " ";
		return ret;

	}

	@Override
	public boolean equals(Object obj) {
		@SuppressWarnings("unchecked")
		GraphNode<E> pom = (GraphNode<E>) obj;
		return (pom.info.equals(this.info));
	}

	public int getIndex() {
		return index;
	}

	public void setIndex(int index) {
		this.index = index;
	}

	public E getInfo() {
		return info;
	}

	public void setInfo(E info) {
		this.info = info;
	}

	public LinkedList<GraphNode<E>> getNeighbors() {
		return neighbors;
	}

	public void setNeighbors(LinkedList<GraphNode<E>> neighbors) {
		this.neighbors = neighbors;
	}

}

class Graph<E> {

	int num_nodes;
	GraphNode<E> adjList[];

	@SuppressWarnings("unchecked")
	public Graph(int num_nodes) {
		this.num_nodes = num_nodes;
		adjList = (GraphNode<E>[]) new GraphNode[num_nodes];
	}

	int adjacent(int x, int y) {
		// proveruva dali ima vrska od jazelot so
		// indeks x do jazelot so indeks y
		return (adjList[x].containsNeighbor(adjList[y])) ? 1 : 0;
	}

	void addEdge(int x, int y) {
		// dodava vrska od jazelot so indeks x do jazelot so indeks y
		if (!adjList[x].containsNeighbor(adjList[y])) {
			adjList[x].addNeighbor(adjList[y]);
		}
	}

	void deleteEdge(int x, int y) {
		adjList[x].removeNeighbor(adjList[y]);
	}

	@Override
	public String toString() {
		String ret = new String();
		for (int i = 0; i < this.num_nodes; i++) {
			ret += i + ": " + adjList[i] + "\n";
		}
		return ret;
	}

	/*
	 * ***********************TOPOLOGICAL SORT
	 *******************************************************************/

	void dfsVisit(Stack<Integer> s, int i, boolean[] visited) {
		if (!visited[i]) {
			visited[i] = true;
			Iterator<GraphNode<E>> it = adjList[i].getNeighbors().iterator();
			System.out.println("dfsVisit: " + i + " Stack=" + s);
			while (it.hasNext()) {
				dfsVisit(s, it.next().getIndex(), visited);
			}
			s.push(i);
			System.out.println("--dfsVisit: " + i + " Stack=" + s);
		}
	}

	void topological_sort_dfs() {
		boolean visited[] = new boolean[num_nodes];
		for (int i = 0; i < num_nodes; i++) {
			visited[i] = false;
		}

		Stack<Integer> s = new Stack<Integer>();

		for (int i = 0; i < num_nodes; i++) {
			dfsVisit(s, i, visited);
		}
		System.out.println("----Stack=" + s);
		while (!s.isEmpty()) {
			System.out.println(adjList[s.pop()]);
		}
	}

	public ArrayList<GraphNode<E>> bfs(int node) {
		ArrayList<GraphNode<E>> gn = new ArrayList<>();
		boolean visited[] = new boolean[num_nodes];
		for (int i = 0; i < num_nodes; i++)
			visited[i] = false;
		visited[node] = true;
		// System.out.println(node+": " + adjList[node].getInfo());
		Queue<Integer> q = new LinkedList<Integer>();
		q.add(node);

		GraphNode<E> pom;

		while (!q.isEmpty()) {
			pom = adjList[q.poll()];
			GraphNode<E> tmp = null;
			if (pom.getInfo().equals("ne"))
				gn.add(pom);
			for (int i = 0; i < pom.getNeighbors().size(); i++) {
				tmp = pom.getNeighbors().get(i);
				/*
				 * else continue;
				 */
				if (!visited[tmp.getIndex()]) {
					visited[tmp.getIndex()] = true;
					// System.out.println(tmp.getIndex()+": " + tmp.getInfo());
					q.add(tmp.getIndex());
				}
			}

		}
		return gn;

	}

}

public class Mraz {
	public static void main(String[] args) {
		Scanner in = new Scanner(System.in);
		int n = Integer.parseInt(in.nextLine());

		Graph g = new Graph(n);

		for (int i = 0; i < n; i++) {

			String[] line = in.nextLine().split(" ");
			g.adjList[i] = new GraphNode<>(i, line[1]);
		}
		n = Integer.parseInt(in.nextLine());
		for (int i = 0; i < n; i++) {
			String[] line = in.nextLine().split(" ");
			g.addEdge(Integer.parseInt(line[0]), Integer.parseInt(line[1]));
			g.addEdge(Integer.parseInt(line[1]), Integer.parseInt(line[0]));

			 System.out.println(line[0] + " " + line[1] + " "
			 +g.adjacent(Integer.parseInt(line[0]),
			 Integer.parseInt(line[1])));

		}
		System.out.println(g.toString());
		int start = Integer.parseInt(in.nextLine());

		// System.out.println(g.toString());
		ArrayList<GraphNode> al = g.bfs(start);
		boolean visited[] = new boolean[n];

		for (int i = 0; i < al.size(); i++) {
			// System.out.println(al.get(i).getIndex());
		}
		Arrays.fill(visited, false);
		int count = 0;
		for (int i = 0; i < al.size(); i++) {
			// System.out.println(al.get(i).getNeighbors().size());
			for (int j = 0; j < al.get(i).getNeighbors().size(); j++) {
				GraphNode pom = (GraphNode) al.get(i).getNeighbors().get(j);
				System.out.println(al.get(i).getNeighbors());
				// System.out.println(pom.getIndex()+" neighbors I");
				if (pom.getInfo().equals("da") && !visited[pom.getIndex()]) {
					visited[pom.getIndex()] = true;
					// System.out.println(pom.getIndex());
					count++;
				}
				for (int h = 0; h < pom.getNeighbors().size(); h++) {
					GraphNode pom2 = (GraphNode) pom.getNeighbors().get(h);
					// System.out.println(pom2.getIndex() + " neighbors II ");
					// pom.getIndex() + " pom");
					if (pom2.getInfo().equals("da") && !visited[pom2.getIndex()]) {
						count++;
						visited[pom2.getIndex()] = true;
						// System.out.println(pom2.getIndex());
					}

				}
				// visited[pom.getIndex()] = true;
			}
		}

		for (int i = 0; i < g.adjList[3].getNeighbors().size(); i++) {
			GraphNode pom2 = (GraphNode) g.adjList[3].getNeighbors().get(i);
			// System.out.println(pom2.getIndex());// + g.adjacent(3, 5));

		}
		System.out.println(count);
	}
}