#include <bits/stdc++.h>

/**
 * Author: Niyaz Nigmatullin
 *
 */

using namespace std;

string to_string(string s) {
  return '"' + s + '"';
}

string to_string(const char* s) {
  return to_string((string) s);
}

string to_string(bool b) {
  return (b ? "true" : "false");
}

template <typename A, typename B>
string to_string(pair<A, B> p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <typename A>
string to_string(A v) {
  bool first = true;
  string res = "{";
  for (const auto &x : v) {
    if (!first) {
      res += ", ";
    }
    first = false;
    res += to_string(x);
  }
  res += "}";
  return res;
}

void debug_out() { cerr << endl; }

template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  cerr << " " << to_string(H);
  debug_out(T...);
}

#ifdef LOCAL
#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__)
#else
#define debug(...) 42
#endif

struct upinfo {
	int left;
	int right;
	int index = -1;
};

struct node {
	long long sum = 0;
	upinfo updateInfo;

	static node single(long long x) {
		node res;
		res.sum = x;
		return res;
	}

	void apply(int l, int r, upinfo info);

	void apply(int l, int r, int x) {
		*this = single(x);
	}
};

node unite(const node &a, const node &b) {
	node res;
	res.sum = a.sum + b.sum;
	return res;
}

struct update {
	static const int K = 20;
	vector<long long> values;
	int n;
	vector<vector<node>> tt;

	update(vector<long long> values_): values(std::move(values_)), n((int) values.size()), tt(K, vector<node>(n)) {
		for (int i = 0; i < n; i++) {
			tt[0][i] = node::single(values[i]);
		}
		for (int i = 1; i < K; i++) {
			for (int v = 0; v < n; v++) {
				tt[i][v] = unite(tt[i - 1][v], tt[i - 1][(v + (1 << (i - 1))) % n]);
			}
		}
	}

	node get(int start, int len) {
		node res;
		start %= n;
		for (int i = K - 1; i >= 0; i--) {
			if (len >= (1 << i)) {
				len -= 1 << i;
				// debug(i, start, n, tt[i][start]);
				res = unite(res, tt[i][start]);
				start = (start + (1 << i)) % n;
			}
		}
		return res;
	}
};



vector<update> updates;

string to_string(node const &s) {
	return "node{sum=" + to_string(s.sum) + "}";
}
void node::apply(int l, int r, upinfo info) {
	assert(info.left <= l && r <= info.right);
	int start = l - info.left;
	node res = updates[info.index].get(start, r - l + 1);
	res.updateInfo = info;
	*this = res;
}

class segtree {
  public:
	

  inline void push(int x, int l, int r) {
    if (tree[x].updateInfo.index < 0) {
    	return;
    }
    int y = (l + r) >> 1;
    int z = x + ((y - l + 1) << 1);
    // push from x into (x + 1) and z
    tree[x + 1].apply(l, y, tree[x].updateInfo);
    tree[z].apply(y + 1, r, tree[x].updateInfo);
/*
    if (tree[x].add != 0) {
      tree[x + 1].apply(l, y, tree[x].add);
      tree[z].apply(y + 1, r, tree[x].add);
      tree[x].add = 0;
    }
*/
  }

  inline void pull(int x, int z) {
    tree[x] = unite(tree[x + 1], tree[z]);
  }

  int n;
  vector<node> tree;

  void build(int x, int l, int r) {
    if (l == r) {
      return;
    }
    int y = (l + r) >> 1;
    int z = x + ((y - l + 1) << 1);
    build(x + 1, l, y);
    build(z, y + 1, r);
    pull(x, z);
  }

  template <typename M>
  void build(int x, int l, int r, const vector<M> &v) {
    if (l == r) {
      tree[x].apply(l, r, v[l]);
      return;
    }
    int y = (l + r) >> 1;
    int z = x + ((y - l + 1) << 1);
    build(x + 1, l, y, v);
    build(z, y + 1, r, v);
    pull(x, z);
  }

  node get(int x, int l, int r, int ll, int rr) {
    if (ll <= l && r <= rr) {
      return tree[x];
    }
    int y = (l + r) >> 1;
    int z = x + ((y - l + 1) << 1);
    push(x, l, r);
    node res{};
    if (rr <= y) {
      res = get(x + 1, l, y, ll, rr);
    } else {
      if (ll > y) {
        res = get(z, y + 1, r, ll, rr);
      } else {
        res = unite(get(x + 1, l, y, ll, rr), get(z, y + 1, r, ll, rr));
      }
    }
    pull(x, z);
    return res;
  }

  template <typename... M>
  void modify(int x, int l, int r, int ll, int rr, const M&... v) {
    if (ll <= l && r <= rr) {
      tree[x].apply(l, r, v...);
      return;
    }
    int y = (l + r) >> 1;
    int z = x + ((y - l + 1) << 1);
    push(x, l, r);
    if (ll <= y) {
      modify(x + 1, l, y, ll, rr, v...);
    }
    if (rr > y) {
      modify(z, y + 1, r, ll, rr, v...);
    }
    pull(x, z);
  }

  int find_first_knowingly(int x, int l, int r, const function<bool(const node&)> &f) {
    if (l == r) {
      return l;
    }
    push(x, l, r);
    int y = (l + r) >> 1;
    int z = x + ((y - l + 1) << 1);
    int res;
    if (f(tree[x + 1])) {
      res = find_first_knowingly(x + 1, l, y, f);
    } else {
      res = find_first_knowingly(z, y + 1, r, f);
    }
    pull(x, z);
    return res;
  }

  int find_first(int x, int l, int r, int ll, int rr, const function<bool(const node&)> &f) {
    if (ll <= l && r <= rr) {
      if (!f(tree[x])) {
        return -1;
      }
      return find_first_knowingly(x, l, r, f);
    }
    push(x, l, r);
    int y = (l + r) >> 1;
    int z = x + ((y - l + 1) << 1);
    int res = -1;
    if (ll <= y) {
      res = find_first(x + 1, l, y, ll, rr, f);
    }
    if (rr > y && res == -1) {
      res = find_first(z, y + 1, r, ll, rr, f);
    }
    pull(x, z);
    return res;
  }

  int find_last_knowingly(int x, int l, int r, const function<bool(const node&)> &f) {
    if (l == r) {
      return l;
    }
    push(x, l, r);
    int y = (l + r) >> 1;
    int z = x + ((y - l + 1) << 1);
    int res;
    if (f(tree[z])) {
      res = find_last_knowingly(z, y + 1, r, f);
    } else {
      res = find_last_knowingly(x + 1, l, y, f);
    }
    pull(x, z);
    return res;
  }

  int find_last(int x, int l, int r, int ll, int rr, const function<bool(const node&)> &f) {
    if (ll <= l && r <= rr) {
      if (!f(tree[x])) {
        return -1;
      }
      return find_last_knowingly(x, l, r, f);
    }
    push(x, l, r);
    int y = (l + r) >> 1;
    int z = x + ((y - l + 1) << 1);
    int res = -1;
    if (rr > y) {
      res = find_last(z, y + 1, r, ll, rr, f);
    }
    if (ll <= y && res == -1) {
      res = find_last(x + 1, l, y, ll, rr, f);
    }
    pull(x, z);
    return res;
  }

  segtree(int _n) : n(_n) {
    assert(n > 0);
    tree.resize(2 * n - 1);
    build(0, 0, n - 1);
  }

  template <typename M>
  segtree(const vector<M> &v) {
    n = (int) v.size();
    assert(n > 0);
    tree.resize(2 * n - 1);
    build(0, 0, n - 1, v);
  }

  node get(int ll, int rr) {
    assert(0 <= ll && ll <= rr && rr <= n - 1);
    return get(0, 0, n - 1, ll, rr);
  }

  node get(int p) {
    assert(0 <= p && p <= n - 1);
    return get(0, 0, n - 1, p, p);
  }

  template <typename... M>
  void modify(int ll, int rr, const M&... v) {
    assert(0 <= ll && ll <= rr && rr <= n - 1);
    modify(0, 0, n - 1, ll, rr, v...);
  }

  // find_first and find_last call all FALSE elements
  // to the left (right) of the sought position exactly once

  int find_first(int ll, int rr, const function<bool(const node&)> &f) {
    assert(0 <= ll && ll <= rr && rr <= n - 1);
    return find_first(0, 0, n - 1, ll, rr, f);
  }

  int find_last(int ll, int rr, const function<bool(const node&)> &f) {
    assert(0 <= ll && ll <= rr && rr <= n - 1);
    return find_last(0, 0, n - 1, ll, rr, f);
  }
};

vector<int> zFunction(string const &s) {
	int n = (int) s.size();
	vector<int> z(n);
	int left = 0;
	int right = 0;
	for (int i = 1; i < n; i++) {
		z[i] = i >= right ? 0 : min(right - i, z[i - left]);
		while (i + z[i] < n && s[z[i]] == s[i + z[i]]) {
			++z[i];
		}
		if (i + z[i] > right) {
			left = i;
			right = i + z[i];
		}
	}
	return z;
}

vector<long long> getV(string const &s, vector<int> const &w) {
	int n = (int) s.size();
	vector<int> p(n);
	vector<long long> sum(n);
	int k = -1;
	p[0] = -1;
	sum[0] = w[0];
	for (int i = 1; i < n; i++) {
		while (k > -1 && s[k + 1] != s[i]) {
			k = p[k];
		}
		if (s[k + 1] == s[i]) {
			k++;
		}
		sum[i] = w[i];
		if (k >= 0) {
			sum[i] += sum[k];
		}
	}
	return sum;
}

struct stupidtree {
	vector<long long> s;

	stupidtree(int n) : s(n) {}

	void modify(int left, int right, upinfo info) {
		for (int i = left; i <= right; i++) {
			s[i] = updates[info.index].values[i - left];
		}
	}

	node get(int left, int right) {
		long long ans = 0;
		for (int i = left; i <= right; i++) {
			ans += s[i];
		}
		node res;
		res.sum = ans;
		return res;
	}
};

vector<long long> solveSmart(string const &s, string const &t, vector<int> const &w, vector<pair<int, int>> const &qs) {
	int n = (int) w.size();
	string zs = s + "@" + t;
	vector<int> z = zFunction(zs);
	int lenT = (int) t.size();
	vector<vector<int>> qByL(lenT);
	int queries = (int) qs.size();
	for (int i = 0; i < queries; i++) {
		qByL[qs[i].first].push_back(i);
	}
	updates = {update(getV(s, w))};
	segtree tree(vector<int>(lenT, 0));
	// stupidtree tree(lenT);
	vector<long long> ans(queries);
	for (int i = lenT - 1; i >= 0; i--) {
		int maxLen = z[n + 1 + i];
		if (maxLen > 0) {
			tree.modify(i, i + maxLen - 1, upinfo{i, i + maxLen - 1, 0});
		}
		for (int qid : qByL[i]) {
			int right = qs[qid].second;
			ans[qid] = tree.get(i, right).sum;
		}
	}
	return ans;
}

int main() {
	std::cin.tie(NULL); std::ios::sync_with_stdio(false);
	int n, m;
	cin >> n >> m;
	string s, t;
	cin >> s >> t;
	vector<int> w(n);
	for (int &x: w) cin >> x;
	vector<pair<int, int>> qs(m);
	for (auto &e: qs) {
		cin >> e.first >> e.second;
		e.first--;
		e.second--;
	}

	vector<long long> ans = solveSmart(s, t, w, qs);
	for (auto &x : ans) {
		cout << x << '\n';
	}

}