#include <bits/stdc++.

h>

using namespace std;

class Node{
public:
int data;
Node *left;
Node *right;
};
Node* treebuild(vector<vector<int>> indexes ){
Node *node, *temp;
node= new Node();
node->left=NULL;
node->right=NULL;
node->data=1;
temp=node;
queue<Node *>current;
for(unsigned i=0;i<indexes.size();i++){
if(indexes[i][0]!=-1){
Node *Left;
Left=new Node();
Left->data=indexes[i][0];
Left->left=NULL;
Left->right=NULL;
temp->left=Left;
current.push(Left);
}
if(indexes[i][1]!=-1){
Node *Right;
Right=new Node();
Right->data=indexes[i][1];
Right->left=NULL;
Right->right=NULL;
temp->right=Right;
current.push(Right);
}
if(!current.empty()){
current.pop();
}
temp=current.front();
}
return(node);
}
Node * swapTree(Node *node, int a){
queue<Node *> present;
queue<Node *> past;
present.push(node);
Node *Temp;
Node *flag;
int level=0;
while(level<a-1){
while(!present.empty()){
Temp=present.front();
if(Temp->left!=NULL){
past.push(Temp->left);
}
if(Temp->right!=NULL){
past.push(Temp->right);
}
 present.pop();
}
present.swap(past);
level++;
}
while(!present.empty()){
Temp=present.front();
if(Temp->left!=NULL&&Temp->right!=NULL){
flag=Temp->left;
Temp->left=Temp->right;
Temp->right=flag;
}
else if(Temp->left==NULL){
Temp->left=Temp->right;
Temp->right=NULL;
}
else if(Temp->right==NULL){
Temp->right=Temp->left;
Temp->left=NULL;
}
present.pop();
}
return(node);
}
vector<int> inorder(Node *node,vector<int>tempvec){
if(node!=NULL){
tempvec=inorder(node->left,tempvec);
tempvec.push_back(node->data);
tempvec=inorder(node->right,tempvec);
}
return(tempvec);
}
vector<vector<int>> swapNodes(vector<vector<int>> indexes, vector<int> queries) {
vector<vector<int>>result;
vector<int>tempvec;
Node *node;
node=new Node;
node=treebuild(indexes);
for(unsigned i=0;i<queries.size();i++){
node=swapTree(node,queries[i]);
result.push_back(inorder(node,tempvec));
}
return(result);
}

int main()
{
ofstream fout(getenv("OUTPUT_PATH"));

int n;
cin >> n;
cin.ignore(numeric_limits<streamsize>::max(), '\n');

vector<vector<int>> indexes(n);
for (int indexes_row_itr = 0; indexes_row_itr < n; indexes_row_itr++) {
indexes[indexes_row_itr].resize(2);

for (int indexes_column_itr = 0; indexes_column_itr < 2;

indexes_column_itr++) {
 cin >> indexes[indexes_row_itr][indexes_column_itr];
}

cin.ignore(numeric_limits<streamsize>::max(), '\n');
}

int queries_count;
cin >> queries_count;
cin.ignore(numeric_limits<streamsize>::max(), '\n');

vector<int> queries(queries_count);

for (int queries_itr = 0; queries_itr < queries_count; queries_itr++) {

int queries_item;
cin >> queries_item;
cin.ignore(numeric_limits<streamsize>::max(), '\n');

queries[queries_itr] = queries_item;
}

vector<vector<int>> result = swapNodes(indexes, queries);

for (int result_row_itr = 0; result_row_itr < result.size(); result_row_itr++)

{
for (int result_column_itr = 0; result_column_itr <
result[result_row_itr].size(); result_column_itr++) {
fout << result[result_row_itr][result_column_itr];

if (result_column_itr != result[result_row_itr].size() - 1) {
fout << " ";
}
}

if (result_row_itr != result.size() - 1) {
fout << "\n";
}
}

fout << "\n";

fout.close();

return 0;
}