#include <iostream>

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

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

void print(Node* tree) {
    if (tree->left != nullptr) {
        print(tree->left);
    }
    std::cout << tree->value << ' ';
    if (tree->right != nullptr) {
        print(tree->right);
    }
}

int main() {
    int n;
    int q;
    std::cin >> n >> q;

    Node* tree[n + 1];

    Node** tree_ind = new Node*[n + 1];
    tree_ind[0] = nullptr;

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

    for (int i = 1; i <= n; i++) {
        tree_ind[i] = tree[i];
        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_int = i;
        tree[tree[i]->right_int]->parent = tree[i];

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

    int x;
    while (q--) {
        std::cin >> x;
        if (tree_ind[x]->parent == nullptr) {
            continue;
        }
        Node* v = tree_ind[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;
            }

            tree_ind[p->value] = p;
            tree_ind[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;}


            tree_ind[p->value] = p;
            tree_ind[v->value] = v;
        }
    }
    print(tree[1]);
}