// Potpuno rjesenje - 1, 2, 3. i 4. podzadatak (20 bodova)

/*
    Za rjesenje sva cetiri podzadatka, potrebno je implementirati binarnu pretragu sa segmentnim (ili fenvikovim) stablom.
    Ideja je da se svaki put markira pozicija sa koje je uzet element.
    Kada trazimo "pravu" poziciju nekog elementa na poziciji X, ona je zapravo X - sumaBrisanihElemenata(1, X).
    Dakle, kada god obrisemo neki element sa pozicija [1, X - 1], pomjerimo element na poziciji X za jedan ulijevo.
    Kako moramo efikasno da provjerimo koliko se elemenata ulijevo od X obrisalo, koristimo se segmentnim stablom.
    Segmentno stablo se gradi kao standardno segmentno stablo (koje cuva sumu podniza).
    Binarnom pretragom trazimo "pravu" poziciju elementa (pogledati kôd ispod) i ispisujemo element sa date pozicije kada je pronadjemo.
*/

#include <iostream>
#include <vector>

using namespace std;

const int mxn = 2e5 + 5;
vector<int> segtree(4 * mxn);
vector<int> g(mxn);
vector<int> ans;
int N, Q;

// Vraca sumu unutar segmenta - u nasem slucaju, segment ce uvijek biti [l, r] = [1, r]
int segtreeSum(int c, int tl, int tr, int l, int r) {
    if (tl > tr || tr < l || tl > r) {
        return 0;
    }
    if (l <= tl && tr <= r) {
        return segtree[c];
    }

    int tm = (tl + tr) / 2;
    int sumHalfL = segtreeSum(2 * c, tl, tm, l, r);
    int sumHalfR = segtreeSum(2 * c + 1, tm + 1, tr, l, r);

    return sumHalfL + sumHalfR;
}

// Funkcija koja vraca pravu poziciju (u odnosu na onu unesenu).
int query(int erasePos) {
    int l = 1;
    int r = N;

    while (l <= r) {
        int m = (l + r) / 2;

        // Broj na poziciji "m" se pomjera ulijevo za onoliko elemenata koliko je obrisano lijevo od njega
        int shiftLeft = m - segtreeSum(1, 1, N, 1, m);

        if (shiftLeft < erasePos) {
          l = m + 1;
        }
        else {
          r = m - 1;
        }
    }

    return l;
}

// Funkcija koja postavlja 1 na pronadjenu poziciju
void segtreeUpdate(int c, int tl, int tr, int pos) {
    if (tl == tr) {
      segtree[c] = 1;
    }

    else {
      int tm = (tl + tr) /2;

      if (pos <= tm) {
        segtreeUpdate(2 * c, tl, tm, pos);
      }
      else {
        segtreeUpdate(2 * c + 1, tm + 1, tr, pos);
      }

      segtree[c] = segtree[2 * c] + segtree[2 * c + 1];
    }
}

int main() {
    cin >> N >> Q;
    for (int i = 1; i <= N; i++) {
        cin >> g[i];
    }

    for (int q = 0; q < Q; q++) {
        int p;
        cin >> p;

        int actualPos = query(p); // Pronadji o kojoj se zapravo poziciji radi
        ans.push_back(g[actualPos]);
        segtreeUpdate(1, 1, N, actualPos); // Postavi 1 na "pravu" poziciju elementa
    }

    // Ispis rezultata
    for (auto& x: ans) {
        cout << x << " ";
    }

    return 0;
}
