package main

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

type FastScanner struct {
	data []byte
	idx  int
	n    int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data, n: len(data)}
}

func (fs *FastScanner) NextInt64() int64 {
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c != ' ' && c != '\n' && c != '\r' && c != '\t' {
			break
		}
		fs.idx++
	}
	sign := int64(1)
	if fs.data[fs.idx] == '-' {
		sign = -1
		fs.idx++
	}
	var v int64
	for fs.idx < fs.n {
		c := fs.data[fs.idx]
		if c < '0' || c > '9' {
			break
		}
		v = v*10 + int64(c-'0')
		fs.idx++
	}
	return v * sign
}

type Edge struct {
	l   int
	r   int
	val int64
}

type Query struct {
	l   int
	r   int
	idx int
}

type BIT struct {
	n    int
	inf  int64
	tree []int64
}

func NewBIT(n int, inf int64) *BIT {
	tree := make([]int64, n+2)
	for i := range tree {
		tree[i] = inf
	}
	return &BIT{n: n, inf: inf, tree: tree}
}

func (b *BIT) Update(i int, v int64) {
	for i <= b.n {
		if v < b.tree[i] {
			b.tree[i] = v
		}
		i += i & -i
	}
}

func (b *BIT) Query(i int) int64 {
	res := b.inf
	for i > 0 {
		if b.tree[i] < res {
			res = b.tree[i]
		}
		i -= i & -i
	}
	return res
}

func main() {
	fs := NewFastScanner()
	n := int(fs.NextInt64())
	q := int(fs.NextInt64())

	x := make([]int64, n+1)
	w := make([]int64, n+1)
	for i := 1; i <= n; i++ {
		x[i] = fs.NextInt64()
		w[i] = fs.NextInt64()
	}

	prev := make([]int, n+1)
	next := make([]int, n+1)

	stack := make([]int, 0, n)
	for i := 1; i <= n; i++ {
		for len(stack) > 0 && w[stack[len(stack)-1]] > w[i] {
			stack = stack[:len(stack)-1]
		}
		if len(stack) > 0 {
			prev[i] = stack[len(stack)-1]
		}
		stack = append(stack, i)
	}

	stack = stack[:0]
	for i := n; i >= 1; i-- {
		for len(stack) > 0 && w[stack[len(stack)-1]] > w[i] {
			stack = stack[:len(stack)-1]
		}
		if len(stack) > 0 {
			next[i] = stack[len(stack)-1]
		}
		stack = append(stack, i)
	}

	edges := make([]Edge, 0, 2*n)
	for i := 1; i <= n; i++ {
		if prev[i] != 0 {
			l := prev[i]
			val := (x[i] - x[l]) * (w[i] + w[l])
			edges = append(edges, Edge{l: l, r: i, val: val})
		}
		if next[i] != 0 {
			r := next[i]
			val := (x[r] - x[i]) * (w[r] + w[i])
			edges = append(edges, Edge{l: i, r: r, val: val})
		}
	}

	queries := make([]Query, q)
	for i := 0; i < q; i++ {
		l := int(fs.NextInt64())
		r := int(fs.NextInt64())
		queries[i] = Query{l: l, r: r, idx: i}
	}

	sort.Slice(edges, func(i, j int) bool {
		return edges[i].r < edges[j].r
	})
	sort.Slice(queries, func(i, j int) bool {
		return queries[i].r < queries[j].r
	})

	const inf int64 = 1 << 62
	bit := NewBIT(n, inf)
	ans := make([]int64, q)

	p := 0
	for _, qu := range queries {
		for p < len(edges) && edges[p].r <= qu.r {
			bit.Update(n-edges[p].l+1, edges[p].val)
			p++
		}
		ans[qu.idx] = bit.Query(n - qu.l + 1)
	}

	out := make([]byte, 0, q*20)
	for i := 0; i < q; i++ {
		out = strconv.AppendInt(out, ans[i], 10)
		out = append(out, '\n')
	}
	os.Stdout.Write(out)
}