```go
package main

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

type FastScanner struct {
	r   *bufio.Reader
	buf [8192]byte
	idx int
	n   int
}

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

func (fs *FastScanner) NextInt() int {
	for {
		if fs.idx >= fs.n {
			fs.n, _ = fs.r.Read(fs.buf[:])
			fs.idx = 0
		}
		if fs.idx < fs.n && fs.buf[fs.idx] >= '0' {
			break
		}
		fs.idx++
	}
	val := 0
	for fs.idx < fs.n && fs.buf[fs.idx] >= '0' {
		val = val*10 + int(fs.buf[fs.idx]-'0')
		fs.idx++
	}
	return val
}

type SubQuery struct {
	l, r int
	k    int64
	idx  int
	sign int64
}

func main() {
	fs := NewFastScanner()
	n := fs.NextInt()
	m := fs.NextInt()

	dist := make([]int64, n+1)
	for i := 1; i < n; i++ {
		w := int64(fs.NextInt())
		v := i + 1
		parent := v / 2
		dist[v] = dist[parent] + w
	}

	tin := make([]int, n+1)
	tout := make([]int, n+1)
	euler := make([]int, n+1)
	timer := 0

	type StackItem struct {
		u     int
		state int
	}
	stack := []StackItem{{1, 0}}

	for len(stack) > 0 {
		top := &stack[len(stack)-1]
		u := top.u
		if top.state == 0 {
			timer++
			tin[u] = timer
			euler[timer] = u
			top.state = 1
			if 2*u+1 <= n {
				stack = append(stack, StackItem{2*u + 1, 0})
			}
			if 2*u <= n {
				stack = append(stack, StackItem{2*u, 0})
			}
		} else {
			tout[u] = timer
			stack = stack[:len(stack)-1]
		}
	}

	elements := make([]struct {
		val int64
		pos int
	}, n)
	for i := 1; i <= n; i++ {
		elements[i-1] = struct {
			val int64
			pos int
		}{dist[euler[i]], i}
	}
	sort.Slice(elements, func(i, j int) bool {
		return elements[i].val < elements[j].val
	})

	maxSub := m * 40
	subQueries := make([]SubQuery, 0, maxSub)
	answers := make([]int64, m)

	for q := 0; q < m; q++ {
		A := fs.NextInt()
		H := int64(fs.NextInt())
		cur := A
		prev := 0
		for cur > 0 {
			K := H - dist[A] + 2*dist[cur]
			if K < 0 {
				break
			}
			l, r := tin[cur], tout[cur]
			subQueries = append(subQueries, SubQuery{l, r, K, q, 1})
			if prev != 0 {
				l2, r2 := tin[prev], tout[prev]
				subQueries = append(subQueries, SubQuery{l2, r2, K, q, -1})
			}
			prev = cur
			cur = cur / 2
		}
	}

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

	bitCnt := make([]int, n+2)
	bitSum := make([]int64, n+2)

	add := func(idx int, c int, s int64) {
		for idx <= n {
			bitCnt[idx] += c
			bitSum[idx] += s
			idx += idx & -idx
		}
	}

	query := func(idx int) (int, int64) {
		var c int
		var s int64
		for idx > 0 {
			c += bitCnt[idx]
			s += bitSum[idx]
			idx -= idx & -idx
		}
		return c, s
	}

	rangeQuery := func(l, r int) (int, int64) {
		if l > r {
			return 0, 0
		}
		c1, s1 := query(r)
		c2, s2 := query(l - 1)
		return c1 - c2, s1 - s2
	}

	ptr := 0
	for _, sq := range subQueries {
		for ptr < n && elements[ptr].val < sq.k {
			add(elements[ptr].pos, 1, elements[ptr].val)
			ptr++
		}
		cnt, sum := rangeQuery(sq.l, sq.r)
		answers[sq.idx] += sq.sign * (sq.k*int64(cnt) - sum)
	}

	writer := bufio.NewWriter(os.Stdout)
	for i := 0; i < m; i++ {
		writer.WriteString(strconv.FormatInt(answers[i], 10))
		writer.WriteByte('\n')
	}
	writer.Flush()
}
```