```go
package main

import (
	"bufio"
	"os"
	"strconv"
)

const M1 uint64 = 1000000007
const M2 uint64 = 1000000009
const B1 uint64 = 313
const B2 uint64 = 317

var pow1 [100005]uint64
var pow2 [100005]uint64

func initHash() {
	pow1[0] = 1
	pow2[0] = 1
	for i := 1; i <= 100002; i++ {
		pow1[i] = (pow1[i-1] * B1) % M1
		pow2[i] = (pow2[i-1] * B2) % M2
	}
}

type Node struct {
	len_O   int32
	len_C   int32
	left    int32
	right   int32
	hash_O1 uint64
	hash_O2 uint64
	hash_C1 uint64
	hash_C2 uint64
	canc1   uint64
	canc2   uint64
	valid   bool
}

const MAX_NODES = 400100

var nodes [MAX_NODES]Node
var pool_cnt int32

type Hash struct {
	h1 uint64
	h2 uint64
}

func get_prefix_O(idx int32, k int32) Hash {
	if k == 0 {
		return Hash{0, 0}
	}
	node := &nodes[idx]
	if node.len_O == k {
		return Hash{node.hash_O1, node.hash_O2}
	}
	L_idx := node.left
	R_idx := node.right

	m := nodes[L_idx].len_O
	if nodes[R_idx].len_C < m {
		m = nodes[R_idx].len_C
	}

	if k <= nodes[R_idx].len_O {
		return get_prefix_O(R_idx, k)
	} else {
		X := k - nodes[R_idx].len_O
		h1 := get_prefix_O(L_idx, m+X)
		h2_h1 := node.canc1
		h2_h2 := node.canc2

		val1 := (h1.h1 + M1 - (h2_h1*pow1[X])%M1) % M1
		val2 := (h1.h2 + M2 - (h2_h2*pow2[X])%M2) % M2

		res1 := (nodes[R_idx].hash_O1 + val1*pow1[nodes[R_idx].len_O]) % M1
		res2 := (nodes[R_idx].hash_O2 + val2*pow2[nodes[R_idx].len_O]) % M2
		return Hash{res1, res2}
	}
}

func get_prefix_C(idx int32, k int32) Hash {
	if k == 0 {
		return Hash{0, 0}
	}
	node := &nodes[idx]
	if node.len_C == k {
		return Hash{node.hash_C1, node.hash_C2}
	}
	L_idx := node.left
	R_idx := node.right

	m := nodes[L_idx].len_O
	if nodes[R_idx].len_C < m {
		m = nodes[R_idx].len_C
	}

	if k <= nodes[L_idx].len_C {
		return get_prefix_C(L_idx, k)
	} else {
		X := k - nodes[L_idx].len_C
		h1 := get_prefix_C(R_idx, m+X)
		h2_h1 := node.canc1
		h2_h2 := node.canc2

		val1 := (h1.h1 + M1 - (h2_h1*pow1[X])%M1) % M1
		val2 := (h1.h2 + M2 - (h2_h2*pow2[X])%M2) % M2

		res1 := (nodes[L_idx].hash_C1 + val1*pow1[nodes[L_idx].len_C]) % M1
		res2 := (nodes[L_idx].hash_C2 + val2*pow2[nodes[L_idx].len_C]) % M2
		return Hash{res1, res2}
	}
}

func merge_nodes(idx int32, left_idx int32, right_idx int32) {
	node := &nodes[idx]
	L := &nodes[left_idx]
	R := &nodes[right_idx]

	node.left = left_idx
	node.right = right_idx

	if !L.valid || !R.valid {
		node.valid = false
		return
	}

	m := L.len_O
	if R.len_C < m {
		m = R.len_C
	}

	if m > 0 {
		hO := get_prefix_O(left_idx, m)
		hC := get_prefix_C(right_idx, m)
		if hO.h1 != hC.h1 || hO.h2 != hC.h2 {
			node.valid = false
			return
		}
		node.canc1 = hO.h1
		node.canc2 = hO.h2
	} else {
		node.canc1 = 0
		node.canc2 = 0
	}

	node.valid = true
	node.len_O = L.len_O - m + R.len_O
	node.len_C = L.len_C + R.len_C - m

	if L.len_O > m {
		X := L.len_O - m
		val1 := (L.hash_O1 + M1 - (node.canc1*pow1[X])%M1) % M1
		val2 := (L.hash_O2 + M2 - (node.canc2*pow2[X])%M2) % M2
		node.hash_O1 = (R.hash_O1 + val1*pow1[R.len_O]) % M1
		node.hash_O2 = (R.hash_O2 + val2*pow2[R.len_O]) % M2
	} else {
		node.hash_O1 = R.hash_O1
		node.hash_O2 = R.hash_O2
	}

	if R.len_C > m {
		X := R.len_C - m
		val1 := (R.hash_C1 + M1 - (node.canc1*pow1[X])%M1) % M1
		val2 := (R.hash_C2 + M2 - (node.canc2*pow2[X])%M2) % M2
		node.hash_C1 = (L.hash_C1 + val1*pow1[L.len_C]) % M1
		node.hash_C2 = (L.hash_C2 + val2*pow2[L.len_C]) % M2
	} else {
		node.hash_C1 = L.hash_C1
		node.hash_C2 = L.hash_C2
	}
}

func build(v int32, tl int32, tr int32, s []int) {
	if tl == tr {
		nodes[v].left = 0
		nodes[v].right = 0
		nodes[v].valid = true
		nodes[v].canc1 = 0
		nodes[v].canc2 = 0
		val := s[tl]
		if val > 0 {
			nodes[v].len_O = 1
			nodes[v].len_C = 0
			nodes[v].hash_O1 = uint64(val)
			nodes[v].hash_O2 = uint64(val)
			nodes[v].hash_C1 = 0
			nodes[v].hash_C2 = 0
		} else {
			nodes[v].len_O = 0
			nodes[v].len_C = 1
			nodes[v].hash_O1 = 0
			nodes[v].hash_O2 = 0
			nodes[v].hash_C1 = uint64(-val)
			nodes[v].hash_C2 = uint64(-val)
		}
		return
	}
	tm := (tl + tr) / 2
	build(v*2, tl, tm, s)
	build(v*2+1, tm+1, tr, s)
	merge_nodes(v, v*2, v*2+1)
}

func update(v int32, tl int32, tr int32, pos int32, val int) {
	if tl == tr {
		if val > 0 {
			nodes[v].len_O = 1
			nodes[v].len_C = 0
			nodes[v].hash_O1 = uint64(val)
			nodes[v].hash_O2 = uint64(val)
			nodes[v].hash_C1 = 0
			nodes[v].hash_C2 = 0
		} else {
			nodes[v].len_O = 0
			nodes[v].len_C = 1
			nodes[v].hash_O1 = 0
			nodes[v].hash_O2 = 0
			nodes[v].hash_C1 = uint64(-val)
			nodes[v].hash_C2 = uint64(-val)
		}
		return
	}
	tm := (tl + tr) / 2
	if pos <= tm {
		update(v*2, tl, tm, pos, val)
	} else {
		update(v*2+1, tm+1, tr, pos, val)
	}
	merge_nodes(v, v*2, v*2+1)
}

func query(v int32, tl int32, tr int32, l int32, r int32) int32 {
	if l > tr || r < tl {
		return 0
	}
	if l <= tl && tr <= r {
		return v
	}
	tm := (tl + tr) / 2
	left_res := query(v*2, tl, tm, l, r)
	right_res := query(v*2+1, tm+1, tr, l, r)

	if left_res == 0 {
		return right_res
	}
	if right_res == 0 {
		return left_res
	}

	pool_cnt++
	idx := pool_cnt
	merge_nodes(idx, left_res, right_res)
	return idx
}

func main() {
	initHash()

	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 10*1024*1024)

	scanInt := func() int {
		scanner.Scan()
		res, _ := strconv.Atoi(scanner.Text())
		return res
	}

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())
	scanInt() 

	s := make([]int, n+1)
	for i := 1; i <= n; i++ {
		s[i] = scanInt()
	}

	build(1, 1, int32(n), s)

	q := scanInt()
	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	for i := 0; i < q; i++ {
		typ := scanInt()
		if typ == 1 {
			pos := scanInt()
			val := scanInt()
			update(1, 1, int32(n), int32(pos), val)
		} else {
			l := scanInt()
			r := scanInt()
			pool_cnt = 400005
			res := query(1, 1, int32(n), int32(l), int32(r))
			if nodes[res].valid && nodes[res].len_O == 0 && nodes[res].len_C == 0 {
				writer.WriteString("Yes\n")
			} else {
				writer.WriteString("No\n")
			}
		}
	}
}
```