#include <algorithm>
#include <cassert>
#include <iostream>
#include <vector>
#include <numeric>
#include <set>

using namespace std;
#define endl '\n'

struct SuffixArrayTree
{

    SuffixArrayTree() : root(-1), up(1), sa(1)
    {
        root = new_node(-1, -1);
    }

    void push(int c)
    {
        int old_root = root;
        root = new_node(c, root);
        if (old_root != -1)
            children[old_root].push_back(root);
        queries.push_back(root);
    }

    void pop()
    {
        assert(root != -1);
        root = up[0][root];
        queries.push_back(root);
    }

    void record()
    {
        queries.clear();
        queries.push_back(root);
    }

    int compare(int u, int v, vector<int> &up, vector<int> &sa, vector<int> &len)
    {
        if (sa[u] != sa[v])
            return sa[u] < sa[v] ? +1 : -1;
        if (up[u] == -1 || up[v] == -1)
        {
            if (len[u] == len[v])
                return 0;
            return len[u] < len[v] ? +1 : -1;
        }
        u = up[u], v = up[v];
        if (sa[u] == sa[v])
            return 0;
        return sa[u] < sa[v] ? +1 : -1;
    }

    void build()
    {
        int n = sa[0].size();

        // compute len of each string
        for (int i = 0; i < n; ++i)
        {
            if (up[0][i] == -1)
                len[i] = 0;
            else
                len[i] = len[up[0][i]] + 1;
        }

        // Build suffix array
        for (int i = 0; i < 20; ++i)
        {
            vector<int> u(n), s(n); // up row + suffix array row

            auto &ub = up.back();
            auto &sb = sa.back();

            for (int i = 0; i < n; ++i)
                u[i] = ub[i] == -1 ? -1 : ub[ub[i]];

            iota(s.begin(), s.end(), 0);
            sort(s.begin(), s.end(), [&](int &u, int &v)
                 { return compare(u, v, ub, sb, len) == +1; });

            vector<int> row(n);
            for (int i = 1; i < n; ++i)
            {
                int u = s[i - 1], v = s[i];
                int c = compare(u, v, ub, sb, len);
                assert(c >= 0);
                row[v] = row[u] + c;
            }

            order = s;
            up.push_back(u);
            sa.push_back(row);
        }

        rank = vector<int>(n);
        for (int i = 0; i < n; ++i)
            rank[order[i]] = i;

        // Build lcp
        lcp = vector<int>(n - 1);
        for (int i = 0; i + 1 < n; ++i)
            lcp[i] = find_lcp_log(order[i], order[i + 1]);

        // Build rmq table for lcp
        rmq.push_back(lcp);
        for (int i = 1; (1 << i) <= n - 1; ++i)
        {
            vector<int> r(n - 1);
            for (int j = 0; j + (1 << i) <= n - 1; ++j)
                r[j] = min(rmq[i - 1][j], rmq[i - 1][j + (1 << (i - 1))]);
            rmq.push_back(r);
        }

        log2 = vector<int>(n + 1);
        for (int i = 2; i <= n; ++i)
            log2[i] = 1 + log2[i / 2];

        set<int> s;
        dfs(0, s);
    }

    void print()
    {
        for (auto u : queries)
            cout << answer[u] << '\n';
    }

private:
    int root;
    vector<int> order, rank, lcp, log2, len, queries;
    vector<long long> answer;
    vector<vector<int>> up, rmq, sa, children;

    int new_node(int value, int parent)
    {
        sa.back().push_back(value);
        up.back().push_back(parent);
        len.push_back(0);
        answer.push_back(0);
        children.push_back({});
        return sa.back().size() - 1;
    }

    int find_lcp_log(int u, int v)
    {
        int answer = 0;

        for (int l = sa.size() - 1; u != -1 && v != -1 && l >= 0; --l)
        {
            if ((1 << l) <= len[u] && sa[l][u] == sa[l][v])
            {
                answer += 1 << l;
                u = up[l][u];
                v = up[l][v];
            }
        }

        return answer;
    }

    int find_lcp_from_rank(int pu, int pv)
    {
        // int pu = rank[u];
        // int pv = rank[v];
        if (pu > pv)
            swap(pu, pv);
        pv--;
        int sz = pv - pu + 1;
        int lg = log2[sz];
        return min(rmq[lg][pu], rmq[lg][pv - (1 << lg) + 1]);
    }

    void dfs(int u, set<int> &s)
    {
        // Try insert
        int r = rank[u];
        auto it = s.lower_bound(r);

        // [l2] ... [l1] ... [r] ... [r1] ... [r2]
        int l2 = 0, l1 = 0, r1 = 0, r2 = 0, c = 0;

        if (it != s.end())
        {
            if (it != s.begin())
            {
                int b = *--it;
                int a = *++it;
                c = find_lcp_from_rank(a, b);
            }

            r1 = find_lcp_from_rank(r, *it);
            if (++it != s.end())
                r2 = find_lcp_from_rank(r, *it);
            --it;
        }

        if (it != s.begin())
        {
            l1 = find_lcp_from_rank(*--it, r);
            if (it != s.begin())
                l2 = find_lcp_from_rank(*--it, r);
        }

        int new_delta = max(l1, r1) - max({l2, r2, c});

        answer[u] += new_delta;

        s.insert(r);

        for (auto v : children[u])
        {
            answer[v] = answer[u];
            dfs(v, s);
        }

        s.erase(r);
    }
};

int main()
{
    ios_base::sync_with_stdio(0);
    cin.tie(0);

    string s, q;
    cin >> s >> q;

    SuffixArrayTree tree;

    for (auto c : s)
        tree.push(c - 'A');

    tree.record();

    for (auto c : q)
    {
        if (c == '-')
            tree.pop();
        else
            tree.push(c - 'A');
    }

    tree.build();
    tree.print();
}