class Node:
    def __init__(self, data, left=None, right=None):
        self.data = data
        self.left = left
        self.right = right


class Tree:
    def __init__(self):
        self.root = Node(1)
        self.nodes = [self.root]
        self.array = []
        self.counts = []

    def insert(self, node, data, direction):
        for each in self.nodes:
            if each.data == node:
                if direction == 0 and data != -1:
                    new_node = Node(data)
                    each.left = new_node
                    self.nodes.append(new_node)
                elif data != -1:
                    new_node = Node(data)
                    each.right = new_node
                    self.nodes.append(new_node)

    def display(self, node):
        if node:
            self.display(node.left)
            self.array.append(node.data)
            self.display(node.right)

    def getDepth(self, root, count):
        node = root
        if node:
            self.getDepth(node.left, count+1)
            self.counts.append(count)
            self.getDepth(node.right, count+1)

    def swap(self, root, query, counter):
        node = root
        if counter+1 == query:
            node.left, node.right = node.right, node.left
            return
        else:
            if node.left is not None:
                self.swap(node.left, query, counter+1)
            if node.right is not None:
                self.swap(node.right, query, counter+1)


def swapNodes(indexes, queries):
    b_tree = Tree()
    b_tree.insert(1, indexes[0], 0)
    b_tree.insert(1, indexes[1], 1)
    my_array = []
    i = -1
    for each in indexes:
        i += 1
        if each == -1:
            i -= 1
            continue
        else:
            counter = i + (i+2)
            if counter > len(indexes)-1:
                break

            b_tree.insert(each, indexes[counter], 0)
            counter += 1

            if counter > len(indexes)-1:
                break
            b_tree. insert(each, indexes[counter], 1)

    b_tree.getDepth(b_tree.root, 1)
    depth = max(b_tree.counts)
    for query in queries:
        H = [query * i for i in range(1, depth) if query * i <= depth]
        for h in H:
            b_tree.swap(b_tree.root, h, 0)
        b_tree.display(b_tree.root)
        my_array.append(b_tree.array)
        b_tree.array = []
    return my_array