package main

import (
	"io"
	"os"
	"strings"
)

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) skipSpaces() {
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c == ' ' || c == '\n' || c == '\r' || c == '\t' {
			fs.idx++
		} else {
			break
		}
	}
}

func (fs *FastScanner) nextInt() int {
	fs.skipSpaces()
	v := 0
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		v = v*10 + int(c-'0')
		fs.idx++
	}
	return v
}

func (fs *FastScanner) nextOp() byte {
	fs.skipSpaces()
	c := fs.data[fs.idx]
	fs.idx++
	return c
}

func (fs *FastScanner) peek() byte {
	fs.skipSpaces()
	if fs.idx < fs.n {
		return fs.data[fs.idx]
	}
	return 0
}

type MaxHeap struct {
	a []int
}

func (h *MaxHeap) Push(x int) {
	h.a = append(h.a, x)
	i := len(h.a) - 1
	for i > 0 {
		p := (i - 1) / 2
		if h.a[p] >= x {
			break
		}
		h.a[i] = h.a[p]
		i = p
	}
	h.a[i] = x
}

func (h *MaxHeap) Pop() int {
	a := h.a
	n := len(a) - 1
	res := a[0]
	if n == 0 {
		h.a = a[:0]
		return res
	}
	x := a[n]
	a = a[:n]
	i := 0
	for {
		l := i*2 + 1
		if l >= n {
			break
		}
		r := l + 1
		c := l
		if r < n && a[r] > a[l] {
			c = r
		}
		if a[c] <= x {
			break
		}
		a[i] = a[c]
		i = c
	}
	a[i] = x
	h.a = a
	return res
}

func (h *MaxHeap) Top() int {
	return h.a[0]
}

type MinHeap struct {
	a []int
}

func (h *MinHeap) Push(x int) {
	h.a = append(h.a, x)
	i := len(h.a) - 1
	for i > 0 {
		p := (i - 1) / 2
		if h.a[p] <= x {
			break
		}
		h.a[i] = h.a[p]
		i = p
	}
	h.a[i] = x
}

func (h *MinHeap) Pop() int {
	a := h.a
	n := len(a) - 1
	res := a[0]
	if n == 0 {
		h.a = a[:0]
		return res
	}
	x := a[n]
	a = a[:n]
	i := 0
	for {
		l := i*2 + 1
		if l >= n {
			break
		}
		r := l + 1
		c := l
		if r < n && a[r] < a[l] {
			c = r
		}
		if a[c] >= x {
			break
		}
		a[i] = a[c]
		i = c
	}
	a[i] = x
	h.a = a
	return res
}

func (h *MinHeap) Top() int {
	return h.a[0]
}

func processCase(fs *FastScanner, out *strings.Builder, q int) {
	cntL := make(map[int]int, q*2)
	cntR := make(map[int]int, q*2)
	var left MaxHeap
	var right MinHeap

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

		if op == '+' {
			cntL[l]++
			cntR[r]++
			left.Push(l)
			right.Push(r)
		} else {
			cntL[l]--
			cntR[r]--
		}

		for len(left.a) > 0 && cntL[left.Top()] == 0 {
			left.Pop()
		}
		for len(right.a) > 0 && cntR[right.Top()] == 0 {
			right.Pop()
		}

		if len(left.a) > 0 && len(right.a) > 0 && left.Top() > right.Top() {
			out.WriteString("YES\n")
		} else {
			out.WriteString("NO\n")
		}
	}
}

func main() {
	fs := NewFastScanner()
	var out strings.Builder

	first := fs.nextInt()
	if c := fs.peek(); c == '+' || c == '-' {
		processCase(fs, &out, first)
	} else {
		t := first
		for ; t > 0; t-- {
			q := fs.nextInt()
			processCase(fs, &out, q)
		}
	}

	os.Stdout.WriteString(out.String())
}