import java.io.

*;
import java.math.*;
import java.text.*;
import java.util.*;
import java.util.regex.*;

public class Solution {

/*
* Complete the swapNodes function below.
*/
public static int[] inorder(int[][] arr)
{
int[] answer = new int[arr.length];
int index = 0;
Stack stk = new Stack();
stk.add(1);
int curr = 1;
while(!stk.isEmpty())
{
if(arr[curr-1][0] != -1)
stk.push(arr[curr-1][0]);
else
{
answer[index] = (int)stk.pop();
index++;
System.out.println(index);
curr = arr[curr-1][1];
}
}

return answer;
}
static int[][] swapNodes(int[][] indexes, int[] queries) {
/*
* Write your code here.
*/
System.out.println("out1");
int[][] answer = new int[queries.length][];
int[] level = new int[indexes.length + 1];
int totalLevels = 1;
level[0] = 0;
level[1] = 1;

for(int i = 0 ; i < indexes.length ; i++)

{
if(indexes[i][0] != -1)
{
level[indexes[i][0]] = level[i+1] + 1;
totalLevels = Math.max(totalLevels, level[indexes[i][0]]);
}
if(indexes[i][1] != -1)
{
level[indexes[i][1]] = level[i+1] + 1;
totalLevels = Math.max(totalLevels, level[indexes[i][1]]);
}

}
System.out.println("out2");
 List<List<Integer>> NodesAtLevel = new ArrayList();
List<Integer> temp = new ArrayList();
NodesAtLevel.add(temp);
for(int i = 1 ; i < totalLevels + 1 ; i++)
{
temp = new ArrayList();
NodesAtLevel.add(temp);
}

System.out.println("out3");
for(int i = 1 ; i < level.length ; i++)
NodesAtLevel.get(level[i]).add(i);

System.out.println("out4");
for(int i = 0 ; i < queries.length ; i++)
{
int k = queries[i];
for(int j = k ; j < totalLevels ; j = j + k)
{
temp = NodesAtLevel.get(j);
System.out.println("outttt");
System.out.println(temp.size());
for(int x = 0 ; x < temp.size() ; x++)
{
int swaper = indexes[temp.get(x) - 1][0];
indexes[temp.get(x) - 1][0] = indexes[temp.get(x) - 1][1];
indexes[temp.get(x) - 1][1] = swaper;
}
}
answer[i] = inorder(indexes);

}
System.out.println("out5");
return answer;
}

private static final Scanner scanner = new Scanner(System.in);

public static void main(String[] args) throws IOException {

BufferedWriter bufferedWriter = new BufferedWriter(new
FileWriter(System.getenv("OUTPUT_PATH")));

int n = Integer.parseInt(scanner.nextLine().trim());

int[][] indexes = new int[n][2];

for (int indexesRowItr = 0; indexesRowItr < n; indexesRowItr++) {

String[] indexesRowItems = scanner.nextLine().split(" ");

for (int indexesColumnItr = 0; indexesColumnItr < 2; indexesColumnItr+

+) {
int indexesItem =
Integer.parseInt(indexesRowItems[indexesColumnItr].trim());
indexes[indexesRowItr][indexesColumnItr] = indexesItem;
}
}

int queriesCount = Integer.parseInt(scanner.nextLine().trim());

 int[] queries = new int[queriesCount];

for (int queriesItr = 0; queriesItr < queriesCount; queriesItr++) {

int queriesItem = Integer.parseInt(scanner.nextLine().trim());
queries[queriesItr] = queriesItem;
}

int[][] result = swapNodes(indexes, queries);

for (int resultRowItr = 0; resultRowItr < result.length; resultRowItr++) {

for (int resultColumnItr = 0; resultColumnItr <
result[resultRowItr].length; resultColumnItr++) {
bufferedWriter.write(String.valueOf(result[resultRowItr]
[resultColumnItr]));

if (resultColumnItr != result[resultRowItr].length - 1) {
bufferedWriter.write(" ");
}
}

if (resultRowItr != result.length - 1) {
bufferedWriter.write("\n");
}
}

bufferedWriter.newLine();

bufferedWriter.close();
}
}