Problem: Hanh is a famous biologist. He loves growing trees and doing experiments on his own garden.

One day, he got a tree consisting of n vertices. Vertices are numbered from 1 to n. A tree with n vertices is an undirected connected graph with n-1 edges. Initially, Hanh sets the value of every vertex to 0.

Now, Hanh performs q operations, each is either of the following types: 

  * Type 1: Hanh selects a vertex v and an integer d. Then he chooses some vertex r uniformly at random, lists all vertices u such that the path from r to u passes through v. Hanh then increases the value of all such vertices u by d. 
  * Type 2: Hanh selects a vertex v and calculates the expected value of v. 



Since Hanh is good at biology but not math, he needs your help on these operations.

Input

The first line contains two integers n and q (1 ≤ n, q ≤ 150 000) — the number of vertices on Hanh's tree and the number of operations he performs.

Each of the next n - 1 lines contains two integers u and v (1 ≤ u, v ≤ n), denoting that there is an edge connecting two vertices u and v. It is guaranteed that these n - 1 edges form a tree.

Each of the last q lines describes an operation in either formats: 

  * 1 v d (1 ≤ v ≤ n, 0 ≤ d ≤ 10^7), representing a first-type operation. 
  * 2 v (1 ≤ v ≤ n), representing a second-type operation. 



It is guaranteed that there is at least one query of the second type.

Output

For each operation of the second type, write the expected value on a single line. 

Let M = 998244353, it can be shown that the expected value can be expressed as an irreducible fraction p/q, where p and q are integers and q not ≡ 0 \pmod{M}. Output the integer equal to p ⋅ q^{-1} mod M. In other words, output such an integer x that 0 ≤ x < M and x ⋅ q ≡ p \pmod{M}.

Example

Input


5 12
1 2
1 3
2 4
2 5
1 1 1
2 1
2 2
2 3
2 4
2 5
1 2 2
2 1
2 2
2 3
2 4
2 5


Output


1
199648871
399297742
199648871
199648871
598946614
199648873
2
2
2

Note

The image below shows the tree in the example:

<image>

For the first query, where v = 1 and d = 1: 

  * If r = 1, the values of all vertices get increased. 
  * If r = 2, the values of vertices 1 and 3 get increased. 
  * If r = 3, the values of vertices 1, 2, 4 and 5 get increased. 
  * If r = 4, the values of vertices 1 and 3 get increased. 
  * If r = 5, the values of vertices 1 and 3 get increased. 



Hence, the expected values of all vertices after this query are (1, 0.4, 0.8, 0.4, 0.4).

For the second query, where v = 2 and d = 2: 

  * If r = 1, the values of vertices 2, 4 and 5 get increased. 
  * If r = 2, the values of all vertices get increased. 
  * If r = 3, the values of vertices 2, 4 and 5 get increased. 
  * If r = 4, the values of vertices 1, 2, 3 and 5 get increased. 
  * If r = 5, the values of vertices 1, 2, 3 and 4 get increased. 



Hence, the expected values of all vertices after this query are (2.2, 2.4, 2, 2, 2).

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
template <class C>
constexpr int sz(const C &c) {
  return int(c.size());
}
using ll = long long;
constexpr const char nl = '\n', sp = ' ';
template <class T>
struct FenwickTreeRangePoint1D {
  int N;
  vector<T> BIT;
  FenwickTreeRangePoint1D(int N) : N(N), BIT(N + 1, T()) {}
  template <class It>
  FenwickTreeRangePoint1D(It st, It en) : FenwickTreeRangePoint1D(en - st) {
    adjacent_difference(st, en, BIT.begin() + 1);
    for (int i = 1; i <= N; i++) {
      int j = i + (i & -i);
      if (j <= N) BIT[j] += BIT[i];
    }
  }
  vector<T> values() {
    vector<T> ret(BIT.begin() + 1, BIT.end());
    for (int i = N; i >= 1; i--) {
      int j = i + (i & -i);
      if (j <= N) ret[j - 1] -= ret[i - 1];
    }
    partial_sum(ret.begin(), ret.end(), ret.begin());
    return ret;
  }
  void update(int i, T v) {
    for (i++; i <= N; i += i & -i) BIT[i] += v;
  }
  void update(int l, int r, T v) {
    update(l, v);
    update(r + 1, -v);
  }
  T get(int i) {
    T ret = T();
    for (i++; i > 0; i -= i & -i) ret += BIT[i];
    return ret;
  }
};
template <class T>
T posMod(T a, T mod) {
  T ret = -mod < a && a < mod ? a : a % mod;
  return 0 <= ret ? ret : ret + mod;
}
template <class T>
T addMod(T a, T b, T mod) {
  T ret = a + b;
  return ret < mod ? ret : ret - mod;
}
template <class T>
T subMod(T a, T b, T mod) {
  T ret = a - b;
  return 0 <= ret ? ret : ret + mod;
}
template <class T>
T mulMod(T a, T b, T mod) {
  return a * b % mod;
}
template <class T, class U>
T powMod(T base, U pow, T mod) {
  T x = 1;
  for (; pow > 0; pow >>= 1, base = mulMod(base, base, mod))
    if (pow & 1) x = mulMod(x, base, mod);
  return x;
}
template <class T>
T mulInvModPrime(T a, T p) {
  return powMod(a, p - 2, p);
}
const ll MOD = 998244353;
const int MAXNQ = 150005;
int N, Q, SZ[MAXNQ], pre[MAXNQ], post[MAXNQ], cur = -1;
vector<int> adj[MAXNQ];
vector<pair<int, pair<int, int>>> adj2[MAXNQ];
int dfs1(int v, int prev) {
  SZ[v] = 1;
  auto it = find(adj[v].begin(), adj[v].end(), prev);
  if (it != adj[v].end()) adj[v].erase(it);
  for (int w : adj[v]) SZ[v] += dfs1(w, v);
  return SZ[v];
}
void dfs2(int v, int prev) {
  sort(adj[v].begin(), adj[v].end(),
       [&](const int &x, const int &y) { return SZ[x] < SZ[y]; });
  pre[v] = ++cur;
  for (int w : adj[v]) dfs2(w, v);
  for (int i = 0, j; i < sz(adj[v]); i = j) {
    for (j = i; j < sz(adj[v]) && SZ[adj[v][i]] == SZ[adj[v][j]]; j++)
      ;
    adj2[v].emplace_back(SZ[adj[v][i]],
                         make_pair(pre[adj[v][i]], post[adj[v][j - 1]]));
  }
  post[v] = cur;
  if (prev != -1) {
    adj2[v].emplace_back(N - SZ[v], make_pair(0, pre[v] - 1));
    adj2[v].emplace_back(N - SZ[v], make_pair(post[v] + 1, N - 1));
  }
}
int main() {
  ios::sync_with_stdio(0);
  cin.tie(0);
  cout.tie(0);
  cin >> N >> Q;
  FenwickTreeRangePoint1D<ll> ft(N);
  for (int i = 0; i < N - 1; i++) {
    int a, b;
    cin >> a >> b;
    adj[--a].push_back(--b);
    adj[b].push_back(a);
  }
  dfs1(0, -1);
  dfs2(0, -1);
  ll invN = mulInvModPrime(ll(N), MOD), add = 0;
  for (int i = 0; i < Q; i++) {
    int t;
    cin >> t;
    if (t == 1) {
      int v;
      ll d;
      cin >> v >> d;
      --v;
      add = addMod(add, mulMod(ll(N), d, MOD), MOD);
      for (auto &&s : adj2[v])
        ft.update(s.second.first, s.second.second, posMod(s.first * d, MOD));
    } else {
      int v;
      cin >> v;
      --v;
      cout << mulMod(subMod(add, posMod(ft.get(pre[v]), MOD), MOD), invN, MOD)
           << nl;
    }
  }
  return 0;
}