#include <bits/stdc++.h>
using namespace std;

const int MAXN = 500005;

int sum[4 * MAXN], minPref[4 * MAXN], maxPref[4 * MAXN];
int assign_tag[4 * MAXN];   // 2 = no assignment, 1 = '(', -1 = ')'
bool flip_tag[4 * MAXN];

inline void applyAssign(int node, int val, int len) {
    assign_tag[node] = val;
    flip_tag[node] = false;
    sum[node] = val * len;
    if (val == 1) {
        minPref[node] = 0;
        maxPref[node] = len;
    } else {
        minPref[node] = -len;
        maxPref[node] = 0;
    }
}

inline void applyFlip(int node, int len) {
    if (assign_tag[node] != 2) {
        applyAssign(node, -assign_tag[node], len);
    } else {
        sum[node] = -sum[node];
        int tmp = minPref[node];
        minPref[node] = -maxPref[node];
        maxPref[node] = -tmp;
        flip_tag[node] ^= 1;
    }
}

inline void push(int node, int l, int r) {
    int mid = (l + r) / 2;
    int left = node * 2, right = node * 2 + 1;
    if (assign_tag[node] != 2) {
        applyAssign(left, assign_tag[node], mid - l + 1);
        applyAssign(right, assign_tag[node], r - mid);
        assign_tag[node] = 2;
    }
    if (flip_tag[node]) {
        applyFlip(left, mid - l + 1);
        applyFlip(right, r - mid);
        flip_tag[node] = false;
    }
}

inline void pull(int node) {
    int left = node * 2, right = node * 2 + 1;
    sum[node] = sum[left] + sum[right];
    minPref[node] = min(minPref[left], sum[left] + minPref[right]);
    maxPref[node] = max(maxPref[left], sum[left] + maxPref[right]);
}

void build(int node, int l, int r, const vector<int>& a) {
    assign_tag[node] = 2;
    flip_tag[node] = false;
    if (l == r) {
        int val = a[l - 1];
        sum[node] = val;
        minPref[node] = min(0, val);
        maxPref[node] = max(0, val);
        return;
    }
    int mid = (l + r) / 2;
    build(node * 2, l, mid, a);
    build(node * 2 + 1, mid + 1, r, a);
    pull(node);
}

void updateAssign(int node, int l, int r, int ql, int qr, int val) {
    if (ql <= l && r <= qr) {
        applyAssign(node, val, r - l + 1);
        return;
    }
    push(node, l, r);
    int mid = (l + r) / 2;
    if (ql <= mid) updateAssign(node * 2, l, mid, ql, qr, val);
    if (qr > mid) updateAssign(node * 2 + 1, mid + 1, r, ql, qr, val);
    pull(node);
}

void updateFlip(int node, int l, int r, int ql, int qr) {
    if (ql <= l && r <= qr) {
        applyFlip(node, r - l + 1);
        return;
    }
    push(node, l, r);
    int mid = (l + r) / 2;
    if (ql <= mid) updateFlip(node * 2, l, mid, ql, qr);
    if (qr > mid) updateFlip(node * 2 + 1, mid + 1, r, ql, qr);
    pull(node);
}

struct Node {
    int sum, minPref, maxPref;
};

Node query(int node, int l, int r, int ql, int qr) {
    if (ql <= l && r <= qr) {
        return {sum[node], minPref[node], maxPref[node]};
    }
    push(node, l, r);
    int mid = (l + r) / 2;
    
    if (qr <= mid) return query(node * 2, l, mid, ql, qr);
    if (ql > mid) return query(node * 2 + 1, mid + 1, r, ql, qr);
    
    Node left = query(node * 2, l, mid, ql, qr);
    Node right = query(node * 2 + 1, mid + 1, r, ql, qr);
    Node res;
    res.sum = left.sum + right.sum;
    res.minPref = min(left.minPref, left.sum + right.minPref);
    res.maxPref = max(left.maxPref, left.sum + right.maxPref);
    return res;
}

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

    int n, Q;
    if (!(cin >> n >> Q)) return 0;
    string S;
    cin >> S;
    vector<int> a(n);
    for (int i = 0; i < n; ++i) {
        a[i] = (S[i] == '(') ? 1 : -1;
    }
    build(1, 1, n, a);
    
    while (Q--) {
        int L, H;
        char c;
        cin >> L >> H >> c;
        
        // Cực kỳ quan trọng để tránh Segment Tree bị lặp vô hạn
        if (L > H) swap(L, H); 
        
        if (c == '?') {
            Node res = query(1, 1, n, L, H);
            if (res.sum == 0 && res.minPref >= 0)
                cout << "yes\n";
            else
                cout << "no\n";
        } else if (c == '(') {
            updateAssign(1, 1, n, L, H, 1);
        } else if (c == ')') {
            updateAssign(1, 1, n, L, H, -1);
        } else if (c == '-') {
            updateFlip(1, 1, n, L, H);
        }
    }
    return 0;
}