#include <iostream>
#include <cstdio>
#include <cstring>
#include <vector>

using namespace std;

typedef unsigned long long u64;

const int N = 100005, B = 9;
int n, m, q;
int l1[N], r1[N], l2[N], r2[N];
int vs[N], vp[N];
int il2[N << 1], ir2[N << 1], t2;
u64 v[N][(N >> (B - 1)) + 5];
int cnt, mp[N << 1];
u64 wl[N], wr[N], ans[N];
vector<int> qy[N << 1];
char a[N];

u64 ts[(N >> (B - 1)) + 5];
namespace bits {
u64 s[N << 1];

void add(int x, u64 v) {
  while (x <= 2 * n)
    s[x] += v, x += x & (-x);
}
u64 query(int x) {
  u64 ans = 0;
  while (x)
    ans += s[x], x &= x - 1;
  return ans;
}
}

namespace block {
u64 s1[N << 1], s2[(N >> (B - 1)) + 5];

void add(int x, u64 v) {
  int b = (--x) >> B;
  for (int i = x + 1; i != (b + 1) << B; i++)
    s1[i] += v;
  for (int i = b + 1; i <= (m >> B); i++)
    s2[i] += v;
}
u64 query(int x) { return s1[x] + s2[x >> B]; }
}

struct sam {
  int cnt = 1, lt = 1;
  int sz[N << 1], fa[N << 1], len[N << 1];
  int tr[N << 1][26];
  int p[N], pos[N << 1];
  int l[N << 1], r[N << 1], tot;
  vector<int> to[N << 1], to2[N << 1];
  int ff[N << 1][18], mp[N << 1];
  int ff2[N << 1][18], ff0[N << 1];
  u64 s[N << 1];

  void extend(int c, int k) {
    int nw = ++cnt, x = lt;
    len[nw] = len[lt] + 1, p[k] = nw, sz[nw] = 1, pos[nw] = k;
    while (x && !tr[x][c])
      tr[x][c] = nw, x = fa[x];
    if (!x)
      fa[nw] = 1;
    else {
      int y = tr[x][c];
      if (len[y] == len[x] + 1)
        fa[nw] = y;
      else {
        int z = ++cnt;
        len[z] = len[x] + 1, fa[z] = fa[y], pos[z] = pos[y];
        memcpy(tr[z], tr[y], sizeof tr[y]);
        fa[y] = fa[nw] = z;
        while (x && tr[x][c] == y)
          tr[x][c] = z, x = fa[x];
      }
    }
    lt = nw;
  }

  void dfs(int i) {
    l[i] = ++tot, mp[tot] = i;
    for (int j = 1; ff[ff[i][j - 1]][j - 1]; j++)
      ff[i][j] = ff[ff[i][j - 1]][j - 1];
    for (int j : to[i]) {
      dfs(j);
      sz[i] += sz[j], s[i] += s[j];
    }
    r[i] = tot;
  }

  void dfs2(int i, int fa) {
    ff0[i] = ff2[i][0] = fa;
    for (int j = 1; ff2[ff2[i][j - 1]][j - 1]; j++)
      ff2[i][j] = ff2[ff2[i][j - 1]][j - 1];
    for (int j : to2[i])
      dfs2(j, i);
  }

  void build() {
    for (int i = 2; i <= cnt; i++)
      to[fa[i]].push_back(i), ff[i][0] = fa[i];
    for (int i = 1; i <= cnt; i++)
      for (int j = 0; j != 26; j++) {
        int x = tr[i][j];
        if (len[x] == len[i] + 1)
          to2[i].push_back(x);
      }
    dfs(1);
    dfs2(1, 0);
  }

  int jump(int x, int l) {
    for (int i = __lg(len[x]); i != -1; i--)
      if (len[ff[x][i]] >= l)
        x = ff[x][i];
    return x;
  }

  int jump2(int x, int k) {
    while (k) {
      int j = __lg(k);
      x = ff2[x][j];
      k ^= 1 << j;
    }
    return x;
  }
} pre, suf;

void getb(int i, int fa) {
  static u64 ts[(N >> (B - 1)) + 5];
  static int h[N << 1];
  il2[i] = ++t2;
  ts[pre.l[i] >> B] += pre.s[i];
  for (int j : pre.to2[i])
    getb(j, i), h[i] = max(h[i], h[j] + 1);
  ir2[i] = t2;
  if (h[i] >= 2) {
    h[i] = 0;
    mp[i] = ++cnt;
    memcpy(v[cnt], ts, ((m >> B) + 1) << 3);
  }
  ts[pre.l[i] >> B] -= pre.s[i];
}

void add(int x, u64 a) {
  block::add(il2[x], a);
  while(x) {
    if (mp[x]) {
      for (int j = 0; j <= (m >> B); j++)
        ts[j] += a * v[mp[x]][j];
      return;
    }
    ts[pre.l[x] >> B] += a * pre.s[x];
    x = pre.ff0[x];
  }
}

u64 query1(int x) { return pre.s[x] * (block::query(ir2[x]) - block::query(il2[x] - 1)); }

u64 query(int l, int r) {
  l--, r++;
  int bl = l >> B, br = r >> B;
  u64 ans = 0;
  if (bl == br) {
    for (int i = l + 1; i != r; i++)
      ans += query1(pre.mp[i]);
  } else {
    for (int i = l + 1; i != (bl + 1) << B; i++)
      ans += query1(pre.mp[i]);
    for (int i = br << B; i != r; i++)
      ans += query1(pre.mp[i]);
    for (int i = bl + 1; i != br; i++)
      ans += ts[i];
  }
  return ans;
}

void dfs(int i) {
  if (i != 1) {
    int l = suf.len[i], p = suf.pos[i];
    int x = pre.jump(pre.p[l + p - 1], l);
    int y = pre.jump2(x, suf.len[i] - suf.len[suf.fa[i]]);
    add(x, suf.s[i] * suf.sz[i]), add(y, -suf.s[i] * suf.sz[i]);
  }

  for (int id : qy[i]) {
    int x = vp[id];
    ans[id] = -query(pre.l[x], pre.r[x]);
  }

  for (int j : suf.to[i])
    dfs(j);

  for (int id : qy[i]) {
    int x = vp[id];
    ans[id] += query(pre.l[x], pre.r[x]);
  }
}

vector<pair<int, u64>> qy2[N << 1];

void dfs2(int i) {
  bits::add(pre.l[i], pre.s[i]);
  for (auto tp : qy2[i]) {
    int id = tp.first;
    int x = vp[id];
    ans[id] += tp.second * (bits::query(pre.r[x]) - bits::query(pre.l[x] - 1));
  }

  for (int j : pre.to2[i])
    dfs2(j);

  bits::add(pre.l[i], -pre.s[i]);
}

vector<pair<int, u64>> qy3[N << 1];
void dfs3(int i) {
  bits::add(suf.l[i], suf.s[i]);
  for (auto tp : qy3[i]) {
    int id = tp.first;
    int y = vs[id];
    ans[id] += tp.second * (bits::query(suf.r[y]) - bits::query(suf.l[y] - 1));
  }

  for (int j : suf.to2[i])
    dfs3(j);

  bits::add(suf.l[i], -suf.s[i]);
}

int main() {
  ios::sync_with_stdio(0), cin.tie(0), cout.tie(0);

  cin >> n >> q >> (a + 1);
  for (int i = 1; i <= n; i++)
    cin >> wl[i];
  for (int i = 1; i <= n; i++)
    cin >> wr[i];
  for (int i = 1; i <= n; i++)
    pre.extend(a[i] - 'a', i), pre.s[pre.p[i]] = wr[i];
  for (int i = n; i; i--)
    suf.extend(a[i] - 'a', i), suf.s[suf.p[i]] = wl[i];
  pre.build(), suf.build();
  m = pre.cnt, getb(1, 0);

  for (int i = 1; i <= q; i++) {
    cin >> l1[i] >> r1[i] >> l2[i] >> r2[i];
    int x = vs[i] = suf.jump(suf.p[l1[i]], r1[i] - l1[i] + 1);
    vp[i] = pre.jump(pre.p[r2[i]], r2[i] - l2[i] + 1);
    qy[x].push_back(i);
    int y = pre.jump(pre.p[suf.pos[x] + suf.len[x] - 1], suf.len[x]);
    qy2[y].push_back({i, suf.sz[x] * suf.s[x]});
    qy2[pre.jump2(y, suf.len[x] - (r1[i] - l1[i] + 1) + 1)].push_back({i, -suf.sz[x] * suf.s[x]});
  }
  dfs(1);
  dfs2(1);

  for (int i = 1; i <= q; i++)
    if (r1[i] - l1[i] < r2[i] - l2[i]) {
      int y = vp[i];
      int l = max(pre.len[pre.fa[y]] + 1, r1[i] - l1[i] + 1);
      int r = r2[i] - l2[i] + 1;
      l--, r--;
      int x = suf.jump(suf.p[pre.pos[y] - pre.len[y] + 1], pre.len[y]);
      if (l != r) {
        x = suf.jump2(x, pre.len[y] - r);
        qy3[x].push_back({i, -pre.sz[y] * pre.s[y]});
        x = suf.jump2(x, r - l);
        qy3[x].push_back({i, pre.sz[y] * pre.s[y]});
      }
    }
  dfs3(1);

  for (int i = 1; i <= q; i++)
    cout << ans[i] << '\n';
}