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: interview

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)]
    #logging.info(S)
    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)]

def __starting_point():
    try:
        sys.stdin = open('input.txt', 'r')
        sys.stdout = open('output.txt', 'w')
    except:
        pass
    main()
__starting_point()