package main

import (
	"bufio"
	"io"
	"os"
	"sort"
	"strconv"
)

type Item struct {
	c int64
	q int64
}

type Node struct {
	val int64
	sum int64
	pr  uint64
	l   *Node
	r   *Node
}

func sum(t *Node) int64 {
	if t == nil {
		return 0
	}
	return t.sum
}

func pull(t *Node) {
	if t != nil {
		t.sum = t.val + sum(t.l) + sum(t.r)
	}
}

var seed uint64 = 88172645463393265

func rnd() uint64 {
	seed ^= seed << 7
	seed ^= seed >> 9
	return seed
}

func merge(a, b *Node) *Node {
	if a == nil {
		return b
	}
	if b == nil {
		return a
	}
	if a.pr > b.pr {
		a.r = merge(a.r, b)
		pull(a)
		return a
	}
	b.l = merge(a, b.l)
	pull(b)
	return b
}

func splitBySum(t *Node, x int64) (*Node, *Node) {
	if t == nil {
		return nil, nil
	}
	ls := sum(t.l)
	if x <= ls {
		a, b := splitBySum(t.l, x)
		t.l = b
		pull(t)
		return a, t
	}
	if x <= ls+t.val {
		left := t.l
		t.l = nil
		pull(t)
		return left, t
	}
	a, b := splitBySum(t.r, x-ls-t.val)
	t.r = a
	pull(t)
	return t, b
}

func collect(t *Node, res *[]int64) {
	if t == nil {
		return
	}
	collect(t.l, res)
	*res = append(*res, t.val)
	collect(t.r, res)
}

func nextInt(data []byte, idx *int) int64 {
	n := len(data)
	for *idx < n && (data[*idx] < '0' || data[*idx] > '9') {
		*idx++
	}
	var v int64
	for *idx < n && data[*idx] >= '0' && data[*idx] <= '9' {
		v = v*10 + int64(data[*idx]-'0')
		*idx++
	}
	return v
}

func upperBound(a []int64, x int64) int {
	l, r := 0, len(a)
	for l < r {
		m := (l + r) >> 1
		if a[m] <= x {
			l = m + 1
		} else {
			r = m
		}
	}
	return l
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	idx := 0

	n := int(nextInt(data, &idx))
	items := make([]Item, n)
	for i := 0; i < n; i++ {
		c := nextInt(data, &idx)
		q := nextInt(data, &idx)
		items[i] = Item{c: c, q: q}
	}

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

	var root *Node
	for i := 0; i < n; i++ {
		left, right := splitBySum(root, items[i].c)
		node := &Node{val: items[i].c, sum: items[i].c, pr: rnd()}
		root = merge(merge(left, node), right)
	}

	seq := make([]int64, 0, n)
	collect(root, &seq)

	pref := make([]int64, n)
	var s int64
	for i := 0; i < n; i++ {
		s += seq[i]
		pref[i] = s
	}

	k := int(nextInt(data, &idx))
	out := make([]byte, 0, k*4)
	for i := 0; i < k; i++ {
		b := nextInt(data, &idx)
		ans := upperBound(pref, b)
		if i > 0 {
			out = append(out, ' ')
		}
		out = strconv.AppendInt(out, int64(ans), 10)
	}
	out = append(out, '\n')

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	w.Write(out)
	w.Flush()
}