```go
package main

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

type FastScanner struct {
	r *bufio.Reader
}

func NewFastScanner() *FastScanner {
	return &FastScanner{r: bufio.NewReader(os.Stdin)}
}

func (fs *FastScanner) NextInt() int {
	sign := 1
	val := 0
	b, _ := fs.r.ReadByte()
	for (b < '0' || b > '9') && b != '-' {
		b, _ = fs.r.ReadByte()
	}
	if b == '-' {
		sign = -1
		b, _ = fs.r.ReadByte()
	}
	for b >= '0' && b <= '9' {
		val = val*10 + int(b-'0')
		b, _ = fs.r.ReadByte()
	}
	return val * sign
}

type BIT struct {
	n int
	t []int64
}

func NewBIT(n int) *BIT {
	return &BIT{n: n, t: make([]int64, n+5)}
}
func (b *BIT) Add(i int, v int64) {
	for i <= b.n {
		b.t[i] += v
		i += i & -i
	}
}
func (b *BIT) Sum(i int) int64 {
	res := int64(0)
	for i > 0 {
		res += b.t[i]
		i -= i & -i
	}
	return res
}
func (b *BIT) Range(l, r int) int64 {
	if r < l {
		return 0
	}
	return b.Sum(r) - b.Sum(l-1)
}

func main() {
	in := NewFastScanner()
	n := in.NextInt()
	g := make([][]int, n+1)
	for i := 0; i < n-1; i++ {
		u := in.NextInt()
		v := in.NextInt()
		g[u] = append(g[u], v)
		g[v] = append(g[v], u)
	}
	// Root the tree at 1, build children lists
	parent := make([]int, n+1)
	children := make([][]int, n+1)
	order := make([]int, 0, n)
	st := make([]int, 0, n)
	st = append(st, 1)
	parent[1] = 0
	for len(st) > 0 {
		u := st[len(st)-1]
		st = st[:len(st)-1]
		order = append(order, u)
		for _, v := range g[u] {
			if v == parent[u] {
				continue
			}
			parent[v] = u
			children[u] = append(children[u], v)
			st = append(st, v)
		}
	}
	// Euler tour tin/tout and postorder computation of maxdesc
	tin := make([]int, n+1)
	tout := make([]int, n+1)
	eul := make([]int, 0, n)
	type frame struct {
		u, it int
	}
	stack := make([]frame, 0, n*2)
	stack = append(stack, frame{1, -1})
	time := 0
	for len(stack) > 0 {
		top := &stack[len(stack)-1]
		if top.it == -1 {
			u := top.u
			time++
			tin[u] = time
			eul = append(eul, u)
			top.it = 0
		}
		u := top.u
		if top.it < len(children[u]) {
			v := children[u][top.it]
			top.it++
			stack = append(stack, frame{v, -1})
		} else {
			tout[u] = time
			stack = stack[:len(stack)-1]
		}
	}
	deg := make([]int, n+1)
	w := make([]int, n+1)
	for u := 1; u <= n; u++ {
		deg[u] = len(children[u])
		w[u] = deg[u] - 1
	}
	// maxdesc_inclusive[u] = max w[z] over subtree(u), including u
	maxdesc := make([]int, n+1)
	for i := 0; i < n; i++ {
		maxdesc[i+1] = -1 << 30
	}
	// postorder via reversed order
	for i := n - 1; i >= 0; i-- {
		u := order[i]
		mx := w[u]
		for _, v := range children[u] {
			if maxdesc[v] > mx {
				mx = maxdesc[v]
			}
		}
		maxdesc[u] = mx
	}
	// For each node, sort its children by sup=maxdesc[child] descending
	sortedChildren := make([][]int, n+1)
	for v := 1; v <= n; v++ {
		ch := children[v]
		if len(ch) == 0 {
			continue
		}
		ids := make([]int, len(ch))
		copy(ids, ch)
		sort.Slice(ids, func(i, j int) bool {
			return maxdesc[ids[i]] > maxdesc[ids[j]]
		})
		sortedChildren[v] = ids
	}
	type Query struct {
		v, k, idx int
	}
	q := in.NextInt()
	qs := make([]Query, q)
	maxK := 0
	for i := 0; i < q; i++ {
		v := in.NextInt()
		k := in.NextInt()
		qs[i] = Query{v: v, k: k, idx: i}
		if k > maxK {
			maxK = k
		}
	}
	sort.Slice(qs, func(i, j int) bool {
		if qs[i].k == qs[j].k {
			return qs[i].v < qs[j].v
		}
		return qs[i].k > qs[j].k
	})
	// Nodes sorted by w descending
	nodes := make([]int, n)
	for i := 1; i <= n; i++ {
		nodes[i-1] = i
	}
	sort.Slice(nodes, func(i, j int) bool { return w[nodes[i]] > w[nodes[j]] })
	bitCnt := NewBIT(n + 2)
	bitSum := NewBIT(n + 2)
	ptr := 0
	ans := make([]int64, q)
	for _, qu := range qs {
		k := qu.k
		for ptr < n && w[nodes[ptr]] > k {
			u := nodes[ptr]
			bitCnt.Add(tin[u], 1)
			bitSum.Add(tin[u], int64(w[u]))
			ptr++
		}
		v := qu.v
		res := int64(deg[v])
		ch := sortedChildren[v]
		if len(ch) > 0 {
			// binary search count of children with maxdesc>k
			l, r := 0, len(ch)
			for l < r {
				m := (l + r) >> 1
				if maxdesc[ch[m]] > k {
					l = m + 1
				} else {
					r = m
				}
			}
			cntCh := l
			for i := 0; i < cntCh; i++ {
				u := ch[i]
				// strict descendants range
				lr := tin[u] + 1
				rr := tout[u]
				var cnt int64 = 0
				var sumw int64 = 0
				if lr <= rr {
					cnt = bitCnt.Range(lr, rr)
					sumw = bitSum.Range(lr, rr)
				}
				val := int64(w[u]-k) + (sumw - int64(k)*cnt)
				if val > 0 {
					res += val
				}
			}
		}
		ans[qu.idx] = res
	}
	out := bufio.NewWriter(os.Stdout)
	for i := 0; i < q; i++ {
		fmt.Fprintln(out, ans[i])
	}
	out.Flush()
}
```