#include <iostream>
#include <cmath>
#include <cctype>
#include <vector>
#include <algorithm>
#include <set>
#include <map>
#include <deque>
#include <stack>
#include <unordered_set>
#include <sstream>
#include <cstring>
#include <iomanip>
#include <queue>
#include <unordered_map>
#include <random>
#include <cfloat>
#include <chrono>

void dfs(int32_t v, bool* visited, bool* tmp, std::vector<int32_t>* graph, std::vector<int32_t>& res) {
	if(visited[v])
		return;
	if(tmp[v]) {
		std::cout << 0 << "\n";
		exit(0);
	}

	tmp[v] = true;
	for(int32_t i = 0 ; i < graph[v].size(); i++)
		dfs(graph[v][i], visited, tmp, graph, res);

	tmp[v] = false;
	visited[v] = true;
	res.push_back(v);
}

int main() {
	std::ios::sync_with_stdio(false);
	std::cin.tie(0);
	std::cout.tie(0);
	
	int32_t num_tests;
	//std::cin >> num_tests;
	num_tests = 1;

	for(int32_t t = 0 ; t < num_tests; t++) {
		int32_t n, k;
		std::cin >> n >> k;

		int32_t* prereq = new int32_t[n];
		for(int32_t i = 0; i < n ; i++) {
			std::cin >> prereq[i];
			prereq[i]--;
		}

		int32_t* next = new int32_t[n];
		bool* beginning = new bool[n];
		for(int32_t i = 0 ; i < n ;i++) {
			next[i] = -1;
			beginning[i] = true;
		}
		for(int32_t i = 0 ; i < k; i++) {
			int32_t p1, p2;
			std::cin >> p1 >> p2;
			p1--;
			p2--;

			if(next[p1] != -1) {
				std::cout << 0 << "\n";
				return 0;
			}
			next[p1] = p2;
			beginning[p2] = false;
		}

		std::vector<std::vector<int32_t> > groups;
		int32_t* group_index = new int32_t[n];
		int32_t* index_in_group = new int32_t[n];
		for(int32_t i = 0 ; i < n; i++)
			group_index[i] = -1;
		for(int32_t i = 0; i < n ; i++) {
			if(group_index[i] != -1 || !beginning[i])
				continue;
			group_index[i] = groups.size();
			index_in_group[i] = 0;
			groups.push_back({});
			int32_t cur = i;
			while(cur != -1) {
				groups[groups.size() - 1].push_back(cur);
				index_in_group[cur] = groups[groups.size() - 1].size() - 1;
				int32_t next_cur = next[cur];
				if(next_cur == -1)
					break;
				if(group_index[next_cur] != -1) {
					std::cout << 0;
					return 0;
				}
				group_index[next_cur] = group_index[cur];
				cur = next[cur];
			}
		}
		for(int32_t i = 0 ; i < n ; i++)
			if(group_index[i] == -1) {
				std::cout << 0;
				return 0;
			}

		std::vector<int32_t>* graph_on_groups = new std::vector<int32_t>[groups.size()];
		for(int32_t i = 0 ; i < n ; i++) {
			if(prereq[i] == -1)
				continue;
			int32_t prev_group = group_index[prereq[i]], cur_group = group_index[i];

			if(prev_group != cur_group)
				graph_on_groups[prev_group].push_back(cur_group);
			else
				if(index_in_group[i] < index_in_group[prereq[i]]) {
					std::cout << 0;
					return 0;
				}
		}

		bool* visited = new bool[groups.size()], *tmp = new bool[groups.size()];
		for(int32_t i = 0 ; i < groups.size(); i++) {
			visited[i] = false;
			tmp[i] = false;
		}

		std::vector<int32_t> groups_sorted;
		for(int32_t i = 0 ; i < groups.size(); i++) {
			if(visited[i])
				continue;
			dfs(i, visited, tmp, graph_on_groups, groups_sorted);
		}
		std::reverse(groups_sorted.begin(), groups_sorted.end());

		for(int32_t i = 0 ; i < groups.size(); i++) {
			for(int32_t j = 0 ; j < groups[groups_sorted[i]].size(); j++)
				std::cout << groups[groups_sorted[i]][j] + 1 << " ";
		}
	}
	return 0;
}












