package main

import (
	"io"
	"os"
)

type Fenwick struct {
	tree []int
	n    int
}

func NewFenwick(n int) *Fenwick {
	return &Fenwick{
		tree: make([]int, n+1),
		n:    n,
	}
}

func (fw *Fenwick) Add(i, delta int) {
	for ; i <= fw.n; i += i & -i {
		fw.tree[i] += delta
	}
}

func (fw *Fenwick) Query(i int) int {
	sum := 0
	for ; i > 0; i -= i & -i {
		sum += fw.tree[i]
	}
	return sum
}

func main() {
	in := readAll(os.Stdin)
	pos := 0

	nextInt := func() int {
		for pos < len(in) && in[pos] <= ' ' {
			pos++
		}
		if pos >= len(in) {
			return 0
		}
		res := 0
		for pos < len(in) && in[pos] > ' ' {
			res = res*10 + int(in[pos]-'0')
			pos++
		}
		return res
	}

	t := nextInt()
	if t == 0 {
		return
	}

	out := make([]byte, 0, 64*t)
	var formatInt = func(n int64) {
		if n == 0 {
			out = append(out, '0', '\n')
			return
		}
		var buf [20]byte
		i := 19
		for n > 0 {
			buf[i] = byte(n%10) + '0'
			n /= 10
			i--
		}
		out = append(out, buf[i+1:]...)
		out = append(out, '\n')
	}

	MOD := int64(998244353)
	M := 20

	for tc := 0; tc < t; tc++ {
		n := nextInt()
		k := nextInt()

		p := make([]int, n)
		for i := 0; i < n; i++ {
			p[i] = nextInt()
		}

		q := make([]int, k)
		for i := 0; i < k; i++ {
			q[i] = nextInt()
		}

		fwQ := NewFenwick(k)
		var invQ int64 = 0
		for i := 0; i < k; i++ {
			val := q[i] + 1
			invQ += int64(i - fwQ.Query(val))
			fwQ.Add(val, 1)
		}
		invQ %= MOD
		ans := (invQ * int64(n)) % MOD

		var W0 int64 = 0
		if k-1 >= M {
			terms := int64(k - M)
			W0 = (terms % MOD) * ((terms + 1) % MOD) % MOD
			W0 = (W0 * 499122177) % MOD
		}
		pairs := (int64(n) * int64(n-1) / 2) % MOD
		ans = (ans + W0*pairs) % MOD

		fwP := NewFenwick(2 * n)
		minD := -k + 1
		if minD < -M+1 {
			minD = -M + 1
		}
		maxD := k - 1
		if maxD > M-1 {
			maxD = M - 1
		}

		for i := n - 1; i >= 0; i-- {
			x := p[i]
			for d := minD; d <= maxD; d++ {
				var target int
				if d >= 0 {
					target = (x - 1) >> d
				} else {
					shift := -d
					tVal := (int64(x) << shift) - 1
					if tVal > int64(2*n) {
						target = 2 * n
					} else {
						target = int(tVal)
					}
				}
				if target > 0 {
					count := fwP.Query(target)
					if count > 0 {
						weight := k - d
						if d < 0 {
							weight = k + d
						}
						ans = (ans + int64(count)*int64(weight)) % MOD
					}
				}
			}
			fwP.Add(x, 1)
		}

		formatInt(ans)
	}
	os.Stdout.Write(out)
}

func readAll(r io.Reader) []byte {
	b, _ := io.ReadAll(r)
	return b
}