#include <bits/stdc++.h>

using i64 = long long;

std::vector<int> Z(std::string s, std::string t) {
    std::vector<int> z(s.size() + t.size() + 1);
    std::string str = s + '#' + t;
    int l = 0, r = 0;
    for (int i = 1; i < str.size(); ++i) {
        if (i < r) {
            z[i] = std::min(z[i - l], r - i);
        }
        while (i + z[i] < str.size() && str[z[i]] == str[i + z[i]]) {
            ++z[i];
        }
        if (i + z[i] > r) {
            l = i;
            r = i + z[i];
        }
    }
    return std::vector<int>(z.begin() + int(s.size()), z.end());
}

std::vector<int> kmp(std::string s) {
    std::vector<int> f(s.size() + 1);
    f[0] = 0;
    for (int i = 1; i < s.size(); ++i) {
        int j = f[i];
        while (j > 0 && s[i] != s[j]) {
            j = f[j];
        }
        f[i + 1] = s[i] == s[j] ? j + 1 : 0;
    }
    return f;
}

template<class T, class F = std::function<T(const T&, const T&)>> class SparseTable {
    int n;
    std::vector<std::vector<T>> st;
    const F func;
public:
    SparseTable(const std::vector<T> &a, const F &f): n(a.size()), func(f) {
        assert(n > 0);
        int lg = std::__lg(n);
        st.assign(lg + 1, std::vector<T>(n));
        st[0] = a;
        for (int i = 1; i <= lg; i += 1) {
            for (int j = 0; j + (1 << i) <= n; j += 1) {
                st[i][j] = func(st[i - 1][j], st[i - 1][j + (1 << (i - 1))]);
            }
        }
    }

    T ask(int l, int r) {
        assert(0 <= l && l <= r && r < n);
        int k = std::__lg(r - l + 1);
        return func(st[k][l], st[k][r - (1 << k) + 1]);
    }
};

int main(){
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    int n, q;
    std::cin >> n >> q;
    std::string s, t;
    std::cin >> s >> t;
    auto z = Z(s, t);
    auto f = kmp(s);
    std::vector<i64> prefixs(n + 1);
    std::vector<i64> prefixt(n + 1);
    std::vector<int> w(n + 1);
    for (int i = 1; i <= n; i += 1) {
        std::cin >> w[i];
    }
    
    std::vector<i64> sum(n + 1);
    for (int i = 1; i <= n; i += 1) {
        prefixt[i] = prefixt[i - 1] + w[i];
        prefixs[i] = prefixs[f[i]] + w[i];
    }

    for (int i = 1; i <= n; i += 1) {
        sum[i] = sum[i - 1] + prefixt[z[i]];
        prefixs[i] += prefixs[i - 1];
    }
    
    auto zz = z;
    for (int i = 1; i <= n; i += 1) {
        zz[i] += i - 1;
    }
    SparseTable st(zz, [](int x, int y) { return std::max(x, y); }); 
    while(q--) {
        int l, r;
        std::cin >> l >> r;
        int lo = l, hi = r, ans = l - 1;
        while(lo <= hi) {
            int mid = (lo + hi) >> 1;
            if (st.ask(l, mid) <= r) {
                ans = mid;
                lo = mid + 1;
            } else {
                hi = mid - 1;
            }
        }
        // std::cout << "!: " << ans << " " << r - ans << " " << prefix[r - ans] << "\n";
        i64 res = sum[ans] - sum[l - 1] + prefixs[r - ans];
        std::cout << res << '\n';
    }
    return 0;
}