using System;
using System.Collections.Generic;

namespace Dag{
	class Program{
		struct Vertex{
			public List<int> outGoing;
			public List<int> inGoing;
		}
		struct Graph{
			public Vertex[] v;
			public Graph(int length){
				v = new Vertex[length];
				for(int i=0; i< length; i++){
					v[i].outGoing = new List<int>();
					v[i].inGoing = new List<int>();
				}
			}
			public int length{
				get {return v.Length;}
			}
			public override string ToString(){
				String str="";
				for(int i=0; i<length; i++){
					str+= $"{i+1}:";
					foreach(int n in v[i].outGoing){
						str+= $" {n+1}";
					}
					str+="\n";
				}
				return str;
			}
			public void addEdge(int start, int end){
				v[start].outGoing.Add(end);
				v[end].inGoing.Add(start);
			}
			public bool removeEdge(int start, int end){
				bool shouldPrint =false;
				v[start].outGoing.Remove(end);
				v[end].inGoing.Remove(start);
				return shouldPrint;
			}
		}
		static void  DFSFinishingTimeOrderHelper(Graph g,bool[] visited, List<int> vertices, int k){
			visited[k] =true;
			foreach(int l in g.v[k].outGoing){
				if(!visited[l]){
					DFSFinishingTimeOrderHelper(g,visited,vertices,l);
				}
			}
			vertices.Add(k);
		}
		static int[] DFSFinishingTimeOrder(Graph g,bool[] visited){
			List<int> vertices= new List<int>();
			DFSFinishingTimeOrderHelper(g,visited,vertices,0);
			return(vertices.ToArray());
		}
		static void  DFS_VisitTransposeHelper(Graph g,bool[] discovered, List<int> vertices, int k,bool[] visited){
			discovered[k] =true;
			foreach(int l in g.v[k].inGoing){
				if(!discovered[l]&&visited[l]){
					DFS_VisitTransposeHelper(g,discovered,vertices,l,visited);
				}
			}
			vertices.Add(k);
		}
		static List<int> DFS_VisitTranspose(Graph g,int u,bool[] discovered,bool[] visited){
			//bool[] discovered = new bool[g.length];
			List<int> vertices= new List<int>();
			DFS_VisitTransposeHelper(g,discovered,vertices,u,visited);
			return(vertices);
		}
		static List<List<int>> SCC(Graph g){
			//Call DFS and compute finish time f[u] for each u
			bool[] visited = new bool[g.length];
			int[] vertices = DFSFinishingTimeOrder(g,visited);
			bool[] discovered = new bool[g.length];
			List<List<int>> components = new List<List<int>>();
			//while some vertex in GT
			//is not-discovered do
			for(int i=vertices.Length-1; i>=0 ; i--){
				//Console.WriteLine(i);
				//u ← not-discovered vertex with the latest f[u]
				int u = vertices[i];
				if(discovered[u])continue;
				//Call DFS-VISIT(u) on GT
				components.Add(DFS_VisitTranspose(g,u,discovered,visited));

			}
			return components;
		}
		static void OptimalDFS(Graph g, bool[] visited, int[] optimal,
				int[] coins, bool[] noDeadEnd, int k,int end){
			visited[k] = true;

			//the finish can't be a dead end
			if(k== end){
				noDeadEnd[k]=true;
				optimal[k] = coins[k];
			}

			for(int i=0; i<g.v[k].outGoing.Count; i++){
				int l = g.v[k].outGoing[i];
				if(!visited[l]){
					OptimalDFS(g,visited,optimal,coins,noDeadEnd,l,end);
				}
				noDeadEnd[k]|= noDeadEnd[l];
				if(noDeadEnd[l])
					optimal[k] = Math.Max(optimal[k],optimal[l]+coins[k]);
			}
		}
		static int Optimal(Graph g,int[] coins,int [] optimal,bool[] noDeadEnd,int end){
			bool[] visited = new bool[g.length];
			//int [] optimal = new int[g.length];
			OptimalDFS(g, visited, optimal, coins, noDeadEnd, 0,end);
			return(optimal[0]);
		}
		static void PrintPath(Graph g, int[] coinsPerComponent,int[] coins, int[] optimal,
				bool[] noDeadEnd,List<List<int>> components){
			if(!noDeadEnd[0])return;
			int new_k;
			for(int k = 0; k>=0;k=new_k){
				//Console.WriteLine(k);
				foreach(int c in components[k])
					if(coins[c]>0)
						Console.Write($"{c+1} ");
				new_k =-1;
				for(int i=0; i<g.v[k].outGoing.Count; i++){
					int l = g.v[k].outGoing[i];
					//Console.WriteLine($"opt l {optimal[l]}, coi k {coins[k]} opt k {optimal[k]}");
					
					if(optimal[l]+coinsPerComponent[k]==optimal[k]&&noDeadEnd[l]){
						new_k = l;
						break;
					}
				}
			}
		}
		static void Main(){
			string[] threeNumbers = Console.ReadLine().Split(' ');
			int n = Int32.Parse(threeNumbers[0]);
			int m = Int32.Parse(threeNumbers[1]);
			int s = Int32.Parse(threeNumbers[2]);

			Graph g = new Graph(n);
			for(int j =0; j<m ;j++){
				string[] twoNumbers = Console.ReadLine().Split(' ');
				int a = Int32.Parse(twoNumbers[0]);
				int b = Int32.Parse(twoNumbers[1]);
		
				g.v[a-1].outGoing.Add(b-1);
				g.v[b-1].inGoing.Add(a-1);
			}
			int[] coins = new int[n];
			string[] coinsStr = Console.ReadLine().Split(' ');
			for(int k = 0; k<s; k++){
				int index = Int32.Parse(coinsStr[k])-1;
				coins[index]=1;
			}
			List<List<int>> components = SCC(g);
			//for(int i=0;i<components.Count; i++){
			//	//Console.Write($"Component {i+1}: ");
			//	for(int j=0; j<components[i].Count; j++){
			//		Console.Write($" {components[i][j]+1}");
			//	}
			//	Console.WriteLine();
			//}
			int[] componentPerVertex = new int[g.length];
			for(int i=0;i<componentPerVertex.Length;i++)componentPerVertex[i]=-1;
			int[] coinsPerComponent = new int[components.Count];
			for(int i=0;i<components.Count;i++){
				foreach(int k in components[i]){
					componentPerVertex[k]=i;
					coinsPerComponent[i]+=coins[k];
				}
			}
			//Console.WriteLine("value per component");
			//for(int i=0;i<components.Count; i++){
			//	Console.WriteLine($"Component {i+1}: {coinsPerComponent[i]}");
			//}
			Graph componentGraph = new Graph(components.Count);
			for(int k=0;k<g.length;k++){
				foreach(int l in g.v[k].outGoing){
					if(componentPerVertex[k]>=0&&componentPerVertex[l]>=0&&componentPerVertex[l] != componentPerVertex[k]){
						componentGraph.addEdge(componentPerVertex[k],componentPerVertex[l]);
					}
				}
			}
			//Console.WriteLine(componentGraph);
			int [] optimal = new int[componentGraph.length];
			bool [] noDeadEnd = new bool[componentGraph.length];
			Console.WriteLine(Optimal(componentGraph, coinsPerComponent,optimal,noDeadEnd,componentPerVertex[n-1]));
			PrintPath(componentGraph,coinsPerComponent,coins,optimal,noDeadEnd,components);
			
		}
	}
}