package main

import (
	"bytes"
	"container/heap"
	"io"
	"os"
)

type MinHeap []int

func (h MinHeap) Len() int           { return len(h) }
func (h MinHeap) Less(i, j int) bool { return h[i] < h[j] }
func (h MinHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
func (h *MinHeap) Push(x interface{}) {
	*h = append(*h, x.(int))
}
func (h *MinHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[:n-1]
	return x
}

type MaxHeap []int

func (h MaxHeap) Len() int           { return len(h) }
func (h MaxHeap) Less(i, j int) bool { return h[i] > h[j] }
func (h MaxHeap) Swap(i, j int)      { h[i], h[j] = h[j], h[i] }
func (h *MaxHeap) Push(x interface{}) {
	*h = append(*h, x.(int))
}
func (h *MaxHeap) Pop() interface{} {
	old := *h
	n := len(old)
	x := old[n-1]
	*h = old[:n-1]
	return x
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0

	nextInt := func() int {
		for p < len(data) && (data[p] < '0' || data[p] > '9') {
			p++
		}
		x := 0
		for p < len(data) && data[p] >= '0' && data[p] <= '9' {
			x = x*10 + int(data[p]-'0')
			p++
		}
		return x
	}

	nextString := func() string {
		for p < len(data) && (data[p] == ' ' || data[p] == '\n' || data[p] == '\r' || data[p] == '\t') {
			p++
		}
		start := p
		for p < len(data) && data[p] != ' ' && data[p] != '\n' && data[p] != '\r' && data[p] != '\t' {
			p++
		}
		return string(data[start:p])
	}

	n := nextInt()
	q := nextInt()
	s := []byte(nextString())

	active := make([]bool, 0)
	if n > 1 {
		active = make([]bool, n-1)
	}

	minH := &MinHeap{}
	maxH := &MaxHeap{}
	heap.Init(minH)
	heap.Init(maxH)

	cnt := 0

	for i := 0; i+1 < n; i++ {
		if s[i] == s[i+1] {
			active[i] = true
			cnt++
			heap.Push(minH, i)
			heap.Push(maxH, i)
		}
	}

	refresh := func(i int) {
		if i < 0 || i >= n-1 {
			return
		}
		eq := s[i] == s[i+1]
		if eq {
			if !active[i] {
				active[i] = true
				cnt++
				heap.Push(minH, i)
				heap.Push(maxH, i)
			}
		} else {
			if active[i] {
				active[i] = false
				cnt--
			}
		}
	}

	pruneMin := func() {
		for minH.Len() > 0 && !active[(*minH)[0]] {
			heap.Pop(minH)
		}
	}

	pruneMax := func() {
		for maxH.Len() > 0 && !active[(*maxH)[0]] {
			heap.Pop(maxH)
		}
	}

	check := func() bool {
		if n%2 == 1 {
			return false
		}
		if s[0] != '(' || s[n-1] != ')' {
			return false
		}
		if cnt == 0 {
			return true
		}
		pruneMin()
		pruneMax()
		return (*minH)[0]%2 == 0 && (*maxH)[0]%2 == 0
	}

	var out bytes.Buffer

	for ; q > 0; q-- {
		pos := nextInt() - 1
		if s[pos] == '(' {
			s[pos] = ')'
		} else {
			s[pos] = '('
		}
		refresh(pos - 1)
		refresh(pos)
		if check() {
			out.WriteString("YES\n")
		} else {
			out.WriteString("NO\n")
		}
	}

	os.Stdout.Write(out.Bytes())
}