package main

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

const MOD = 1000000007

var fact [4005]int64
var invFact [4005]int64

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 modInverse(n int64) int64 {
	return power(n, MOD-2)
}

func precompute() {
	fact[0] = 1
	invFact[0] = 1
	for i := 1; i <= 4000; i++ {
		fact[i] = (fact[i-1] * int64(i)) % MOD
	}
	invFact[4000] = modInverse(fact[4000])
	for i := 3999; i >= 1; i-- {
		invFact[i] = (invFact[i+1] * int64(i+1)) % MOD
	}
}

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

func main() {
	precompute()
	reader := bufio.NewReader(os.Stdin)
	var t int
	if _, err := fmt.Fscan(reader, &t); err != nil {
		return
	}

	for tc := 0; tc < t; tc++ {
		var n int
		fmt.Fscan(reader, &n)
		var s, t_str string
		fmt.Fscan(reader, &s, &t_str)

		sPrime := make([]byte, n)
		tPrime := make([]byte, n)
		for i := 0; i < n; i++ {
			if i%2 == 1 {
				if s[i] == '0' {
					sPrime[i] = '1'
				} else if s[i] == '1' {
					sPrime[i] = '0'
				} else {
					sPrime[i] = '?'
				}
				if t_str[i] == '0' {
					tPrime[i] = '1'
				} else if t_str[i] == '1' {
					tPrime[i] = '0'
				} else {
					tPrime[i] = '?'
				}
			} else {
				sPrime[i] = s[i]
				tPrime[i] = t_str[i]
			}
		}

		FS_pref := make([]int, n)
		QS_pref := make([]int, n)
		FT_pref := make([]int, n)
		QT_pref := make([]int, n)

		for i := 0; i < n; i++ {
			if i > 0 {
				FS_pref[i] = FS_pref[i-1]
				QS_pref[i] = QS_pref[i-1]
				FT_pref[i] = FT_pref[i-1]
				QT_pref[i] = QT_pref[i-1]
			}
			if sPrime[i] == '1' {
				FS_pref[i]++
			} else if sPrime[i] == '?' {
				QS_pref[i]++
			}
			if tPrime[i] == '1' {
				FT_pref[i]++
			} else if tPrime[i] == '?' {
				QT_pref[i]++
			}
		}

		totalAns := int64(0)

		for i := 0; i < n-1; i++ {
			Q1 := QS_pref[i] + QT_pref[i]
			K1 := QT_pref[i] - FS_pref[i] + FT_pref[i]

			QS_suff := QS_pref[n-1] - QS_pref[i]
			QT_suff := QT_pref[n-1] - QT_pref[i]
			FS_suff := FS_pref[n-1] - FS_pref[i]
			FT_suff := FT_pref[n-1] - FT_pref[i]

			Q2 := QS_suff + QT_suff
			K2 := QS_suff - FT_suff + FS_suff

			minD := -K1
			if -K2 > minD {
				minD = -K2
			}
			maxD := Q1 - K1
			if Q2-K2 < maxD {
				maxD = Q2 - K2
			}

			for d := minD; d <= maxD; d++ {
				term1 := nCr(Q1, K1+d)
				term2 := nCr(Q2, K2+d)
				absD := int64(d)
				if absD < 0 {
					absD = -absD
				}

				ways := (term1 * term2) % MOD
				ways = (ways * absD) % MOD
				totalAns = (totalAns + ways) % MOD
			}
		}

		fmt.Println(totalAns)
	}
}