package main

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

type FastScanner struct {
	data []byte
	idx  int
}

func (fs *FastScanner) skip() {
	for fs.idx < len(fs.data) && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
}

func (fs *FastScanner) nextInt() int {
	fs.skip()
	sign := 1
	if fs.idx < len(fs.data) && fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	n := 0
	for fs.idx < len(fs.data) && fs.data[fs.idx] > ' ' {
		n = n*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return sign * n
}

func (fs *FastScanner) nextOp() byte {
	fs.skip()
	b := fs.data[fs.idx]
	for fs.idx < len(fs.data) && fs.data[fs.idx] > ' ' {
		fs.idx++
	}
	return b
}

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
}

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
}

func solveCase(fs *FastScanner, q int, out *strings.Builder) {
	leftCnt := make(map[int]int)
	rightCnt := make(map[int]int)
	lh := &MaxHeap{}
	rh := &MinHeap{}
	heap.Init(lh)
	heap.Init(rh)

	for i := 0; i < q; i++ {
		op := fs.nextOp()
		l := fs.nextInt()
		r := fs.nextInt()

		if op == '+' {
			leftCnt[l]++
			rightCnt[r]++
			heap.Push(lh, l)
			heap.Push(rh, r)
		} else {
			leftCnt[l]--
			if leftCnt[l] == 0 {
				delete(leftCnt, l)
			}
			rightCnt[r]--
			if rightCnt[r] == 0 {
				delete(rightCnt, r)
			}
		}

		for lh.Len() > 0 {
			x := (*lh)[0]
			if leftCnt[x] == 0 {
				heap.Pop(lh)
			} else {
				break
			}
		}
		for rh.Len() > 0 {
			x := (*rh)[0]
			if rightCnt[x] == 0 {
				heap.Pop(rh)
			} else {
				break
			}
		}

		if lh.Len() > 0 && rh.Len() > 0 && (*lh)[0] > (*rh)[0] {
			out.WriteString("YES\n")
		} else {
			out.WriteString("NO\n")
		}
	}
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	fs := &FastScanner{data: data}
	fs.skip()
	if fs.idx >= len(fs.data) {
		return
	}

	var out strings.Builder
	first := fs.nextInt()
	fs.skip()

	if fs.idx < len(fs.data) && (fs.data[fs.idx] == '+' || fs.data[fs.idx] == '-') {
		solveCase(fs, first, &out)
	} else {
		t := first
		for i := 0; i < t; i++ {
			q := fs.nextInt()
			solveCase(fs, q, &out)
		}
	}

	os.Stdout.Write([]byte(out.String()))
}