#include <cstdio>
#include <cstring>
#include <algorithm>
#include <numeric>
#include <vector>
#include <queue>
#include <map>
#include <cmath>
#include <cctype>
#include <set>

namespace uvu
{
// #define LOCAL ____________DONT_DEFINE_ME____________
#define ll long long
#define inf 0x3f3f3f3f
// #define int long long
// #define inf 0x3f3f3f3f3f3f3f3fll
#define infll 0x3f3f3f3f3f3f3f3fll
#define debug(...) fprintf(stderr, __VA_ARGS__)
#define gline debug("now is #%d\n", __LINE__)
#define pii std::pair <int, int>
#define mkp std::make_pair
#define fi first
#define se second
char _ST_;
const int BUFSIZE = (1 << 20);
char ibuf[BUFSIZE], *iS = ibuf, *iT = ibuf;
char obuf[BUFSIZE], *oS = obuf, *oT = obuf + BUFSIZE;
char getc()
{
#ifdef LOCAL
	return getchar();
#else
	if(iS == iT) iT = (iS = ibuf) + fread(ibuf, 1, BUFSIZE, stdin);
	return iS == iT ? EOF : *iS++;
#endif
#define getchar ERR
}

void Flush() { fwrite(obuf, 1, oS - obuf, stdout); oS = obuf; }
struct Flusher { ~Flusher(){ Flush(); } }iamflusher;

void putc(char c)
{
#ifdef LOCAL
	putchar(c);
#else
	*oS++ = c;
	if(oS == oT) Flush();
#endif
#define putchar ERR
}

template <typename T = int> T read()
{
	T x = 0, f = 1; char c = getc();
	for(; !isdigit(c); c = getc()) if(c == '-') f = -1;
	for(;  isdigit(c); c = getc()) x = (x << 3) + (x << 1) + (c ^ 48);
	return x * f;
}

template <typename T> void print(T x, char c)
{
static int sta[BUFSIZE], top;
	top = 0;
	if(x < 0) putc('-'), x = -x;
	if(!x) sta[top = 1] = 0;
	for(; x; x /= 10) sta[++top] = x % 10;
	for(; top; ) putc(sta[top--] ^ 48);
	if(c) putc(c);
}

int readstr(char *s, int base)
{
	int idx = base - 1; char c = getc();
	for(; !(isdigit(c) || isalpha(c) || c == '#' || c == '.'); c = getc());
	for(;   isdigit(c) || isalpha(c) || c == '#' || c == '.' ; c = getc()) s[++idx] = c;
	return idx - base + 1;
}

void printf(const char *s) { for(; *s; s++) putc(*s); }
template <typename T, typename ... Args>
void printf(const char *s, T x, Args ... rest)
{
	for(; *s; s++)
	{
		if(*s != '%') { putc(*s); continue; }
		s++; if(*s == 'd') print(x, 0);
		else if(*s == 'c') putc(x);
		printf(s + 1, rest ...);
		return;
	}
}

template <typename T> void ckmax(T &x, T y) { x = x > y ? x : y; }
template <typename T> void ckmin(T &x, T y) { x = x < y ? x : y; }
#define mod 998244353
// #define mod 1000000007
int sm(int x) { return x >= mod ? x - mod : x; }
void plus_(int &x, int y) { x = sm(x + y); }
void mul_(int &x, int y) { x = 1ll * x * y % mod; }
int ksm(int a, int b) { int res = 1; for(; b; b >>= 1, mul_(a, a)) if(b & 1) mul_(res, a); return res; }

#define N 1000010
int n, lx_[N], rx_[N];
int m, ly_[N], ry_[N];
char s[N], t[N], str[N];
int las, idx;
int tr[N][26], fail[N], len[N], pre[N];
void ins(char c, int i)
{
	int p = las;
	for(; str[i - len[p] - 1] != c; p = fail[p]);
	if(!tr[p][c - 'a'])
	{
		int np = ++idx, v; pre[np] = ((len[p] & 1) ? len[p] + 2 : 1);
		for(v = fail[p]; str[i - len[v] - 1] != c; v = fail[v]);
		if(!tr[v][c - 'a']) fail[np] = 2;
		else fail[np] = tr[v][c - 'a'];
		len[np] = len[p] + 2;
		ckmax(pre[np], pre[fail[np]]);
		tr[p][c - 'a'] = np;
	}
	las = tr[p][c - 'a'];
}

void PAMclear()
{
	for(int i = 1; i <= idx; i++) 
	{
		pre[i] = 1;
		fail[i] = uvu::len[i] = 0;
		memset(tr[i], 0, sizeof(tr[i]));
		// for(int j = 0; j < 26; j++) tr[i][j] = 0;
	}
	idx = 0;
	las = idx = 2;
	len[1] = -1, len[2] = 0;
	fail[1] = fail[2] = 1;
}

ll ans;
const int B = 150;
int s_in[N], t_in[N];
bool s_isp[N], t_isp[N];
ll tot[N << 1];
std::vector <int> vecs, vect;

namespace matrix_merge
{
struct Tree
{
	int mn, mncnt, lazy;
	void push(int z) { mn += z, lazy += z; }
}tr[N << 2];
#define lson k << 1
#define rson k << 1 | 1
#define ls lson, l, mid
#define rs rson, mid + 1, r
void build(int k, int l, int r) 
{
	tr[k].mn = tr[k].lazy = 0, tr[k].mncnt = r - l + 1;
	if(l == r) return; 
	int mid = (l + r) >> 1; build(ls); build(rs);
}
void pushup(int k) { tr[k].mn = std::min(tr[lson].mn, tr[rson].mn), tr[k].mncnt = (tr[lson].mn == tr[k].mn) * tr[lson].mncnt + (tr[rson].mn == tr[k].mn) * tr[rson].mncnt; }
void pushdown(int k) { if(tr[k].lazy) tr[lson].push(tr[k].lazy), tr[rson].push(tr[k].lazy), tr[k].lazy = 0; }
void change(int k, int l, int r, int ql, int qr, int z) 
{
	if(ql <= l && r <= qr) return tr[k].push(z);
	int mid = (l + r) >> 1; pushdown(k);
	if(ql <= mid) change(ls, ql, qr, z);
	if(mid < qr)  change(rs, ql, qr, z);
	pushup(k);
}
int n, m;
struct node
{
	int l, r, z;
};

std::vector <node> nvec[N];
void init(int n, int m)
{
	// printf("n = %d, m = %d\n", n, m);
	matrix_merge::n = n, matrix_merge::m = m;
	for(int i = 0; i <= n + 1; i++) nvec[i].clear();
	if(m) build(1, 1, m);
}
void push(int lx, int rx, int ly, int ry, bool op)
{
	if(lx > rx || ly > ry) return;
	if(op) std::swap(lx, ly), std::swap(rx, ry);
	// printf("push [%d %d] [%d %d]\n", lx, rx, ly, ry);
	nvec[lx].push_back((node){ly, ry, 1});
	nvec[rx + 1].push_back((node){ly, ry, -1});
}
ll calc()
{
	ll res = 0;
	for(int i = 1; i <= n; i++) 
	{
		for(node t : nvec[i]) change(1, 1, m, t.l, t.r, t.z);
		if(tr[1].mn == 0) res += m - tr[1].mncnt;
		else res += m;
	}
	// printf("res = %d\n", res);
	return res;
}
}


struct Trie
{
Trie *other;
int tr[N][26], nidx, dep[N]; bool isp[N];
std::vector <int> nvec[N];
int tag[N];
int ins(char *s, int n, bool *vis)
{
	int p = 0;
	for(int i = 1; i <= n; i++)
	{
		if(!tr[p][s[i] - 'a']) 
			tr[p][s[i] - 'a'] = ++nidx;
		p = tr[p][s[i] - 'a'];
		isp[p] = vis[i]; dep[p] = i;
	}
	return p;
}
std::vector <int> ivec[N];
void init()
{
	for(int i = 1; i <= nidx; i++) if(isp[i]) ivec[dep[i]].push_back(i);
}
std::vector <pii> vec;
int L[N], R[N], dfncnt;
void dfs0(int k)
{
	L[k] = dfncnt + 1;
	for(int i = 1; i <= tag[k]; i++) ++dfncnt;
	for(int i = 0; i < 26; i++) if(tr[k][i]) dfs0(tr[k][i]);
	R[k] = dfncnt;
}
bool OP;
void flush(int L)
{
	std::vector <pii> tmp;
	for(pii p : vec)
	{
		for(int i = 0; i < 26; i++) if(tr[p.fi][i] && other->tr[p.se][i])
			tmp.push_back(mkp(tr[p.fi][i], other->tr[p.se][i]));
	}
	for(int p : ivec[L]) tmp.push_back(mkp(p, 0));
	std::swap(vec, tmp);
	// printf("vec : "); for(pii p : vec) printf("[%d %d] ", p.fi, p.se); putc('\n');
	for(int i : nvec[L]) tag[i]++;//, printf("(%d) tag[%d]++\n", OP, i);
	dfncnt = 0; dfs0(0);
}
void buildmatrix()
{
	for(pii p : vec) matrix_merge::push(L[p.fi], R[p.fi], other->L[p.se], other->R[p.se], OP);
}
}TrieS, TrieT;


void solve()
{
	// memset(h, idx = -1, sizeof(h));
	n = read(); m = read(); PAMclear();
	for(int i = 1; i <= n; i++) rx_[i] = rx_[i - 1] + readstr(s, lx_[i] = rx_[i - 1] + 1), std::reverse(s + lx_[i], s + rx_[i] + 1);
	for(int i = 1; i <= m; i++) ry_[i] = ry_[i - 1] + readstr(t, ly_[i] = ry_[i - 1] + 1);
	for(int i = 1; i <= n; i++) 
	{
		int len = 0, now = 1; PAMclear();
		for(int _ = lx_[i]; _ <= rx_[i]; _++) str[++len] = s[_], ins(s[_], len), s_isp[_] = (len & 1) && uvu::len[las] == len;
		PAMclear(); len = 0;
		for(int _ = rx_[i]; _ >= lx_[i]; _--) str[++len] = s[_], ins(s[_], len), ckmax(now, pre[las]);
		s_in[i] = now;
		if(rx_[i] - lx_[i] + 1 <= B) { vecs.push_back(i); continue; }
		int _las = las, _now = now, _len = len;
		for(int j = 1; j <= m; j++)
		{
			las = _las, now = _now, len = _len;
			for(int _ = ly_[j]; _ <= ry_[j]; _++) str[++len] = t[_], ins(t[_], len), ckmax(now, pre[las]);
			ans += (now + 1) / 2;
			// printf("f[%d] = %d\n", j, now);
		}
	}
	for(int j = 1; j <= m; j++) 
	{
		int len = 0, now = 1; PAMclear();
		for(int _ = ly_[j]; _ <= ry_[j]; _++) str[++len] = t[_], ins(t[_], len), t_isp[_] = (len & 1) && uvu::len[las] == len;
		PAMclear(); len = 0;
		for(int _ = ry_[j]; _ >= ly_[j]; _--) str[++len] = t[_], ins(t[_], len), ckmax(now, pre[las]);
		t_in[j] = now;
		if(ry_[j] - ly_[j] + 1 <= B) { vect.push_back(j); continue; }
		int _las = las, _now = now, _len = len;
		for(int i = 1; i <= n; i++) if(rx_[i] - lx_[i] + 1 <= B) 
		{
			las = _las, now = _now, len = _len;
			for(int _ = lx_[i]; _ <= rx_[i]; _++) str[++len] = s[_], ins(s[_], len), ckmax(now, pre[las]);
			ans += (now + 1) / 2;
		}
	}
	// debug("(%d %d)\n", (int)vecs.size(), (int)vect.size());
	for(int i : vecs) TrieS.nvec[s_in[i] + 2].push_back(TrieS.ins(s + lx_[i] - 1, rx_[i] - lx_[i] + 1, s_isp + lx_[i] - 1));
	for(int i : vect) TrieT.nvec[t_in[i] + 2].push_back(TrieT.ins(t + ly_[i] - 1, ry_[i] - ly_[i] + 1, t_isp + ly_[i] - 1));
	TrieS.other = &TrieT; TrieS.OP = 0;
	TrieT.other = &TrieS; TrieT.OP = 1;
	TrieS.init(); TrieT.init();
	for(int L = 1; L <= B + B; L += 2)
	// for(int L = 1; L <= 5; L += 2)
	{
		TrieS.flush(L);
		TrieT.flush(L);
		matrix_merge::init(TrieS.dfncnt, TrieT.dfncnt);
		TrieS.buildmatrix();
		TrieT.buildmatrix();
		tot[L] = matrix_merge::calc();
		// printf("tot[%d] = %d\n", L, tot[L]);
		int x = (int)vecs.size(), y = (int)vect.size();
		tot[L] += 1ll * (x - matrix_merge::n) * y;
		tot[L] += 1ll * matrix_merge::n * (y - matrix_merge::m);
		// printf("tot[%d] = %d\n", L, tot[L]);
	}
	for(int L = 1; L <= B + B; L += 2)
	{
		tot[L] -= tot[L + 2];
		ans += 1ll * ((L + 1) / 2) * tot[L];
		// if(tot[L]) printf("tot[%d] = %d\n", L, tot[L]);
	}
	print(ans, '\n');
}

void init()
{
	
}

char _ED_;

void mian()
{
	debug("%.3f MB\n", abs(&_ST_ - &_ED_) / 1024.0 / 1024);
	init();
	for(int T = 1; T; solve(), T--);
}

#ifdef int
	#undef int
#endif
}

int main()
{
	uvu::mian(); return 0;
}