using System;
using System.Collections.Generic;

namespace Dag{
	class Program{

		static bool able1to33 = true;
		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);
				if(start+1==33){
					bool[] visited = new bool[v.Length];
					if(!fromToPossible(this,33-1,11-1,visited,false)){
						shouldPrint=true;
						//Console.WriteLine($"After removing the edge from {start+1} to {end+1} it is not possible to get from 33 to 11");
					}
				}
				v[end].inGoing.Remove(start);
				return shouldPrint;
			}
		}
		static void DAGifyDFS(Graph g, bool[] visited, bool[] finished, int k){
			visited[k] = true;
			for(int i=0; i<g.v[k].outGoing.Count; i++){
				int l = g.v[k].outGoing[i];
				if(!visited[l]){
					DAGifyDFS(g,visited,finished,l);
				}else if(!finished[l]){
					//move all neighbours of l
					//that have not been visited
					bool shouldPrint = g.removeEdge(k,l);
					List<int> toMoveOut = new List<int>();
					foreach(int m in g.v[l].outGoing){
						if(!visited[m]||finished[m]){
							toMoveOut.Add(m);
						}
					}
					i--;
					foreach(int m in toMoveOut){
						g.removeEdge(l,m);
						g.addEdge(k,m);
					}
					List<int> toMoveIn = new List<int>();
					foreach(int m in g.v[l].inGoing){
						if(!visited[m]||finished[m]){
							toMoveIn.Add(m);
						}
					}
					foreach(int m in toMoveIn){
						g.removeEdge(m,l);
						g.addEdge(m,k);
					}
					bool[] visited2 = new bool[g.v.Length];
					if(able1to33){
						able1to33 = fromToPossible(g,1-1,33-1,visited2,false);
						if(!able1to33){
							Console.WriteLine($"The path from 1 to 33 became inpossible when k={k+1} and l={l+1}");
						}
						//Console.WriteLine($"After removing the edge from {start+1} to {end+1} it is not possible to get from 33 to 11");
					}
				}else{
				}
			}
			finished[k] = true;
		}
		static void OptimalDFS(Graph g, bool[] visited, int[] optimal,
				int[] coins, bool[] noDeadEnd, int k){
			visited[k] = true;

			//the finish can't be a dead end
			if(k+1== g.length){
				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);
				}
				noDeadEnd[k]|= noDeadEnd[l];
				if(noDeadEnd[l])
					optimal[k] = Math.Max(optimal[k],optimal[l]+coins[k]);
			}
		}
		static void DAGify(Graph g){
			bool[] visited = new bool[g.length];
			bool[] finished = new bool[g.length];
			DAGifyDFS(g, visited, finished, 0);
		}
		static int Optimal(Graph g,int[] coins,int [] optimal,bool[] noDeadEnd){
			bool[] visited = new bool[g.length];
			//int [] optimal = new int[g.length];
			OptimalDFS(g, visited, optimal, coins, noDeadEnd, 0);
			return(optimal[0]);
		}
		static void PrintPath(Graph g, int[] coins, int[] optimal,
				bool[] noDeadEnd){
			if(!noDeadEnd[0])return;
			int new_k;
			for(int k = 0; k>=0;k=new_k){
				//Console.WriteLine(k);
				if(coins[k]==1)
				Console.Write($"{k+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]+coins[k]==optimal[k]&&noDeadEnd[l]){
						new_k = l;
						break;
					}
				}
			}
		}
		static bool fromToPossible(Graph g, int start, int end,bool[] visited,bool print){
			visited[start] = true;
			if(start == end){
				if(print)Console.WriteLine(start+1);
				return true;
			}
			foreach(int l in g.v[start].outGoing){
				if(!visited[l] && fromToPossible(g,l,end,visited,print)){
					if(print)Console.WriteLine(start+1);
					return true;
				}
			}
			return false;
		}
		static bool pathPossible(Graph g, int[] path, int start){
			foreach(int end in path){
				bool[] visited = new bool[g.length];
				bool print;
				if(start == 33 && end ==11){
					print = true;
				}else{
					print =false;
				}
				if(!fromToPossible(g,start-1, end-1,visited,print)){
					//Console.WriteLine($"No path between {start} and {end}");
					return false;
				}
				start = end;
			}
			return true;
		}
		static void pathPermutationPossible(Graph g, int[] path, int start){
			List<int> l = new List<int>();
			int c =0;
			foreach(int p in path){
				Console.WriteLine(c);
				c++;
				bool possible=false;
				for(int i=0; i<=l.Count;i++){
					l.Insert(i,p);
					if(pathPossible(g,l.ToArray(),1)){
						possible=true;
						break;
					}else{
						l.RemoveAt(i);
					}
				}
				if(!possible){
					Console.WriteLine($"Could not add {p} anywhere");
					foreach(int i in l){
						Console.Write($"{i} ");
					}
					return;
				}
			}
			Console.WriteLine("It is definitely possible here is the path:");
			foreach(int p in l){
				Console.Write($"{p} ");
			}
		}
		static void MainOld(){
			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;
			}
			bool[] vis = new bool[n];
			int[] pathy= {63,78,27,11,4,33};
			if(pathPossible(g,pathy, 1)){
				Console.WriteLine("The path is possible");
			}else                               
				Console.WriteLine("The path  is not possible");
			DAGify(g);
			bool[] vis2 = new bool[n];
			if(pathPossible(g,pathy, 1)){
				Console.WriteLine("The path  is possible aftre Dagify");
			}else
				Console.WriteLine("The path  is not possible after Dagify");
			//Console.WriteLine(g);
			int [] optimal = new int[g.length];
			bool[] noDeadEnd = new bool[g.length];
			int o = Optimal(g,coins,optimal,noDeadEnd);
			//if(o==193){
			//	Console.WriteLine("327");
			//	Console.WriteLine("33 11 78 27 4 63 35 9 88 15 38 97 56 22 23 59 61 47 91 42 84 3 45 34 49 73 98 86 31 77 18 74 48 55 1 192 157 225 214 160 209 158 166 217 178 204 201 161 154 211 223 203 188 184 189 180 181 175 199 206 205 229 186 185 176 173 218 208 155 162 224 220 174 227 200 183 197 228 171 168 167 179 215 163 191 213 164 222 212 238 241 242 234 344 354 336 337 338 346 334 341 351 329 340 335 347 339 326 332 353 342 343 348 350 330 349 333 352 440 441 383 377 404 364 397 423 396 408 392 370 406 413 452 431 432 367 434 379 424 433 447 429 356 374 410 448 409 365 381 419 426 389 357 395 402 366 443 445 416 394 362 359 425 390 417 371 437 414 372 427 386 439 468 457 470 466 454 471 467 463 465 464 462 458 461 460 469 472 459 455 456 453 589 583 569 587 566 577 563 582 594 572 578 730 732 750 734 746 742 698 690 738 692 688 719 706 708 726 702 733 731 736 747 735 697 711 740 714 701 704 728 720 703 689 700 729 694 684 744 723 691 686 748 699 683 707 721 682 715 718 696 810 791 825 759 812 789 816 764 758 822 751 766 787 799 776 771 760 785 819 827 821 774 806 757 755 808 788 795 807 794 798 775 768 779 752 769 809 767 803 761 780 762 811 778 781 753 793 765 805 792 796 804 813 826 824 800 756 820 783 797 773 801 823 948 993 977 971 988 995 976 992 970 968 998 966 987");
			//}
			//else{
				Console.WriteLine(Optimal(g,coins,optimal,noDeadEnd));
				PrintPath(g,coins,optimal,noDeadEnd);
			//}
			//Console.Write("\noptimal:");
			//foreach(int opt in optimal){
			//	Console.Write($"{opt} ");
			//}
			//Console.WriteLine();
			//Console.WriteLine(optimal);

		}
		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;
			}
			int[] path = {33,11,78,27,4,63,35,9,88,15,38,97,56,22,23,59,61,47,91,42,84,3,45,34,49,73,98,86,31,77,18,74,48,55,1,192,157,225,214,160,209,158,166,217,178,204,201,161,154,211,223,203,188,184,189,180,181,175,199,206,205,229,186,185,176,173,218,208,155,162,224,220,174,227,200,183,197,228,171,168,167,179,215,163,191,213,164,222,212,238,241,242,234,344,354,336,337,338,346,334,341,351,329,340,335,347,339,326,332,353,342,343,348,350,330,349,333,352,440,441,383,377,404,364,397,423,396,408,392,370,406,413,452,431,432,367,434,379,424,433,447,429,356,374,410,448,409,365,381,419,426,389,357,395,402,366,443,445,416,394,362,359,425,390,417,371,437,414,372,427,386,439,468,457,470,466,454,471,467,463,465,464,462,458,461,460,469,472,459,455,456,453,589,583,569,587,566,577,563,582,594,572,578,730,732,750,734,746,742,698,690,738,692,688,719,706,708,726,702,733,731,736,747,735,697,711,740,714,701,704,728,720,703,689,700,729,694,684,744,723,691,686,748,699,683,707,721,682,715,718,696,810,791,825,759,812,789,816,764,758,822,751,766,787,799,776,771,760,785,819,827,821,774,806,757,755,808,788,795,807,794,798,775,768,779,752,769,809,767,803,761,780,762,811,778,781,753,793,765,805,792,796,804,813,826,824,800,756,820,783,797,773,801,823,948,993,977,971,988,995,976,992,970,968,998,966,987};
			DAGify(g);
			pathPermutationPossible(g,path,1);
			bool[] vis1 = new bool[g.length];
			Console.WriteLine(fromToPossible(g,38-1,63-1,vis1,false));
			

		}
	}
}