#include <cstdio>

#include <cstring>

#include <algorithm>

using namespace std;

const int N = 1e5 + ;

struct edge {

    int nxt, to, w;

} e[N << ];

int n, m, cnt = ;

int h[N], pos[N];

char s[N];

long long sum;

namespace lct

{

    struct node {

        int ch[];

        int f, tag, reg;

    } t[N << ];

    bool isr(int x) {

        return !t[x].f || (t[t[x].f].ch[] != x && t[t[x].f].ch[] != x);

    }

    int wh(int x) {

        return x == t[t[x].f].ch[];

    }

    void paint(int x, int d) {

        t[x].tag += d;

        t[x].reg += d;

    }

    void pushdown(int x) {

        if(t[x].tag) {

            paint(t[x].ch[], t[x].tag);

            paint(t[x].ch[], t[x].tag);

            t[x].tag = ;

        }

    }

    void pd(int x) {

        if(!isr(x)) {

            pd(t[x].f);

        }

        pushdown(x);

    }

    void rotate(int x) {

        int y = t[x].f, z = t[y].f, w = wh(x);

        if(!isr(y)) {

            t[z].ch[wh(y)] = x;

        }

        t[x].f = z;

        t[y].ch[w] = t[x].ch[w ^ ];

        t[t[x].ch[w ^ ]].f = y;

        t[y].f = x;

        t[x].ch[w ^ ] = y;

    }

    void splay(int x) {

        pd(x);

        for(; !isr(x); rotate(x)) {

            if(!isr(t[x].f)) {

                rotate(wh(t[x].f) == wh(x) ? t[x].f : x);

            }

        }

    }

    void access(int x) {

        for(int y = ; x; y = x, x = t[x].f) {

            splay(x);

            t[x].ch[] = y;

        }

    }

    void link(int u, int v) {

        access(u);

        splay(u);

        access(v);

        splay(v);

        paint(v, t[u].reg);

        t[u].f = v;

    }

    void cut(int u, int v) {

        access(u);

        splay(u);

        t[u].ch[] = ;

        t[v].f = ;

        paint(v, -t[u].reg);

    }

}

namespace SAM

{

    struct node {

        int ch[];

        int par, val;

    } t[N << ];

    int root = , sz = ;

    int nw(int x) {

        t[++sz].val = x;

        return sz;

    }

    int extend(int last, int c) {

        int p = last, np = nw(t[p].val + );

        lct::t[np].reg = ;

        while(p && !t[p].ch[c]) {

            t[p].ch[c] = np;

            p = t[p].par;

        }

        if(!p) {

            t[np].par = root;

            lct::link(np, root);

        } else {

            int q = t[p].ch[c];

            if(t[q].val == t[p].val + ) {

                t[np].par = q;

                lct::link(np, q);

            } else {

                int nq = nw(t[p].val + );

                lct::link(nq, t[q].par);

                lct::cut(q, t[q].par);

                lct::link(np, nq);

                lct::link(q, nq);

                t[nq].par = t[q].par;

                t[np].par = t[q].par = nq;

                memcpy(t[nq].ch, t[q].ch, sizeof(t[q].ch));

                while(p && t[p].ch[c] == q) {

                    t[p].ch[c] = nq;

                    p = t[p].par;

                }

            }

        }

        sum += t[np].val - t[t[np].par].val;

        return np;

    }

    void solve(char *s) {

        int len = strlen(s), now = root;

        for(int i = ; i < len; ++i) {

            if(!t[now].ch[s[i] - 'a']) {

                puts("");

                return;

            }

            now = t[now].ch[s[i] - 'a'];

        }

        lct::pd(now);

        printf("%d\n", lct::t[now].reg);

        lct::splay(now);

    }

}

void link(int u, int v, int w) {

    e[++cnt].nxt = h[u];

    h[u] = cnt;

    e[cnt].to = v;

    e[cnt].w = w;

}

void dfs(int u, int last) {

    for(int i = h[u]; i; i = e[i].nxt) {

        if(e[i].to == last) {

            continue;

        }

        pos[e[i].to] = SAM::extend(pos[u], e[i].w);

        dfs(e[i].to, u);

    }

    h[u] = ;

}

int main() {

//    freopen("1.out", "w", stdout);

    int laji;

    scanf("%d%d", &laji, &n);

    for(int i = ; i < n; ++i) {

        int u, v;

        scanf("%d%d%s", &u, &v, s);

        link(u, v, s[] - 'a');

        link(v, u, s[] - 'a');

    }

    pos[] = ;

    dfs(, );

    scanf("%d", &m);

    while(m--) {

        int opt;

        scanf("%d", &opt);

        if(opt == ) {

            printf("%lld\n", sum);

        } else if(opt == ) {

            int rt, sz;

            scanf("%d%d", &rt, &sz);

            while(--sz) {

                int u, v;

                scanf("%d%d%s", &u, &v, s);

                link(u, v, s[] - 'a');

                link(v, u, s[] - 'a');

            }

            dfs(rt, );

        } else {

            scanf("%s", s);

            SAM::solve(s);

        }

    }

    return ;

}