```go
package main

import (
	"io"
	"os"
	"strconv"
)

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

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

func updateI32(seg []int32, size, pos int, val int32) {
	i := size + pos - 1
	seg[i] = val
	for i >>= 1; i > 0; i >>= 1 {
		if seg[i<<1] > seg[i<<1|1] {
			seg[i] = seg[i<<1]
		} else {
			seg[i] = seg[i<<1|1]
		}
	}
}

func queryMaxI32(seg []int32, size, l, r int) int32 {
	var res int32
	l += size - 1
	r += size - 1
	for l <= r {
		if l&1 == 1 {
			if seg[l] > res {
				res = seg[l]
			}
			l++
		}
		if r&1 == 0 {
			if seg[r] > res {
				res = seg[r]
			}
			r--
		}
		l >>= 1
		r >>= 1
	}
	return res
}

func queryMaxI64(seg []int64, size, l, r int) int64 {
	var res int64
	l += size - 1
	r += size - 1
	for l <= r {
		if l&1 == 1 {
			if seg[l] > res {
				res = seg[l]
			}
			l++
		}
		if r&1 == 0 {
			if seg[r] > res {
				res = seg[r]
			}
			r--
		}
		l >>= 1
		r >>= 1
	}
	return res
}

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

	n := int(nextInt(data, &idx))
	p := make([]int64, n+1)
	a := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		pi := nextInt(data, &idx)
		li := nextInt(data, &idx)
		p[i] = pi
		a[i] = pi + li
	}

	size := 1
	for size < n {
		size <<= 1
	}

	segR := make([]int32, size<<1)
	R := make([]int32, n+2)

	for i := n; i >= 1; i-- {
		ri := upperBound(p, n, a[i])
		val := int32(ri)
		if i+1 <= ri {
			mx := queryMaxI32(segR, size, i+1, ri)
			if mx > val {
				val = mx
			}
		}
		R[i] = val
		updateI32(segR, size, i, val)
	}

	segA := make([]int64, size<<1)
	for i := 1; i <= n; i++ {
		segA[size+i-1] = a[i]
	}
	for i := size - 1; i >= 1; i-- {
		if segA[i<<1] > segA[i<<1|1] {
			segA[i] = segA[i<<1]
		} else {
			segA[i] = segA[i<<1|1]
		}
	}

	K := 1
	for (1 << K) <= n+1 {
		K++
	}

	up := make([][]int32, K)
	mx := make([][]int32, K)
	sum := make([][]int64, K)
	for k := 0; k < K; k++ {
		up[k] = make([]int32, n+2)
		mx[k] = make([]int32, n+2)
		sum[k] = make([]int64, n+2)
	}

	sentinel := n + 1
	up[0][sentinel] = int32(sentinel)
	mx[0][sentinel] = int32(sentinel)

	for i := 1; i <= n; i++ {
		up[0][i] = R[i] + 1
		mx[0][i] = R[i]
		if R[i] < int32(n) {
			best := queryMaxI64(segA, size, i, int(R[i]))
			sum[0][i] = p[int(R[i])+1] - best
		}
	}

	for k := 1; k < K; k++ {
		upPrev := up[k-1]
		mxPrev := mx[k-1]
		sumPrev := sum[k-1]
		upCur := up[k]
		mxCur := mx[k]
		sumCur := sum[k]
		for i := 1; i <= n+1; i++ {
			mid := int(upPrev[i])
			upCur[i] = upPrev[mid]
			mxCur[i] = mxPrev[mid]
			sumCur[i] = sumPrev[i] + sumPrev[mid]
		}
	}

	q := int(nextInt(data, &idx))
	out := make([]byte, 0, q*16)

	for ; q > 0; q-- {
		x := int(nextInt(data, &idx))
		y := int32(nextInt(data, &idx))
		cur := x
		var ans int64
		for k := K - 1; k >= 0; k-- {
			if mx[k][cur] < y {
				ans += sum[k][cur]
				cur = int(up[k][cur])
			}
		}
		out = strconv.AppendInt(out, ans, 10)
		out = append(out, '\n')
	}

	_, _ = os.Stdout.Write(out)
}
```