//案2
#include<bits/stdc++.h>
typedef long long int ll;
typedef unsigned long long int ull;
#define BIG_NUM 2000000000
#define HUGE_NUM 99999999999999999
#define MOD 1000000007
#define EPS 0.000000001
using namespace std;


#define NUM 100005

struct Edge{
	Edge(int arg_to,ll arg_cost){
		to = arg_to;
		cost = arg_cost;
	}
	int to;
	ll cost;
};

struct Info{

	Info(){
		to_root_sum_cost = 0;
		to_leaf_sum_cost = 0;
		node_sum_cost = 0;
		original_to_root_cost = 0;
	}
	Info(ll arg_to_root_sum_cost,ll arg_to_leaf_sum_cost,ll arg_node_sum_cost,ll arg_original_to_root_cost){
		to_root_sum_cost = arg_to_root_sum_cost;
		to_leaf_sum_cost = arg_to_leaf_sum_cost;
		node_sum_cost = arg_node_sum_cost;
		original_to_root_cost = arg_original_to_root_cost;
	}

	ll to_root_sum_cost, //根方向の辺に累積された太さ
	   to_leaf_sum_cost, //葉方向の辺に累積された太さ
	   node_sum_cost, //区間の総コスト
	   original_to_root_cost; //根方向の辺の、オリジナルの太さ
};

struct Data{
	int parent,head,depth,weight;
	ll to_root_cost,sum_add_cost;
};

int V,N;
int root,global_index;
int index_table[NUM];
ll K;
Data data[NUM];
Info  table[8*NUM]; //セグ木
vector<Edge> G[NUM];

void init(int first_N){
	while(N < first_N)N *= 2;
}

Info merge(Info a,Info b){

	if(a.to_leaf_sum_cost == -1)return b;
	if(b.to_leaf_sum_cost == -1)return a;

    Info ret = Info(a.to_root_sum_cost,b.to_leaf_sum_cost,
    		a.node_sum_cost+b.node_sum_cost,a.original_to_root_cost);

    ll tmp_cost = a.to_leaf_sum_cost+b.to_root_sum_cost+b.original_to_root_cost;

    if(tmp_cost%K != 0){
    	ret.node_sum_cost += tmp_cost;
    }

    return ret;
}

void add(int loc,ll value){

	loc += N-1;

	table[loc].to_root_sum_cost += value; //根方向に加算
	table[loc].to_leaf_sum_cost += value; //葉方向に加算

	int parent = (loc-1)/2;
	int left_child,right_child;

	while(true){

		left_child = 2*parent+1; //根に近い子
		right_child = 2*parent+2; //葉に近い子

		table[parent] = merge(table[left_child], table[right_child]);

		if(parent == 0){

			break;

		}else{

			parent = (parent-1)/2;
		}
	}
}

int makeTree(int node_id,int parent,int depth,ll to_root_cost){

	data[node_id].depth = depth;
	data[node_id].parent = parent;
	data[node_id].to_root_cost = to_root_cost;
	data[node_id].weight = 1;

	int child;

	for(int i = 0; i < G[node_id].size(); i++){

		child = G[node_id][i].to;
		if(child == parent)continue;

		data[node_id].weight += makeTree(child,node_id,depth+1,G[node_id][i].cost);
	}

	return data[node_id].weight;
}

void HLD(int node_id,int head,int parent){

	index_table[node_id] = global_index++; //★★根に近いものほど、番号が小さい(★左にある★)
	data[node_id].head = head;

	if(G[node_id].size() == 0)return;

	//子の中で、最大の重み(部分木のノード数)を持つものを探す
	int max_weight = -BIG_NUM;
	int max_node_id = -1,child;

	for(int i = 0; i < G[node_id].size(); i++){

		child = G[node_id][i].to;
		if(child == parent)continue;

		if(max_weight < data[child].weight){

			max_weight = data[child].weight;
			max_node_id = child;
		}
	}

	if(max_node_id == -1)return;

	//最大の重みを持つ子へ(headは変わらず)
	HLD(max_node_id,head,node_id);

	//その他の子を処理(新しいラインを作る)
	for(int i = 0; i < G[node_id].size(); i++){

		child = G[node_id][i].to;
		if(child == parent || child == max_node_id)continue;

		HLD(child,child,node_id);
	}
}

//セグ木には、%Kの判定が済んだ値が保存されている
Info query(int search_left,int search_right,int node_id,int node_left,int node_right){

	//範囲外
	if(search_right < node_left || search_left > node_right)return Info(-1,-1,-1,-1);

	//今回のノードの区間が、検索区間の部分区間である場合
	if(search_left <= node_left && search_right >= node_right){
		return table[node_id];
	}

	//今回のノードの区間に、一部検索区間と重なっている区間がある場合→再帰的に子どもに尋ねる
	Info left_info = query(search_left,search_right,2*node_id+1,node_left,(node_left+node_right)/2);
	Info right_info = query(search_left,search_right,2*node_id+2,(node_left+node_right)/2+1,node_right);

	return merge(left_info,right_info);
}

ll query(int from,int to){

	return query(index_table[from],index_table[to],0,0,N-1).node_sum_cost;
}

int LCA(int a,int b){

	int head_a,head_b;

	while(true){

		head_a = data[a].head;
		head_b = data[b].head;

		//aとbが同じラインに属する場合
		if(head_a == head_b){
			//より根に近い方を返す
			if(data[a].depth < data[b].depth){

				return a;
			}else{

				return b;
			}
		}

		//深い方のhead_nodeを、そのparentに切り替える
		if(data[head_a].depth > data[head_b].depth){

			a = data[head_a].parent;
		}else{

			b = data[head_b].parent;
		}
	}
}

//node_id～rootへのコストを求める
ll get_cost(int node_id){

	ll ret = 0;
	ll tmp,add_cost;
	int head_node;

	while(true){

		head_node = data[node_id].head;

		//node_id～同じラインのヘッドのコストを求める(セグ木演算)
		tmp = query(head_node,node_id);

		ret += tmp;

		if(head_node == root)break; //rootまで到達したらbreak

		add_cost =  data[head_node].to_root_cost //headのオリジナルの根方向への太さ
				  + data[head_node].sum_add_cost //headの、根方向への累積
				  + data[data[head_node].parent].sum_add_cost; //ヘッドの親の、葉方向への累積

		if(add_cost%K != 0){

			ret += add_cost;
		}

		node_id = data[head_node].parent;
	}

	return ret;
}

ll send(int from,int to){

	ll A = get_cost(from); //from～rootのコスト
	ll B = get_cost(to); //to～rootのコスト
	ll C = get_cost(LCA(from,to)); //LCA(from,to)～rootのコスト

	return A+B-2*C;
}

int main(){

	int first_N;

	scanf("%d %lld",&first_N,&K);

	int from,to;
	ll cost;

	for(int loop = 0; loop < first_N-1; loop++){

		scanf("%d %d %lld",&from,&to,&cost);
		G[from].push_back(Edge(to,cost));
		G[to].push_back(Edge(from,cost));
	}

	root = 0;

	makeTree(root,-1,0,0);
	global_index = 0;
	HLD(root,root,-1);  //0スタートでdfs木を作ったので、0がrootとなる

	//dfs木をセグメント木に変換する
	N = 1;
	init(first_N);

	int tmp_index;

	for(int i = 0; i < first_N; i++){

		tmp_index = index_table[i]+(N-1); //ノードの、セグ木におけるインデックス
		table[tmp_index].original_to_root_cost = data[i].to_root_cost;
		data[i].sum_add_cost = 0;
	}

	for(int i = 0; i < N; i++){

		add(i,0); //セグ木の構築
	}

	int num_query;
	scanf("%d",&num_query);

	int node_id;
	char buf[5];

	for(int loop = 0; loop < num_query; loop++){

		scanf("%s",buf);

		if(buf[0] == 'a'){ //add命令

			scanf("%d %lld",&node_id,&cost);
			add(index_table[node_id],cost); //セグ木に加算
			data[node_id].sum_add_cost += cost;

		}else{ //send命令

			scanf("%d %d",&from,&to);
			printf("%lld\n",send(from,to));
		}
	}

	return 0;
}



Measured memory_bytes: 46572