/* ICPC 2014 Asia Regional Tokyo Problem G, Flipping Parentheses

 * 開括弧が閉括弧になったとき -> 最も左にある閉括弧または変化した括弧のうち、左にあるものを操作.
 * 閉括弧が開括弧になったとき -> どの区間の深さも負にならないように操作できる開括弧のうち、最も左のものを操作

 */

import std.stdio;
import std.ascii;
import std.range;
import std.array;
import std.functional;
import std.algorithm;
import std.conv;
import std.container;
import std.math;
import std.numeric;
import std.string;
import std.c.string;
import std.random;
import std.regex;
import std.typecons;

const INF = long.max / 8L;

class SegmentTree {
    // rootのindexは1
    int N;
    long[] V, L;
    static int FindPow2(int x) {
        int x1 = 1;
        while (x1 < x) x1 *= 2;
        return x1;
    }
    this(int N_) {
        N = FindPow2(N_);
        V = new long[N * 2];
        L = new long[N * 2];
    }
    /* [s, t)に一様にxを加算 */
    void add(long x, int s, int t) { return add(x, s, t, 0, N, 1); }
    void add(long x, int s, int t, int a, int b, int k) {
        if (t <= a || b <= s) return;
        if (s <= a && b <= t) {
            L[k] += x;
        } else if (s < b || a < t) {
            int m = (a + b) / 2;
            add(x, s, t, a, m, k * 2);
            add(x, s, t, m, b, k * 2 + 1);
            V[k] = min(V[k * 2] + L[k * 2], V[k * 2 + 1] + L[k * 2 + 1]);
        }
    }
    /* [s, t)の最小値 */
    long query(int s, int t) { return query(s, t, 0, N, 1); }
    long query(int s, int t, int a, int b, int k) {
        if (t <= a || b <= s) return INF;
        if (s <= a && b <= t) return V[k] + L[k];
        int m = (a + b) / 2;
        return min( query(s, t, a, m, k * 2), query(s, t, m, b, k * 2 + 1)) + L[k];
    }
};

void main() {
    int N, Q; scanf("%d %d\n", &N, &Q);
    char[] s = readln.chomp.dup;
    auto seg = new SegmentTree(N + 1);
    for (int i = 1; i <= N; i++) {
        auto c = s[i - 1];
        auto d = (c == '(' ? +1 : -1);
        seg.add(d, i, N + 1);
    }
    void dump() {
        foreach (i; 0 .. N + 1) {
            write(seg.query(i, i + 1), " ");
        }
        writeln;
    }

    auto open  = new RedBlackTree!int,
         close = new RedBlackTree!int;

    foreach (int i, c; s) {
        ( c == '(' ? open : close ).insert(i);
    }

    foreach (i; 0 .. Q) {
        int q; scanf("%d\n", &q);
        int sign = (s[q - 1] == '(' ? -1 : 1);

        //writeln("q: ", q);
        //writeln("s: ", s);
        //writeln("open: ", open[]);
        //writeln("close: ", close[]);

        if (s[q - 1] == '(') {
            auto r = close.lowerBound(q); // qより左の閉括弧
            if (r.empty) {
                writeln(q);
            } else {
                seg.add(-2, q, N + 1);
                auto index = r.front; // 開く閉括弧のインデックス
                writeln(index + 1);
                open.removeKey(q - 1);
                close.insert(q - 1);
                close.removeKey(index);
                open.insert(index);
                seg.add(2, index + 1, N + 1);
                s[index] = '('; s[q - 1] = ')';
            }
        } else {
            seg.add(2, q, N + 1);
            int lb = 0, ub = q; // (lb, ub]
            bool C(int x) {
                return seg.query(x, q) >= 2;
            }
            while (lb + 1 < ub) {
                int mid = (lb + ub) / 2;
                ( C(mid) ? ub : lb ) = mid;
            }
            writeln(ub);
            close.removeKey(q - 1);
            open.insert(q - 1);
            open.removeKey(ub - 1);
            close.insert(ub - 1);
            seg.add(-2, ub, N + 1);
            s[q - 1] = '(';
            s[ub - 1] = ')';
        }
        //dump;
    }
}