#include <iostream>
#include <vector>
#include <fstream>
#include <string>
#include <bits/stdc++.h>


struct Node {
    int value;
    Node* left;
    Node* right;
    Node* parent;
    int left_int;
    int right_int;

    Node() {
        left = nullptr;
        right = nullptr;
        parent = nullptr;
        left_int = 0;
        right_int = 0;
    }
};

struct Node_char {
    char value;
    Node_char* left;
    Node_char* right;
    Node_char* parent;
    int left_int;
    int right_int;

    Node_char() {
        left = nullptr;
        right = nullptr;
        parent = nullptr;
        left_int = 0;
        right_int = 0;
    }
};


void print(Node* tree, std::vector<int>& vector) {
    if (tree->left != nullptr) {
        print(tree->left, vector);
    }
    if (tree->right != nullptr) {
        print(tree->right, vector);
    }
    vector.push_back(tree->value);
    delete tree;
}

void print_char(Node_char* tree, std::vector<char>& vector) {
    if (tree->left != nullptr) {
        print_char(tree->left, vector);
    }
    if (tree->right != nullptr) {
        print_char(tree->right, vector);
    }
    vector.push_back(tree->value);
    delete tree;
}


std::vector<int> solve(int file) {
//    std::ifstream in(std::to_string(file));

    int n;
    int q;

//    std::cin >> n >> q;

    std::cin >> n >> q;

    Node** tree = new Node*[n + 1];
    std::unordered_map<int, Node*> map_tree;

    for (int i = 0; i <= n; i++) {
        tree[i] = new Node();
    }

    for (int i = 1; i <= n; i++) {
//        tree_ind[i] = tree[i];
        map_tree[i] = tree[i];
        std::cin >> tree[i]->value; // = i;

        tree[i]->left_int = ((i*2 <=n) ? i * 2 : 0);
        tree[i]->left = (tree[i]->left_int != 0 ? tree[tree[i]->left_int] : nullptr);

        tree[i]->right_int = ((i*2 + 1 <=n) ? i * 2 + 1 : 0);
        tree[i]->right = (tree[i]->right_int != 0 ? tree[tree[i]->right_int] : nullptr);

        tree[tree[i]->right_int]->parent = tree[i];

        tree[tree[i]->left_int]->parent = tree[i];
    }

    int x;
    while (q--) {
        std::cin >> x;
        if (map_tree[x]->parent == nullptr) {
            continue;
        }
        Node* v = map_tree[x];
        Node* p = v->parent;
        if (p->left == v) {
            Node* pr = p->right;
            Node* vr = v->right;
            std::swap(v->value, p->value);
            p->right = vr;
            v->right = pr;

            if (vr != nullptr) {
                vr->parent = p;
            }

            if (pr != nullptr) {
                pr->parent = v;
            }

            map_tree[p->value] = p;
            map_tree[v->value] = v;
        } else {
            Node* pl = p->left;
            Node* vl = v->left;

            std::swap(p->value, v->value);
            p->left = vl;
            v->left = pl;

            if (pl != nullptr) {pl->parent = v;}

            if (vl != nullptr) {vl->parent = p;}


            map_tree[p->value] = p;
            map_tree[v->value] = v;
        }
    }
    std::vector<int> vec;
    print(tree[1], vec);
    delete []tree;
    return vec;
}

std::vector<char> solve_char(int file) {
//    std::ifstream in(std::to_string(file));

    int n;
    int q;

//    std::cin >> n >> q;

    std::cin >> n >> q;

    Node_char** tree = new Node_char*[n + 1];
    std::unordered_map<int, Node_char*> map_tree;



    for (int i = 0; i <= n; i++) {
        tree[i] = new Node_char();
    }

    for (int i = 1; i <= n; i++) {
//        tree_ind[i] = tree[i];
        map_tree[i] = tree[i];
        std::cin >> tree[i]->value; // = i;

        tree[i]->left_int = ((i*2 <=n) ? i * 2 : 0);
        tree[i]->left = (tree[i]->left_int != 0 ? tree[tree[i]->left_int] : nullptr);

        tree[i]->right_int = ((i*2 + 1 <=n) ? i * 2 + 1 : 0);
        tree[i]->right = (tree[i]->right_int != 0 ? tree[tree[i]->right_int] : nullptr);

        tree[tree[i]->right_int]->parent = tree[i];

        tree[tree[i]->left_int]->parent = tree[i];
    }

    int x;
    while (q--) {
        std::cin >> x;
        if (map_tree[x]->parent == nullptr) {
            continue;
        }
        Node_char* v = map_tree[x];
        Node_char* p = v->parent;
        if (p->left == v) {
            Node_char* pr = p->right;
            Node_char* vr = v->right;
            std::swap(v->value, p->value);
            p->right = vr;
            v->right = pr;

            if (vr != nullptr) {
                vr->parent = p;
            }

            if (pr != nullptr) {
                pr->parent = v;
            }

            map_tree[p->value] = p;
            map_tree[v->value] = v;
        } else {
            Node_char* pl = p->left;
            Node_char* vl = v->left;

            std::swap(p->value, v->value);
            p->left = vl;
            v->left = pl;

            if (pl != nullptr) {pl->parent = v;}

            if (vl != nullptr) {vl->parent = p;}


            map_tree[p->value] = p;
            map_tree[v->value] = v;
        }
    }
    std::vector<char> vec;
    print_char(tree[1], vec);
    delete []tree;

    return vec;
}




int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

//    std::freopen(, "r", stdin);

    std::vector<int> vec;
    std::vector<char> vec_char;
    for (int i = 30; i < 31; i++) {
//        std::cout << i << "\n";
//        std::ofstream outfile(std::to_string(i) + ".a");
//        std::freopen(std::to_string(i).c_str(), "r", stdin);

        vec = solve(i);
        vec_char = solve_char(i);
//        std::fclose(stdin);
//        std::freopen((std::to_string(i) + ".a").c_str(), "w", stdout);
        for (int j = 0; j < vec.size(); j++) {
            while (vec[j]--) {
                std::cout << vec_char[j];
//                std::printf("%c", vec_char[j]);
//                std::printf(std::string(12, vec_char[j]));
            }
        }
//        std::fclose(stdout);
    }
}