#include <bits/stdc++.h>

using i64 = long long;

struct G {
    int k = 1;
    int b = 0;
};

int N;
G operator*(G a, G b) {
    return {a.k * b.k, ((a.b * b.k + b.b) % N + N) % N};
}

std::vector<int> manacher(std::string s) {
    std::string t = "#";
    for (auto c : s) {
        t += c;
        t += '#';
    }
    int n = t.size();
    std::vector<int> r(n);
    for (int i = 0, j = 0; i < n; i++) {
        if (2 * j - i >= 0 && j + r[j] > i) {
            r[i] = std::min(r[2 * j - i], j + r[j] - i);
        }
        while (i - r[i] >= 0 && i + r[i] < n && t[i - r[i]] == t[i + r[i]]) {
            r[i] += 1;
        }
        if (i + r[i] > j + r[j]) {
            j = i;
        }
    }
    return r;
}

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    std::string S;
    std::cin >> S;

    N = S.size();
    std::vector<int> f(N + 1);
    for (int i = 1, j = 0; i < N; i++) {
        while (j && S[i] != S[j]) {
            j = f[j];
        }
        j += (S[i] == S[j]);
        f[i + 1] = j;
    }
    if (N % (N - f[N]) == 0) {
        N = N - f[N];
        S.resize(N);
    }
    
    auto r = manacher(S + S);
    std::vector<int> axis;
    for (int i = 0; i < N; i++) {
        if (r[i + i + N] > N) {
            axis.push_back(2 * i % N);
            break;
        }
    }
    if (N % 2 == 0) {
        for (int i = 0; i < N; i++) {
            if (r[i + i + N - 1] > N - 1) {
                axis.push_back((2 * i - 1 + N) % N);
                break;
            }
        }
    }

    int K;
    std::cin >> K;

    std::vector<G> a(K);
    for (int i = 0; i < K; i++) {
        char x;
        std::cin >> x;

        if (x == 'I') {
            a[i] = {-1, 0};
        } else {
            int y;
            std::cin >> y;

            a[i] = {1, (x == 'L' ? (N - y % N) % N : y % N)};
        }
    }

    std::vector<G> pre(K + 1);
    pre[0] = {1, 0};
    for (int i = 0; i < K; i++) {
        pre[i + 1] = pre[i] * a[i];
    }

    i64 ans = 0;
    std::vector cnt(2, std::vector<int>(N));
    for (int i = K; i >= 0; i--) {
        auto v = pre[i];
        ans += cnt[v.k == -1][v.b];
        for (auto x : axis) {
            auto u = v * G{-1, x};
            ans += cnt[u.k == -1][u.b];
        }
        cnt[pre[i].k == -1][pre[i].b]++;
    }
    std::cout << ans << "\n";

    return 0;
}