package main

import (
	"bufio"
	"os"
)

const INF = 1000000000

var maxTree []int
var fTree []int
var lazy []bool

func min(a, b int) int {
	if a < b {
		return a
	}
	return b
}

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

func buildMaxTree(node, L, R int, a []int) {
	if L == R {
		maxTree[node] = a[L]
		return
	}
	mid := (L + R) / 2
	buildMaxTree(node*2, L, mid, a)
	buildMaxTree(node*2+1, mid+1, R, a)
	maxTree[node] = max(maxTree[node*2], maxTree[node*2+1])
}

func queryMaxIndex(node, L, R, qL, qR, v int) int {
	if qL > qR || L > qR || R < qL || maxTree[node] <= v {
		return 0
	}
	if L == R {
		return L
	}
	mid := (L + R) / 2
	res := queryMaxIndex(node*2+1, mid+1, R, qL, qR, v)
	if res == 0 {
		res = queryMaxIndex(node*2, L, mid, qL, qR, v)
	}
	return res
}

func buildFTree(node, L, R int) {
	fTree[node] = 0
	lazy[node] = false
	if L == R {
		return
	}
	mid := (L + R) / 2
	buildFTree(node*2, L, mid)
	buildFTree(node*2+1, mid+1, R)
}

func pushDown(node int) {
	if lazy[node] {
		fTree[node*2] = INF
		lazy[node*2] = true
		fTree[node*2+1] = INF
		lazy[node*2+1] = true
		lazy[node] = false
	}
}

func updateRange(node, L, R, qL, qR int) {
	if qL > qR || L > qR || R < qL {
		return
	}
	if qL <= L && R <= qR {
		fTree[node] = INF
		lazy[node] = true
		return
	}
	pushDown(node)
	mid := (L + R) / 2
	updateRange(node*2, L, mid, qL, qR)
	updateRange(node*2+1, mid+1, R, qL, qR)
	fTree[node] = min(fTree[node*2], fTree[node*2+1])
}

func updatePoint(node, L, R, idx, val int) {
	if L == R {
		if fTree[node] < val {
			fTree[node] = val
		}
		return
	}
	pushDown(node)
	mid := (L + R) / 2
	if idx <= mid {
		updatePoint(node*2, L, mid, idx, val)
	} else {
		updatePoint(node*2+1, mid+1, R, idx, val)
	}
	fTree[node] = min(fTree[node*2], fTree[node*2+1])
}

func queryMin(node, L, R, qL, qR int) int {
	if qL > qR || L > qR || R < qL {
		return INF
	}
	if qL <= L && R <= qR {
		return fTree[node]
	}
	pushDown(node)
	mid := (L + R) / 2
	return min(queryMin(node*2, L, mid, qL, qR), queryMin(node*2+1, mid+1, R, qL, qR))
}

func readInt(in *bufio.Reader) int {
	var x int
	var c byte
	var err error
	for {
		c, err = in.ReadByte()
		if err != nil {
			return 0
		}
		if c >= '0' && c <= '9' {
			break
		}
	}
	x = int(c - '0')
	for {
		c, err = in.ReadByte()
		if err != nil {
			break
		}
		if c >= '0' && c <= '9' {
			x = x*10 + int(c-'0')
		} else {
			break
		}
	}
	return x
}

type Query struct {
	l, id int
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	n := readInt(in)
	if n == 0 {
		return
	}

	a := make([]int, n+1)
	for i := 1; i <= n; i++ {
		a[i] = readInt(in)
	}

	q := readInt(in)
	queries := make([][]Query, n+1)
	for i := 0; i < q; i++ {
		l := readInt(in)
		r := readInt(in)
		queries[r] = append(queries[r], Query{l, i})
	}

	maxTree = make([]int, 4*n+1)
	fTree = make([]int, 4*n+1)
	lazy = make([]bool, 4*n+1)

	buildMaxTree(1, 1, n, a)
	buildFTree(1, 1, n)

	ans := make([]bool, q)
	stack := make([]int, 0, n)

	for r := 1; r <= n; r++ {
		for len(stack) > 0 && a[stack[len(stack)-1]] > a[r] {
			stack = stack[:len(stack)-1]
		}
		y := 0
		if len(stack) > 0 {
			y = stack[len(stack)-1]
		}
		stack = append(stack, r)

		if y+1 <= r-1 {
			updateRange(1, 1, n, y+1, r-1)
		}
		if y >= 1 {
			X := queryMaxIndex(1, 1, n, 1, y-1, a[r])
			updatePoint(1, 1, n, y, X+1)
		}

		for _, qry := range queries[r] {
			minF := queryMin(1, 1, n, qry.l, r-1)
			if minF <= qry.l {
				ans[qry.id] = true
			} else {
				ans[qry.id] = false
			}
		}
	}

	for i := 0; i < q; i++ {
		if ans[i] {
			out.WriteString("Yes\n")
		} else {
			out.WriteString("No\n")
		}
	}
}