#include <bits/stdc++.h>
#define mod 1000000007
#define mod998 998244353
#define sp ' '
#define intmax 2147483647
#define llmax 9223372036854775807
#define mkp make_pair
typedef long long ll;
using namespace std;

struct edge {
	int to, di, co;
};
struct query {
	int co, di, pm, num;
};

int N, Q, a, b, c, d, cnt, A[100000], res[100000], col[100000], s, cols[100000];
bool vis[100000];
pair<int, int>tree[1 << 19];
vector<edge>v[100000];
vector<query>q[100000];

void dfs(int x, int dep) {
	vis[x] = true;
	A[x] = cnt - (1 << 18);
	tree[cnt] = mkp(dep, x);
	++cnt;
	for (edge e : v[x]) {
		if (!vis[e.to]) {
			dfs(e.to, dep + 1);
			tree[cnt] = mkp(dep, x);
			++cnt;
		}
	}
}

pair<int,int> calc(int l, int r, int p, int q, int k) {
	if (q < l || r < p)return mkp(0xE869120, -1);
	if (p <= l&&r <= q)return tree[k];
	return min(calc(l, (l + r) / 2, p, q, k * 2), calc((l + r) / 2 + 1, r, p, q, k * 2 + 1));
}


int LCA(int x, int y) {
	return calc(0, (1 << 18) - 1, min(A[x], A[y]), max(A[x], A[y]), 1).second;
}

void dfs2(int x) {
	vis[x] = false;
	for (query u : q[x]) {
		res[u.num] += (s + col[u.co] * u.di - cols[u.co])*u.pm;
	}
	for (edge e : v[x]) {
		if (vis[e.to]) {
			s += e.di;
			col[e.co]++;
			cols[e.co] += e.di;
			dfs2(e.to);
			s -= e.di;
			col[e.co]--;
			cols[e.co] -= e.di;
		}
	}
}

int main() {
	cin >> N >> Q;
	for (int i = 1; i < N; ++i) {
		cin >> a >> b >> c >> d;
		--a;
		--b;
		v[a].push_back({ b, d, c });
		v[b].push_back({ a, d, c });
	}
	cnt = (1 << 18);
	dfs(0, 0);
	for (int i = (1 << 18) - 1; i; --i) {
		tree[i] = min(tree[i * 2], tree[i * 2 + 1]);
	}
	for (int i = 0; i < Q; ++i) {
		int x, y, u, v;
		cin >> x >> y >> u >> v;
		--u;
		--v;
		q[u].push_back({ x, y, 1, i });
		q[v].push_back({ x, y, 1, i });
		q[LCA(u, v)].push_back({ x, y, -2, i });
	}
	dfs2(0);
	for (int i = 0; i < Q; ++i) {
		cout << res[i] << endl;
	}
}
### Prompt

In cpp, your task is to solve the following problem:

There is a tree with N vertices numbered 1 to N. The i-th edge in this tree connects Vertex a_i and Vertex b_i, and the color and length of that edge are c_i and d_i, respectively. Here the color of each edge is represented by an integer between 1 and N-1 (inclusive). The same integer corresponds to the same color, and different integers correspond to different colors.

Answer the following Q queries:

* Query j (1 \leq j \leq Q): assuming that the length of every edge whose color is x_j is changed to y_j, find the distance between Vertex u_j and Vertex v_j. (The changes of the lengths of edges do not affect the subsequent queries.)

Constraints

* 2 \leq N \leq 10^5
* 1 \leq Q \leq 10^5
* 1 \leq a_i, b_i \leq N
* 1 \leq c_i \leq N-1
* 1 \leq d_i \leq 10^4
* 1 \leq x_j \leq N-1
* 1 \leq y_j \leq 10^4
* 1 \leq u_j < v_j \leq N
* The given graph is a tree.
* All values in input are integers.

Input

Input is given from Standard Input in the following format:


N Q
a_1 b_1 c_1 d_1
:
a_{N-1} b_{N-1} c_{N-1} d_{N-1}
x_1 y_1 u_1 v_1
:
x_Q y_Q u_Q v_Q


Output

Print Q lines. The j-th line (1 \leq j \leq Q) should contain the answer to Query j.

Example

Input

5 3
1 2 1 10
1 3 2 20
2 4 4 30
5 2 1 40
1 100 1 4
1 100 1 5
3 1000 3 4


Output

130
200
60

### Response

```cpp
#include <bits/stdc++.h>
#define mod 1000000007
#define mod998 998244353
#define sp ' '
#define intmax 2147483647
#define llmax 9223372036854775807
#define mkp make_pair
typedef long long ll;
using namespace std;

struct edge {
	int to, di, co;
};
struct query {
	int co, di, pm, num;
};

int N, Q, a, b, c, d, cnt, A[100000], res[100000], col[100000], s, cols[100000];
bool vis[100000];
pair<int, int>tree[1 << 19];
vector<edge>v[100000];
vector<query>q[100000];

void dfs(int x, int dep) {
	vis[x] = true;
	A[x] = cnt - (1 << 18);
	tree[cnt] = mkp(dep, x);
	++cnt;
	for (edge e : v[x]) {
		if (!vis[e.to]) {
			dfs(e.to, dep + 1);
			tree[cnt] = mkp(dep, x);
			++cnt;
		}
	}
}

pair<int,int> calc(int l, int r, int p, int q, int k) {
	if (q < l || r < p)return mkp(0xE869120, -1);
	if (p <= l&&r <= q)return tree[k];
	return min(calc(l, (l + r) / 2, p, q, k * 2), calc((l + r) / 2 + 1, r, p, q, k * 2 + 1));
}


int LCA(int x, int y) {
	return calc(0, (1 << 18) - 1, min(A[x], A[y]), max(A[x], A[y]), 1).second;
}

void dfs2(int x) {
	vis[x] = false;
	for (query u : q[x]) {
		res[u.num] += (s + col[u.co] * u.di - cols[u.co])*u.pm;
	}
	for (edge e : v[x]) {
		if (vis[e.to]) {
			s += e.di;
			col[e.co]++;
			cols[e.co] += e.di;
			dfs2(e.to);
			s -= e.di;
			col[e.co]--;
			cols[e.co] -= e.di;
		}
	}
}

int main() {
	cin >> N >> Q;
	for (int i = 1; i < N; ++i) {
		cin >> a >> b >> c >> d;
		--a;
		--b;
		v[a].push_back({ b, d, c });
		v[b].push_back({ a, d, c });
	}
	cnt = (1 << 18);
	dfs(0, 0);
	for (int i = (1 << 18) - 1; i; --i) {
		tree[i] = min(tree[i * 2], tree[i * 2 + 1]);
	}
	for (int i = 0; i < Q; ++i) {
		int x, y, u, v;
		cin >> x >> y >> u >> v;
		--u;
		--v;
		q[u].push_back({ x, y, 1, i });
		q[v].push_back({ x, y, 1, i });
		q[LCA(u, v)].push_back({ x, y, -2, i });
	}
	dfs2(0);
	for (int i = 0; i < Q; ++i) {
		cout << res[i] << endl;
	}
}
```