struct List_node{//链节点 
	int elem=0;//数据 
	List_node* next=nullptr;//下一个节点的指针 
}; 

struct List{//链表 
	int Size;//保存节点个数
	List_node* head;//头结点
	List_node* top;//头指针 
}; 
List list;//创建链表
void Initialize(){//链表初始化 
	list.head=new List_node;
	list.head->elem=0;
	list.head->next=nullptr;
	list.Size=0;
	list.top=list.head;//头指针指向头节点 
} 

int size(){
	return list.Size;
} 

bool empty(){
	if(list.Size==0)return true;
	return false;
	//或
	if(list.top==list.head) return true;
	return false; 
}

void push_front_head(int data){//头插法 
	List_node * newnode=new List_node;
	newnode->elem=0; 
	list.top->elem=data;//保存值 
	newnode->next=list.top; //next 指向top指向的位置 
	list.top=newnode;//top指向新节点 
    list.Size++;//元素个数+1
}

void push_front_tail(int data){ //尾插法 
	List_node * newnode=new List_node;
	newnode->elem=data;
	newnode->next=list.top->next; 
	list.top->next=newnode;
    list.Size++;//元素个数+1
} 

void push_back(int data){//尾部插入 
	List_node* new_node=new List_node;
	new_node->elem=data;
	//开始找最后一个节点
	List_node* p=list.top;
	int num=list.Size;
	while(num>0){
		p=p->next;//指向下一个节点
		num--; 
	}
	//找到最后节点位置，开始插入
	p->next=new_node; 
} 

void pop_front(){
	if(list.Size==0) cout<<"链空"<<endl;
	else{
		List_node* node=list.top->next;//指向第一个节点
		list.top=node->next;//top指向第二个节点
		delete node;//释放第一个节点的内存 
		list.Size--;//元素个数-1 
	} 
}

void pop_back(){
	if(list.Size==0) cout<<"链空"<<endl;
	else{
		List_node* node1=list.top;//指向top
		List_node* node2=list.top->next;//指向第一个节点
		while(node2->next!=nullptr){
			node1=node1->next;
			node2=node2->next;
		}
		//到达最后的位置
		node1->next=nullptr;//将倒数第二个节点的next 置为空
		delete node2;//释放最后一个节点的内存
		list.Size--;//元素个数-1 
	}
} 

void erase(int data){
	if(list.Size==0) cout<<"链空"<<endl;
	else{
		List_node* node1=list.top;//指向top
		List_node* node2=list.top->next;//指向第一个节点
		if(node2->elem==data) pop_front();//如果是第一个节点的话直接删除
		else{
			bool b=false;//表示是否找到该数据的位置 
			while(node2->next!=nullptr){
				node1=node1->next;
				node2=node2->next;
				if(node2->elem==data){
					b=true;
					break;
				} 
			}
			//找到位置
			if(b){
				node1->next=node2->next;
				delete node2;//释放最后一个节点的内存
			    list.Size--;//元素个数-1 
			} 
            else cout<<"未找到这个数据的节点";
		} 	
	}
} 

void traverse(){
	//方法1： 
	if(list.Size==0)cout<<"空链表"<<endl;
	else{
		List_node* node=list.top->next;//指向第一个节点
		int num=list.Size;
		while(num>0){
			cout<<node->elem<<" ";//输出数据
			num--; 
		} 
	}
	//方法2： 
	if(list.Size==0)cout<<"空链表"<<endl;
	else{
		List_node* node=list.top->next;//指向第一个节点
		while(node->next!=nullptr){
			cout<<node->elem<<" ";//输出数据
			node=node->next; 
		} 
	}
	
}

#include<iostream>
#include<forward_list>
using namespace std;
int main(){
	
	//构造函数 
	forward_list<int> n;//创建一个单链表
	//使用数组构造
	int arr[10]={1,2,3,4,5,6,7,8,9,10};
	forward_list<int> n1(arr,arr+10);
	forward_list<int> n2(arr+2,arr+10);
	forward_list<int> n3(begin(arr),end(arr));
	//使用数据构造
	forward_list<int> n4(10);//10个默认数据 
	forward_list<int> n5(10,500);//10个数据的值为500
	//使用拷贝构造
	forward_list<int> n6(n5);//拷贝
	
	//赋值操作
	forward_list<int> n7=n6;//使用=赋值 
	n7.assign({1,2,3,4,5});//使用assign赋值 
	n7.assign(10,100);//使用assign赋值	
	n7.assign(n2.begin(),n2.end());//使用assign赋值
	
	//访问数据
	cout<<n7.front()<<endl;//访问第一个节点 
	
	//头部插入和删除
	n7.push_front(50);//头部插入
	n7.emplace_front(60);//头部插入
	n7.pop_front();//头部删除
	
	//遍历链表
	for(auto it=n7.begin();it!=n7.end();it++){
		cout<<*it<<" ";
	} 
	 
	return 0;
}

struct List_node{ //链表节点 
	int elem=0;
	List_node *next=nullptr;
};

struct Circular_Linked_List{//循环单链表 
	int Size;
	List_node *head;//头节点 
	List_node *top;////头指针 
};
Circular_Linked_List cll;//创建一个循环单链表 
void Initialize(){ //循环单链表初始化 
	cll.Size=0;//元素个数 
	cll.head=new List_node;
	cll.top=cll.head;//头指针指向头节点
	cll.head->next=cll.head;//尾部连接起来，实现循环 
}

int size(){
	return cll.Size;
} 

bool empty(){
	//方法1
	if(cll.Size==0) return true;
	return false;
	//方法2
	if(cll.top==cll.head->next) return true
	return false; 
}

void push_front(int data){
	List_node*newnode=new List_node;
	newnode->elem=data;
	newnode->next=cll.top->next;
	cll.top->next=newnode; 
	cll.Size++;
}

void pop_front(){
	if(empty()) cout<<"空链"<<endl;
	else{
		List_node*newnode=new List_node;
		newnode=cll.top->next;
		cll.top->next=newnode->next; 
		delete newnode;
		cll.Size--;
	} 
} 

int front(){
	if(empty()) cout<<"空链"<<endl;
	else return cll.top->next->elem;
}

struct List_node{ //链表节点 
	List_node* prev=nullptr;
	int elem=0;
	List_node *next=nullptr;
};

struct Doubly_Linked_List{//双向链表 
	int Size;
	List_node *head;//头节点 
	List_node *top;//头指针 
};

Doubly_Linked_List dll;//创建一个链表 

void Initialize(){ //双向链表初始化 
	dll.Size=0;//元素个数 
	dll.head=new List_node;
	dll.top=dll.head;//头指针指向头节点
}

int size(){
	return dll.Size;
} 

bool empty(){
	//方法1
	if(dll.Size==0) return true;
	else false;
	//方法2
	if(dll.top->next==nullptr) return true;
	return false; 
}

void push_front(int data){
	List_node * newnode=new List_node;
	newnode->elem=data;
	newnode->next=dll.top->next;
	dll.top->next->prev=newnode;
	dll.top->next=newnode;
	newnode->prev=dll.top;
	dll.Size++;	
}

void pop_front(){
	if(empty()) cout<<"链空"<<endl;
	else{
		dll.top->next->next->prev=dll.top;
		dll.top->next=dll.top->next->next;
		dll.Size--;
	}
}

void insert(int inedex,int data){
	if(empty()) cout<<"链空"<<endl;
	else{
		//开始查找
		List_node *p=dll.top->next;
		while(p!=nullptr){
			if(p->elem==data) break;//找到了退出循环
			else p=p->next;//进入下一个节点 
		} 
		if(p!=nullptr){
			List_node*newnode=new List_node;
			newnode->elem=data;
			//开始插入到p前面
			newnode->prev=p->prev; 
			newnode->next=p;
			p->prev->next=newnode;
			p->prev=newnode;
			dll.Size++;
		} 
	} 
}

void erase(int number){ //查找这个number所在的位置
	if(empty()) cout<<"链空"<<endl;
	else{
		//开始查找
		List_node *p=dll.top->next;
		while(p!=nullptr){
			if(p->elem==number) break;//找到了退出循环
			else p=p->next;//进入下一个节点 
		} 
		if(p!=nullptr){
			//开始删除 
			p->prev->next=p->next;
			p->next->prev=p->prev
			delete p; 
			dll.Size--;
		} 
	} 
}

struct List_node{ //链表节点 
	List_node* prev=nullptr;
	int elem=0;
	List_node *next=nullptr;
};

struct Doubly_Circular_Linked_List{//双向链表 
	int Size;
	List_node *head;//头节点 
	List_node *top;//头指针 
};

Doubly_Circular_Linked_List dcll;//创建一个链表 

void Initialize(){ //双向链表初始化 
	dcll.Size=0;//元素个数 
	dcll.head=new List_node;
	dcll.top=dll.head;//头指针指向头节点
    dcll.head->next=dcll.top;//指向本身
    dell.head->prev=dcll.top;//指向本身
}

void ReverseList(List_node*head){
	if(head==nullptr) return;
	//创建 P H K 指针
	List_node *P,*H,*K;
	P=nullptr;
	H=head->next;//指向第一个节点
	K=H->next;//指向H下一个节点
	while(H!=nullptr){
		H->next=P;
		P=H;
		H=K;
		K=K->next;
	} 
	//最后头结点指向p
	head->next=P; 
}

bool hasCycle(List_node*head){ //head为头结点  head->next 为第一个数据 
	if(head->next==nullptr) return;
	List_node*P=head->next;//指向第一个数据 慢指针
	List_node*K=head->next;//指向第二个数据 快指针
	while(K!=nullptr||K->next!=nullptr){
		if(P==K) return true;
		P=P->next;//前进1步 
		K=K->next->next;//前进2步 
	}
	return false; 
}

List_node* EntryNodeOfLoop(List_node*head){ //head为头结点  head->next 为第一个数据 
	if(head->next==nullptr) return;
	List_node*P=head->next;//指向第一个数据 慢指针 
	List_node*K=head->next;//指向第二个数据 快指针 
	while(K!=nullptr||K->next!=nullptr){
		if(P==K){ //如果有环 
			List_node* G=head->next;//起点 
			while(G!=P){
				G=G->next;
				P=P->next; 
			} 
			//到达相遇点
			return G; 
		}
		P=P->next;//前进1步 
		K=K->next->next;//前进2步
		 
	}
	return nullptr; 
}
 

#include<iostream>
#include<list>
#include<iterator>
using namespace std;

using Iter = list<int>::iterator;
const int max_N=1e5+10;
Iter pos[max_N];//存储位置迭代器
list<int> lt;
bool b[max_N];//表示有没有被删除
int N; 
int main(){
	cin>>N;
	lt.push_front(1);
	pos[1]=lt.begin();//添加迭代器
	for(int i=2;i<=N;i++){
		int k,p;
		cin>>k>>p;
		if(p==0){
			pos[i]=lt.insert(pos[k],i);//左边插入数据，indsert会返回当前插入数据的迭代器
		}
		else{
			auto next_It=next(pos[k]);//获取下一个迭代器位置
			pos[i]=lt.insert(next_It,i);//右边插入数据 
		} 	
	} 
	int M;
	cin>>M;
	for(int x,i=1;i<=M;i++){
		cin>>x;
		if(!b[x]) lt.erase(pos[x]);
		b[x]=true;
	} 
	for(auto p:lt){
		cout<<p<<" ";
	}
	return 0;
}