#include<bits/stdc++.h>
#define L(i, j, k) for(int i = (j); i <= (k); ++i)
#define R(i, j, k) for(int i = (j); i >= (k); --i)
#define ll long long
#define sz(a) ((int) (a).size())
#define vi vector < int > 
#define me(a, x) memset(a, x, sizeof(a))
#define ull unsigned long long
#define ld __float128
using namespace std;
const int N = 2e5 + 7, xn = 2e5;

int n, q;
const int blk = 512;
const int bks = 400;
ull smp[bks][N], rns[bks];
struct sam {
	
ull W[N]; 
char s[N];
int ch[N][26], fa[N], len[N], lst = 1, tot = 1;
void copy (int x, int y) {
	fa[y] = fa[x], len[y] = len[x];
	L(i, 0, 25) ch[y][i] = ch[x][i];
}
void ins (int x) {
	int p = lst, now = lst = ++tot;
	len[now] = len[p] + 1;
	for (; p && !ch[p][x]; p = fa[p]) ch[p][x] = now;
	if(!p) fa[now] = 1;
	else {
		int pto = ch[p][x];
		if(len[pto] == len[p] + 1) fa[now] = pto;
		else {
			int sp = ++tot;
			copy (pto, sp), len[sp] = len[p] + 1;
			fa[now] = fa[pto] = sp;
			for (; p && ch[p][x] == pto; p = fa[p]) ch[p][x] = sp;
		}
	}
}

int up[20][N];
vi e[N];

int pos[N];
int edp[N];

ull ws[N];
vi vc[N];
void dfs(int x) {
	for(const int &v : e[x]) {
		dfs(v), ws[x] += ws[v];
		if(!edp[x]) edp[x] = edp[v];
	}
}

void init() {
	L(i, 1, n) ins(s[i] - 'a'), pos[i] = lst, ws[pos[i]] = W[i], edp[lst] = i;
	L(i, 2, tot) up[0][i] = fa[i], e[fa[i]].emplace_back(i);
	L(i, 1, 19) L(j, 1, tot) up[i][j] = up[i - 1][up[i - 1][j]];
	dfs(1);
}

int getp (int l, int r) {
	int x = pos[r];
	R(i, 19, 0) if(len[up[i][x]] >= r - l + 1) x = up[i][x];
	return x;
}

vi CUR;
void DFS(int x) {
	CUR.emplace_back(x);
	for(const int &v : e[x]) DFS(v);
}

vi getng(int x) {
	CUR.clear();
	DFS(x);
	return CUR;
}

} _S, _T;


struct solver {

bool rev; 

#define S (!rev ? _S : _T)
#define T (!rev ? _T : _S)

char s[N];

ull A[N], B[N];
int l1[N], r1[N], l2[N], r2[N];

ull ns[N];
int nxt[N]; // array "NXT" nxt is a tree.

int pt[N], pe[N], dfn[N], en[N], mp[N], idt, cnt[N];
void DFS(int x) {
	dfn[x] = ++idt, mp[idt] = x;
	for(const int &v : S.e[x]) {
		DFS(v), cnt[x] += cnt[v];
	}
	en[x] = idt;
	A[x] = S.ws[x] * cnt[x];
}

vi e[N];
vector < pair < int, int > > vc[N];
ull si[N]; 

int jp[20][N];
int jump(int x, int k) {
	R(i, 19, 0) if(k >> i & 1) x = jp[i][x];
	return x; 
}

template < int N > struct fenwt {
	using F = ull;
	int B = 512;
	F a[N + 512 + 1];
	F sum[514];
	void add (int x, F w) {
		int bk = (x + B - 1) / B;
		L(i, bk, B) sum[i] += w;
		L(i, x, bk * B) a[i] += w;
	}
	F query (int x) {
		int bk = (x + B - 1) / B;
		return a[x] + sum[bk - 1];
	}
} ;

fenwt < N > F;

int Bg[N], En[N], IDT;
void dfs(int x) {
	Bg[x] = ++IDT;
	for(const int &v : e[x]) {
		dfs(v);
	}
	En[x] = IDT; 
} 
ull qaq[N];

int dl[N], dr[N], odt[N], ttt;
void tdfs(int x) {
	dl[x] = ++ttt, odt[ttt] = x;
	for(const int &v : T.e[x]) tdfs(v); 
	dr[x] = ttt;
} 

int L[N], R[N];
ull W[N];
inline ull query(int l, int r) {
	ull ns = 0;
	int bl = (l + blk - 1) / blk;
	int br = (r + blk - 1) / blk;
	if(bl == br) {
		L(i, l, r) 
			ns += W[i] * (F.query(L[i]) - F.query(R[i]));
		return ns; 	
	}
	L(i, l, bl * blk) ns += W[i] * (F.query(L[i]) - F.query(R[i]));
	assert(br <= (T.tot + blk - 1) / blk);
	L(i, bl + 1, br - 1) {
		ns += rns[i];
	}
	L(i, (br - 1) * blk + 1, r) ns += W[i] * (F.query(L[i]) - F.query(R[i]));
	return ns; 
}

void main() {
	L(i, 1, S.tot) {
		vi qwq;
		L(j, 0, 25) if(S.ch[i][j]) qwq.emplace_back(S.ch[i][j]);
		if(sz(qwq) == 1) nxt[i] = qwq[0], e[nxt[i]].emplace_back(i); 
	}
	
	L(i, 2, T.tot) {
		int p = n - T.edp[i] + 1;
		int len = T.len[T.fa[i]] + 1;
		pt[i] = S.getp(p, p + len - 1);
	}
	
	L(i, 1, S.tot) jp[0][i] = nxt[i];
	L(i, 1, 19) L(j, 1, S.tot) jp[i][j] = jp[i - 1][jp[i - 1][j]];
	
	L(i, 1, n) cnt[S.pos[i]] += 1;
	DFS(1);
	L(t, 1, q) if(l1[t]) {
		int pos2 = S.getp(l2[t], r2[t]);
		vc[en[pos2]].push_back({t, 1});
		vc[dfn[pos2] - 1].push_back({t, -1});
	}
	
	L(i, 1, S.tot) if(!Bg[i] && !nxt[i]) dfs(i);
	L(i, 1, T.tot) pe[i] = jump(pt[i], T.len[i] - T.len[T.fa[i]]);
	tdfs(1);
	L(i, 1, T.tot) L[i] = Bg[pt[odt[i]]], R[i] = Bg[pe[odt[i]]], W[i] = T.ws[odt[i]];
	
	assert(T.tot <= xn);
	
	me(smp, 0), me(rns, 0);
	L(i, 1, (T.tot + blk - 1) / blk) {
		L(j, (i - 1) * blk + 1, min(i * blk, T.tot)) 
			smp[i][L[j]] += W[j], smp[i][R[j]] -= W[j];
		R(j, xn, 1) smp[i][j] += smp[i][j + 1];
	}
	
	L(p, 1, S.tot) {
		int u = mp[p];
		si[u] += A[u];
		F.add(Bg[u], A[u]);
		F.add(En[u] + 1, -A[u]); 
		L(i, 1, (T.tot + blk - 1) / blk) {
			rns[i] += (smp[i][Bg[u]] - smp[i][En[u] + 1]) * A[u]; 
		}
		for(auto pr : vc[p]) {
			int t = pr.first;
			int pc = T.getp(n - r1[t] + 1, n - l1[t] + 1);
			int len = max(r1[t] - l1[t] + 1, r2[t] - l2[t] + 1);
			ull sum = 0;
			
			int cur = pt[pc];
			int l = T.len[T.fa[pc]] + 1, r = T.len[pc];
			if(len >= l) cur = jump(cur, len - l), l = len;
			sum += (F.query(Bg[cur]) - F.query(Bg[jump(cur, r - l + 1)])) * T.ws[pc];
			
			sum += query(dl[pc] + 1, dr[pc]);
			ns[t] += sum * pr.second;
		}
	}
}

} a, b;

char s[N];
int l1[N], r1[N], l2[N], r2[N];
ull wl[N], wr[N];
int main() {
//	return system("fc qwq.out a.out"), 0;
//	freopen("a.in", "r", stdin);
//	freopen("qwq.out", "w", stdout);
	ios :: sync_with_stdio(false);
	cin.tie(0); cout.tie(0);
	cin >> n >> q;
	cin >> (s + 1);
	L(i, 1, n) cin >> wl[i];
	L(i, 1, n) cin >> wr[i];
	L(i, 1, n) _S.W[i] = wr[i];
	L(i, 1, n) _T.W[n - i + 1] = wl[i];
	
	L(i, 1, n) _S.s[i] = s[i];
	reverse(s + 1, s + n + 1);
	L(i, 1, n) _T.s[i] = s[i];
	reverse(s + 1, s + n + 1);
	
	_S.init();
	_T.init();
	
	b.rev = true;
	L(i, 1, n) a.s[i] = s[i];
	L(i, 1, n) b.s[i] = s[n - i + 1];
	
	L(t, 1, q) {
		cin >> l1[t] >> r1[t] >> l2[t] >> r2[t];
		int len1 = r1[t] - l1[t] + 1;
		int len2 = r2[t] - l2[t] + 1;
		if(len1 >= len2) {
			a.l1[t] = l1[t];
			a.r1[t] = r1[t];
			a.l2[t] = l2[t];
			a.r2[t] = r2[t];
		} else {
			b.l1[t] = n - r2[t] + 1;
			b.r1[t] = n - l2[t] + 1;
			b.l2[t] = n - r1[t] + 1;
			b.r2[t] = n - l1[t] + 1;
		}
	}
	
	a.main();
	b.main();
	
	L(t, 1, q) {
		cout << (a.l1[t] ? a.ns[t] : b.ns[t]) << '\n';
	}
	return 0;
}