/*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;



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));
		return (this.index == pom.index);
	}

	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;
		//boolean temp = false;
		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(tmp.getInfo().equals("da"))
					break;
				if (!visited[tmp.getIndex()]) {
					visited[tmp.getIndex()] = true;
					// System.out.println(tmp.getIndex()+": " + tmp.getInfo());
					//if(!temp)
						q.add(tmp.getIndex());
				}
			}

		}
		return gn;

	}
	ArrayList<Integer> dfsRecursive(int node, boolean visited[], int count, ArrayList<Integer> al) {
		visited[node] = true;
	//	System.out.println(node + ": " + adjList[node].getInfo());
		if(count==2)
			return al;
		for (int i = 0; i < adjList[node].getNeighbors().size(); i++) {
			GraphNode<E> pom = adjList[node].getNeighbors().get(i);
			if (!visited[pom.getIndex()])
				{
					count++;
					al.add(pom.getIndex());
					System.out.println(pom.getIndex()+ "DFS");
					dfsRecursive(pom.getIndex(), visited,count, al);
				}
		}
		return al;
	}

}

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);

	//	for (int i = 0; i < al.size(); i++) {
			// System.out.println(al.get(i).getIndex());
	//	}
		  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() + "BFS");
	        }
	        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;
	            }
	        }
		//void dfsNonrecursive(int node) {
			ArrayList<ArrayList<Integer>> all = new ArrayList<>();
			for(int i=0; i<al.size(); i++)
			{
				//visited[al.get(i).getIndex()] =false;
				g.dfsRecursive(al.get(i).getIndex(), visited, 0, all);
			//	System.out.println(al.get(i).getIndex() + "____");
			}

			//for(int j=0; j<all.get(i).size(); j++)
		for (int i = 0; i < all.size(); i++) {
			{
				System.out.println(all.get(i));
			}
		//}
		System.out.println(count);
	}
}
10
0 da
1 da
2 da
3 ne
4 ne
5 da
6 ne
7 ne
8 ne
9 ne
11
0 1
0 2
1 3
2 4
3 4
3 5
6 4
5 7
6 8
7 9
8 9
9
*/