Let *D*(*x*) be the number of positive divisors of a positive integer *x*. For example, *D*(2) = 2 (2 is divisible by 1 and 2), *D*(6) = 4 (6 is divisible by 1, 2, 3 and 6).

You are given an array *a* of *n* integers. You have to process two types of queries:
 1.  REPLACE *l* *r* — for every <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/6afb5e3d414ffbb040c175e23c6627da949add06.png" style="max-width: 100.0%;max-height: 100.0%;"/> replace *a*<sub class="lower-index">*i*</sub> with *D*(*a*<sub class="lower-index">*i*</sub>); 1.  SUM *l* *r* — calculate <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/1e50b9417bb7e50d92d43134922596e938249431.png" style="max-width: 100.0%;max-height: 100.0%;"/>. 
Print the answer for each SUM query.
The first line contains two integers *n* and *m* (1 ≤ *n*, *m* ≤ 3·10<sup class="upper-index">5</sup>) — the number of elements in the array and the number of queries to process, respectively.

The second line contains *n* integers *a*<sub class="lower-index">1</sub>, *a*<sub class="lower-index">2</sub>, ..., *a*<sub class="lower-index">*n*</sub> (1 ≤ *a*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">6</sup>) — the elements of the array.

Then *m* lines follow, each containing 3 integers *t*<sub class="lower-index">*i*</sub>, *l*<sub class="lower-index">*i*</sub>, *r*<sub class="lower-index">*i*</sub> denoting *i*-th query. If *t*<sub class="lower-index">*i*</sub> = 1, then *i*-th query is REPLACE *l*<sub class="lower-index">*i*</sub> *r*<sub class="lower-index">*i*</sub>, otherwise it's SUM *l*<sub class="lower-index">*i*</sub> *r*<sub class="lower-index">*i*</sub> (1 ≤ *t*<sub class="lower-index">*i*</sub> ≤ 2, 1 ≤ *l*<sub class="lower-index">*i*</sub> ≤ *r*<sub class="lower-index">*i*</sub> ≤ *n*).

There is at least one SUM query.
none
7 6
6 4 1 10 3 2 4
2 1 7
2 4 5
1 3 5
2 4 4
1 5 7
2 1 7
30
13
4
22
4 2
1 1 1 3
1 1 4
2 1 4
5
10 2
1 1 1 1 1 1 1 1 1 9
1 1 10
2 1 10
12
4 2
1 1 3 1
1 1 4
2 1 4
5
5 3
1 1 1 1 3
2 1 5
1 1 5
2 1 5
7
6
7 10
1 1 1 1 1 1 1
1 1 7
1 1 7
1 1 7
1 1 7
1 1 7
1 1 7
1 1 7
1 1 7
1 1 7
2 1 7
7
from sys import stdout, stdin
r = lambda: int(input())
ra = lambda: [*map(int, input().split())]
raw = lambda: [*stdin.readline()]

def c(a, B):
    f(B)
    ch = ['']*3
    LC = -1
    for i in a:
        LC+=1
        if '' in ch:
            for j in range(3):
                if ch[j] == '': ch[j] = nxt(B[j])
        if ch == [-1]*3:
            sle(LC)
            return True
        if i in ch:
            if ch.count(i)>1:
                g = [_ for _, e in enumerate(ch) if e == i]
                if len(B[g[0]])>=len(B[g[1]]): ch[g[0]] = ''
                else: ch[g[1]] = ''
            else: ch[ch.index(i)] = ''
    if '' in ch:
        for j in range(3):
            if ch[j] == '': ch[j] = nxt(B[j])
    if ch == [-1]*3:
        sle(LC)
        return True
    else: return False
        
def f(a):
    a[0] = a[0][::-1]
    a[1] = a[1][::-1]
    a[2] = a[2][::-1]

def nxt(a):
    if len(a)>0: return a.pop()
    else: return -1

def sle(a):
    le = a

def gle(): return le


n, q = ra()
a = raw()
a.pop()
b = [[], [], []]
le = 0

for i in range(q):
    s = stdin.readline()
    t = int(s[2])-1
    if s[0]=='+': b[t]+=[s[4]]
    else: b[t].pop()
    ar = b[:]
    if s[0]=='+':
        if s[4] not in a:
            stdout.write("".join('NO'))
            stdout.write("".join('\n'))
        elif le!=0 and s[4] in a[le:n]:
            stdout.write("".join('YES'))
            stdout.write("".join('\n'))
        else:
            stdout.write("".join('YNEOS'[not c(a, ar)::2]))
            stdout.write("".join('\n'))
    else:
        stdout.write("".join('YNEOS'[not c(a, ar)::2]))
        stdout.write("".join('\n'))
