package main

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

const MOD = 1000000007

var fact []int32
var invFact []int32
var pow2 []int32
var invPow2 []int32

func init() {
	MAX := 10000005
	fact = make([]int32, MAX)
	invFact = make([]int32, MAX)
	pow2 = make([]int32, MAX)
	invPow2 = make([]int32, 5000005)

	fact[0] = 1
	invFact[0] = 1
	pow2[0] = 1
	invPow2[0] = 1

	inv2 := int64(500000004)

	for i := 1; i < MAX; i++ {
		fact[i] = int32((int64(fact[i-1]) * int64(i)) % MOD)
		pow2[i] = int32((int64(pow2[i-1]) * 2) % MOD)
	}

	for i := 1; i < 5000005; i++ {
		invPow2[i] = int32((int64(invPow2[i-1]) * inv2) % MOD)
	}

	invFact[MAX-1] = int32(power(int64(fact[MAX-1]), MOD-2))
	for i := MAX - 2; i >= 1; i-- {
		invFact[i] = int32((int64(invFact[i+1]) * int64(i+1)) % MOD)
	}
}

func power(base, exp int64) int64 {
	res := int64(1)
	base %= MOD
	for exp > 0 {
		if exp%2 == 1 {
			res = (res * base) % MOD
		}
		base = (base * base) % MOD
		exp /= 2
	}
	return res
}

func binom(n, k int) int64 {
	if k < 0 || k > n {
		return 0
	}
	return int64(fact[n]) * int64(invFact[k]) % MOD * int64(invFact[n-k]) % MOD
}

func f(n, k int) int64 {
	if k == 0 {
		if n == 0 {
			return 1
		}
		return 0
	}
	ans := int64(0)
	limit := n
	if k < limit {
		limit = k
	}
	for j := 0; j <= limit; j++ {
		term := binom(k, j)
		term = term * int64(invPow2[j]) % MOD
		term = term * binom(n-j+k-1, k-1) % MOD
		if j%2 == 1 {
			ans -= term
			if ans < 0 {
				ans += MOD
			}
		} else {
			ans += term
			if ans >= MOD {
				ans -= MOD
			}
		}
	}
	ans = ans * int64(pow2[n+k]) % MOD
	return ans
}

func main() {
	scanner := bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	buf := make([]byte, 1024*1024)
	scanner.Buffer(buf, 1024*1024)

	scanInt := func() int {
		scanner.Scan()
		res := 0
		for _, b := range scanner.Bytes() {
			res = res*10 + int(b-'0')
		}
		return res
	}

	if !scanner.Scan() {
		return
	}
	t_bytes := scanner.Bytes()
	t := 0
	for _, b := range t_bytes {
		t = t*10 + int(b-'0')
	}

	writer := bufio.NewWriter(os.Stdout)
	defer writer.Flush()

	inv2 := int64(500000004)
	inv4 := int64(250000002)

	for i := 0; i < t; i++ {
		n := scanInt()
		m := scanInt()
		if n > m {
			n, m = m, n
		}

		term1 := f(n, m+2)
		term1 = term1 * int64(m+1) % MOD
		term1 = term1 * inv4 % MOD

		term2 := f(n, m+1)
		term2 = term2 * int64(m) % MOD
		term2 = term2 * inv2 % MOD

		term3 := f(n, m)
		term3 = term3 * int64(m-1) % MOD
		term3 = term3 * inv4 % MOD

		ans := term1 - term2
		if ans < 0 {
			ans += MOD
		}
		ans += term3
		if ans >= MOD {
			ans -= MOD
		}

		fmt.Fprintln(writer, ans)
	}
}