Vasya had three strings $a$, $b$ and $s$, which consist of lowercase English letters. The lengths of strings $a$ and $b$ are equal to $n$, the length of the string $s$ is equal to $m$. 

Vasya decided to choose a substring of the string $a$, then choose a substring of the string $b$ and concatenate them. Formally, he chooses a segment $[l_1, r_1]$ ($1 \leq l_1 \leq r_1 \leq n$) and a segment $[l_2, r_2]$ ($1 \leq l_2 \leq r_2 \leq n$), and after concatenation he obtains a string $a[l_1, r_1] + b[l_2, r_2] = a_{l_1} a_{l_1 + 1} \ldots a_{r_1} b_{l_2} b_{l_2 + 1} \ldots b_{r_2}$.

Now, Vasya is interested in counting number of ways to choose those segments adhering to the following conditions:

  segments $[l_1, r_1]$ and $[l_2, r_2]$ have non-empty intersection, i.e. there exists at least one integer $x$, such that $l_1 \leq x \leq r_1$ and $l_2 \leq x \leq r_2$;  the string $a[l_1, r_1] + b[l_2, r_2]$ is equal to the string $s$. 


-----Input-----

The first line contains integers $n$ and $m$ ($1 \leq n \leq 500\,000, 2 \leq m \leq 2 \cdot n$) — the length of strings $a$ and $b$ and the length of the string $s$.

The next three lines contain strings $a$, $b$ and $s$, respectively. The length of the strings $a$ and $b$ is $n$, while the length of the string $s$ is $m$.

All strings consist of lowercase English letters.


-----Output-----

Print one integer — the number of ways to choose a pair of segments, which satisfy Vasya's conditions.


-----Examples-----
Input
6 5
aabbaa
baaaab
aaaaa

Output
4

Input
5 4
azaza
zazaz
azaz

Output
11

Input
9 12
abcabcabc
xyzxyzxyz
abcabcayzxyz

Output
2



-----Note-----

Let's list all the pairs of segments that Vasya could choose in the first example:

  $[2, 2]$ and $[2, 5]$;  $[1, 2]$ and $[2, 4]$;  $[5, 5]$ and $[2, 5]$;  $[5, 6]$ and $[3, 5]$;

Difficulty: MEDIUM

Starter code:

Solutions:
import sys, logging
logging.basicConfig(level=logging.INFO)
logging.disable(logging.INFO)

def build(S, n):
	Z = [0 for i in range(3 * n + 3)]
	n = len(S)
	L = 0
	R = 0
	Z[0] = n
	for i in range(1, n):
		if i > R:
			L = R = i
			while R < n and S[R] == S[R - L]:
				R += 1
			Z[i] = R - L
			R -= 1
		else:
			k = i - L
			if Z[k] < R - i + 1:
				Z[i] = Z[k]
			else:
				L = i
				while R < n and S[R] == S[R - L]:
					R += 1
				Z[i] = R - L
				R -= 1
	return Z

def update1(n, x, val):
	while x <= n + 1:
		bit1[x] += val
		x += x & -x

def get1(n, x):
	ans = 0
	while x > 0:
		ans += bit1[x]
		x -= x & -x
	return ans

def update2(n, x, val):
	while x <= n + 1:
		bit2[x] += val
		x += x & -x

def get2(n, x):
	ans = 0
	while x > 0:
		ans += bit2[x]
		x -= x & -x
	return ans

def process(n, m, fa, fb):
	r2 = int(1)
	ans = 0
	for l1 in range(1, n + 1):
		while r2 <= min(n, l1 + m - 2):
			update1(n, m - fb[r2] + 1, 1)
			update2(n, m - fb[r2] + 1, fb[r2] - m + 1)
			r2 += 1
		ans += get1(n, fa[l1] + 1) * fa[l1] + get2(n, fa[l1] + 1)
		update1(n, m - fb[l1] + 1, -1)
		update2(n, m - fb[l1] + 1, m - 1 - fb[l1])
	print(ans)

def main():
	(n, m) = map(int, sys.stdin.readline().split())
	a = sys.stdin.readline()
	b = sys.stdin.readline()
	s = sys.stdin.readline()
	a = a[:len(a) - 1]
	b = b[:len(b) - 1]
	s = s[:len(s) - 1]
	fa = build(s + a, n)
	kb = build(s[::-1] + b[::-1], n)
	fb = [0 for k in range(n + 2)]
	for i in range(m, m + n):
		fa[i - m + 1] = fa[i]
		if fa[i - m + 1] >= m:
			fa[i - m + 1] = m - 1
		fb[m + n - i] = kb[i]
		if fb[m + n - i] >= m:
			fb[m + n - i] = m - 1
	logging.info(fa[1:n + 1])
	logging.info(fb[1:n + 1])
	process(n, m, fa, fb)
bit1 = [0 for i in range(500004)]
bit2 = [0 for i in range(500004)]
try:
	sys.stdin = open('input.txt', 'r')
	sys.stdout = open('output.txt', 'w')
except:
	pass
main()