#include<cstdio>
#include<algorithm>
#define L 1<<23
#define C (c=*A++)
#define ENS
#define NES
#define N 100007
using namespace std;
struct Athy {
    long long x;
    int y;
    NES bool operator>(Athy &b) {
        return x > b.x;
    }
} G1[N << 2], G2[N << 1];
const long long NE = -1ll << 57;
int n, test, v1, v2, cnt, p[N], F[N], G[N], z[N], mx[N], s[N], fa[N], d[N], e[N], cd[N << 1],
    nt[N << 1], et = 1, wt, ss[19];
char fl[L], *A = fl, fll[L], *B = fll;
long long a[N], b[N];
NES void read(int &x) {
    char c;

    for (x = 0; '0' > C || c > '9';)
        ;

    while ('0' <= c && c <= '9')
        x = (x << 3) + (x << 1) + c - 48, C;
}
NES void print(long long x) {
    if (!x)
        *B++ = (48);
    else {
        for (wt = 0; x; ss[++wt] = x % 10, x /= 10)
            ;

        for (; wt; *B++ = (ss[wt--] + 48))
            ;
    }
}
NES long long max(long long a, long long b, long long c) {
    return a > b ? (a > c ? a : c) : (b > c ? b : c);
}
NES long long max(long long a, long long b) {
    return a > b ? a : b;
}
struct node {
    int n;
    Athy *f;
    NES void build(int x) {
        int y;

        for (f = &G1[v1 + 1], y = e[x]; y; y = nt[y])
            if (!z[cd[y]])
                f[F[cd[y]] = ++n].y = cd[y];

        v1 += n + 3;
    } NES void alter_F(int tmp, long long dt) {
        int tp, LIA, x;

        if (f[x = F[tmp]].x = dt, x > 1 && f[x] > f[x >> 1])
            for (swap(F[f[x].y], F[f[x >> 1].y]), swap(f[x], f[x >> 1]), x >>= 1; x > 1 &&
                    f[x] > f[x >> 1]; swap(f[x], f[x >> 1]), swap(F[f[x].y], F[f[x >> 1].y]), x >>= 1)
                ;
        else
            while ((x << 1) <= n) {
                if (f[tp = x << 1] > f[LIA = x])
                    LIA = tp;

                if ((tp |= 1) <= n && f[tp] > f[LIA])
                    LIA = tp;

                if (LIA != x)
                    swap(f[LIA], f[x]), swap(F[f[LIA].y], F[f[x].y]), x = LIA;
                else
                    break;
            }
    }
} g[N];
struct val {
    long long lm, ra, sa, sb, ia;
    NES void fix(val &l, val &r) {
        lm = max(l.lm, l.sa + r.lm), ra = max(r.sb + l.ra + r.sa, r.ra), ia = max(r.sb + l.ia, r.ia,
                                          r.sb + l.ra + r.lm), sa = l.sa + r.sa, sb = l.sb + r.sb;
    } NES void initial(int x) {
        long long mx = g[x].f[1].x, sc = max(g[x].f[2].x, g[x].f[3].x);
        ra = (lm = a[x] + mx) + b[x], ia = mx + sc + a[x] + b[x], sa = a[x], sb = b[x];
    }
} T[N << 2];
struct tree {
    int M, n, r;
    val *t;
    Athy *g;
    NES void build(int x) {
        int tmp = fa[z[x]], y;

        for (n = p[x], M = 1; M <= n; M <<= 1)
            ;

        for (t = &T[cnt + 1], g = &G2[v2 + 1], cnt += M << 1; x != tmp; x = fa[x])
            for (y = e[x]; y; y = nt[y])
                if (!z[cd[y]])
                    g[G[cd[y]] = ++r].y = cd[y];

        for (v2 += r + 1, x = M + n + 1; x < (M << 1); t[x] = (val) {
        NE, NE, 0, 0, NE
    }, x++)
        ;
    } NES void alter_G(int tmp, long long dt) {
        int tp, LIA, x;

        if (g[x = G[tmp]].x = dt, x > 1 && g[x] > g[x >> 1])
            for (swap(G[g[x].y], G[g[x >> 1].y]), swap(g[x], g[x >> 1]), x >>= 1; x > 1 &&
                    g[x] > g[x >> 1]; swap(g[x], g[x >> 1]), swap(G[g[x].y], G[g[x >> 1].y]), x >>= 1)
                ;
        else
            while ((x << 1) <= r) {
                if (g[tp = x << 1] > g[LIA = x])
                    LIA = tp;

                if ((tp |= 1) <= r && g[tp] > g[LIA])
                    LIA = tp;

                if (LIA != x)
                    swap(g[LIA], g[x]), swap(G[g[LIA].y], G[g[x].y]), x = LIA;
                else
                    break;
            }
    } NES void alter_a(int x, int dt) {
        for (t[x = p[x] + M].sb += dt, t[x].ra += dt, t[x].ia += dt, x >>= 1; x;
                t[x].fix(t[x << 1], t[x << 1 | 1]), x >>= 1)
            ;
    } NES void alter_c(int x) {
        for (t[p[x] + M].initial(x), x = (p[x] + M) >> 1; x; t[x].fix(t[x << 1], t[x << 1 | 1]), x >>= 1)
            ;
    }
} t[N];
struct ques {
    int qx, qy, tmp, LIA;
    NES void initial() {
        int x, y, nt;

        for (read(qx), read(qy), read(tmp), x = qx, y = qy; z[x] != z[y];
                d[z[x]] > d[z[y]] ? x = fa[z[x]] : y = fa[z[y]])
            ;

        LIA = d[x] > d[y] ? y : x;

        if (x = qx, y = qy, b[x] += tmp, b[y] += tmp, a[LIA] += tmp, b[LIA] -= (long long)tmp << 1,
                z[x] != z[LIA]) {
            for (t[z[x]].alter_a(x, tmp); (nt = z[fa[x = z[x]]]) != z[LIA]; x = nt) {
                long long tp;

                if ((tp = max(t[x].t[1].lm, g[x].f[1].x)) != g[fa[x]].f[F[x]].x)
                    g[fa[x]].alter_F(x, tp);

                if ((tp = max(t[x].t[1].ia, t[x].g[1].x)) != t[nt].g[G[x]].x)
                    t[nt].alter_G(x, tp);

                b[fa[x]] += tmp, t[nt].alter_c(fa[x]);
            }

            long long tp;

            if ((tp = max(t[x].t[1].lm, g[x].f[1].x)) != g[fa[x]].f[F[x]].x)
                g[fa[x]].alter_F(x, tp);

            if ((tp = max(t[x].t[1].ia, t[x].g[1].x)) != t[nt].g[G[x]].x)
                t[nt].alter_G(x, tp);

            if (b[x = fa[x]] += tmp, x != LIA)
                t[nt].alter_c(x);
        } else if (x != LIA)
            t[z[x]].alter_a(x, tmp);

        if (z[y] != z[LIA]) {
            for (t[z[y]].alter_a(y, tmp); (nt = z[fa[y = z[y]]]) != z[LIA]; y = nt) {
                long long tp;

                if ((tp = max(t[y].t[1].lm, g[y].f[1].x)) != g[fa[y]].f[F[y]].x)
                    g[fa[y]].alter_F(y, tp);

                if ((tp = max(t[y].t[1].ia, t[y].g[1].x)) != t[nt].g[G[y]].x)
                    t[nt].alter_G(y, tp);

                b[fa[y]] += tmp, t[nt].alter_c(fa[y]);
            }

            long long tp;

            if ((tp = max(t[y].t[1].lm, g[y].f[1].x)) != g[fa[y]].f[F[y]].x)
                g[fa[y]].alter_F(y, tp);

            if ((tp = max(t[y].t[1].ia, t[y].g[1].x)) != t[nt].g[G[y]].x)
                t[nt].alter_G(y, tp);

            if (b[y = fa[y]] += tmp, y != LIA)
                t[nt].alter_c(y);
        } else if (y != LIA)
            t[z[y]].alter_a(y, tmp);

        for (t[x = z[LIA]].alter_c(LIA); nt = z[fa[x]]; x = nt) {
            long long tp, l1 = g[fa[x]].f[1].x, l2 = t[nt].g[1].x, l3 = max(g[fa[x]].f[2].x, g[fa[x]].f[3].x);

            if ((tp = max(t[x].t[1].lm, g[x].f[1].x)) != g[fa[x]].f[F[x]].x)
                g[fa[x]].alter_F(x, tp);

            if ((tp = max(t[x].t[1].ia, t[x].g[1].x)) != t[nt].g[G[x]].x)
                t[nt].alter_G(x, tp);

            if (g[fa[x]].f[1].x != l1 || (max(g[fa[x]].f[2].x, g[fa[x]].f[3].x)) != l3)
                t[nt].alter_c(fa[x]);
            else if (t[nt].g[1].x == l2)
                break;
        }
    } NES void del() {
        int x, y, nt;

        for (x = qx, y = qy, tmp = -tmp; z[x] != z[y]; d[z[x]] > d[z[y]] ? x = fa[z[x]] : y = fa[z[y]])
            ;

        LIA = d[x] > d[y] ? y : x;

        if (x = qx, y = qy, b[x] += tmp, b[y] += tmp, a[LIA] += tmp, b[LIA] -= (long long)tmp << 1,
                z[x] != z[LIA]) {
            for (t[z[x]].alter_a(x, tmp); (nt = z[fa[x = z[x]]]) != z[LIA]; x = nt) {
                long long tp;

                if ((tp = max(t[x].t[1].lm, g[x].f[1].x)) != g[fa[x]].f[F[x]].x)
                    g[fa[x]].alter_F(x, tp);

                if ((tp = max(t[x].t[1].ia, t[x].g[1].x)) != t[nt].g[G[x]].x)
                    t[nt].alter_G(x, tp);

                b[fa[x]] += tmp, t[nt].alter_c(fa[x]);
            }

            long long tp;

            if ((tp = max(t[x].t[1].lm, g[x].f[1].x)) != g[fa[x]].f[F[x]].x)
                g[fa[x]].alter_F(x, tp);

            if ((tp = max(t[x].t[1].ia, t[x].g[1].x)) != t[nt].g[G[x]].x)
                t[nt].alter_G(x, tp);

            if (b[x = fa[x]] += tmp, x != LIA)
                t[nt].alter_c(x);
        } else if (x != LIA)
            t[z[x]].alter_a(x, tmp);

        if (z[y] != z[LIA]) {
            for (t[z[y]].alter_a(y, tmp); (nt = z[fa[y = z[y]]]) != z[LIA]; y = nt) {
                long long tp;

                if ((tp = max(t[y].t[1].lm, g[y].f[1].x)) != g[fa[y]].f[F[y]].x)
                    g[fa[y]].alter_F(y, tp);

                if ((tp = max(t[y].t[1].ia, t[y].g[1].x)) != t[nt].g[G[y]].x)
                    t[nt].alter_G(y, tp);

                b[fa[y]] += tmp, t[nt].alter_c(fa[y]);
            }

            long long tp;

            if ((tp = max(t[y].t[1].lm, g[y].f[1].x)) != g[fa[y]].f[F[y]].x)
                g[fa[y]].alter_F(y, tp);

            if ((tp = max(t[y].t[1].ia, t[y].g[1].x)) != t[nt].g[G[y]].x)
                t[nt].alter_G(y, tp);

            if (b[y = fa[y]] += tmp, y != LIA)
                t[nt].alter_c(y);
        } else if (y != LIA)
            t[z[y]].alter_a(y, tmp);

        for (t[x = z[LIA]].alter_c(LIA); nt = z[fa[x]]; x = nt) {
            long long tp, l1 = g[fa[x]].f[1].x, l2 = t[nt].g[1].x, l3 = max(g[fa[x]].f[2].x, g[fa[x]].f[3].x);

            if ((tp = max(t[x].t[1].lm, g[x].f[1].x)) != g[fa[x]].f[F[x]].x)
                g[fa[x]].alter_F(x, tp);

            if ((tp = max(t[x].t[1].ia, t[x].g[1].x)) != t[nt].g[G[x]].x)
                t[nt].alter_G(x, tp);

            if (g[fa[x]].f[1].x != l1 || (max(g[fa[x]].f[2].x, g[fa[x]].f[3].x)) != l3)
                t[nt].alter_c(fa[x]);
            else if (t[nt].g[1].x == l2)
                break;
        }
    }
} q[N];
NES void dfs(int x, int fe) {
    s[x] = 1;

    for (int y = e[x]; y; y = nt[y])
        if (y != fe &&
                (fa[cd[y]] = x, d[cd[y]] = d[x] + 1, dfs(cd[y], y ^ 1), s[x] += s[cd[y]], s[cd[y]] > s[mx[x]]))
            mx[x] = cd[y];
}
NES void vfs(int x, int chain) {
    if (z[x] = chain, mx[x])
        p[mx[x]] = p[x] + 1, vfs(mx[x], chain);
    else
        t[chain].build(x);

    g[x].build(x);

    for (int y = e[x]; y; y = nt[y])
        if (!z[cd[y]])
            vfs(cd[y], cd[y]);
}
ENS main() {
    int i, x, y, ti;
    char c;

    for (fl[fread(fl, 1, L, stdin)] = EOF, read(n), read(test), i = 1; i < n;
            read(x), read(y), cd[++et] = y, nt[et] = e[x], e[x] = et, cd[++et] = x, nt[et] = e[y], e[y] = et,
            i++)
        ;

    for (dfs(1, 0), vfs(1, 1), ti = 1; ti <= test;
            ti++, print(max(t[1].g[1].x, t[1].t[1].ia)), *B++ = '\n') {
        while (C != '+' && c != '-')
            ;

        if (c == '+')
            q[ti].initial();
        else
            read(x), q[x].del();
    }

    fwrite(fll, 1, B - fll, stdout);
}