```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

type BIT struct {
	n int
	f []int
}

func NewBIT(n int) *BIT {
	return &BIT{n: n, f: make([]int, n+2)}
}
func (b *BIT) Add(i, v int) {
	for i <= b.n {
		b.f[i] += v
		i += i & -i
	}
}
func (b *BIT) Sum(i int) int {
	s := 0
	for i > 0 {
		s += b.f[i]
		i -= i & -i
	}
	return s
}
func (b *BIT) Kth(k int) int {
	idx := 0
	bit := 1
	for bit<<1 <= b.n {
		bit <<= 1
	}
	for bit > 0 {
		nxt := idx + bit
		if nxt <= b.n && b.f[nxt] < k {
			k -= b.f[nxt]
			idx = nxt
		}
		bit >>= 1
	}
	return idx + 1
}

type Item struct {
	val int
	idx int
}

type Query struct {
	k   int
	pos int
	id  int
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

	var n int
	fmt.Fscan(in, &n)
	a := make([]int, n+1)
	items := make([]Item, n)
	for i := 1; i <= n; i++ {
		fmt.Fscan(in, &a[i])
		items[i-1] = Item{val: a[i], idx: i}
	}

	sort.Slice(items, func(i, j int) bool {
		if items[i].val != items[j].val {
			return items[i].val > items[j].val
		}
		return items[i].idx < items[j].idx
	})

	var m int
	fmt.Fscan(in, &m)
	qs := make([]Query, m)
	for i := 0; i < m; i++ {
		fmt.Fscan(in, &qs[i].k, &qs[i].pos)
		qs[i].id = i
	}

	sort.Slice(qs, func(i, j int) bool {
		return qs[i].k < qs[j].k
	})

	bit := NewBIT(n)
	ans := make([]int, m)

	p := 0
	for _, q := range qs {
		for p < q.k {
			bit.Add(items[p].idx, 1)
			p++
		}
		idx := bit.Kth(q.pos)
		ans[q.id] = a[idx]
	}

	for i := 0; i < m; i++ {
		fmt.Fprintln(out, ans[i])
	}
}
```