#include <bits/stdc++.h>

using namespace std;

long long Nodes[25];
long long Sons[25];

const long long INF = 1e18 + 10;

unordered_map<long long, int> Map;
vector<long long> V;
vector<vector<long long>> Queries;
int vals;

int getDepth(long long n) {
	n -= 1;
	long long s = 0, aux = n, d;
	for(d = 0; n >= 0 && d <= 7; d += 1) {
		n -= Nodes[d];
	}
	if(n >= 0) return 8;
	return d - 1;
}

long long getParent(long long n) {
	int d = getDepth(n);
	n -= 1;

	long long bias = 0;
	for(int i = 0; i < d; ++i) {
		n -= Nodes[i];
		bias += Nodes[i];
	}
	assert(n >= 0);
	bias -= Nodes[d - 1];

	//Avem sons * Nodes[d - 1] fii in total
	return bias + (n / Sons[d]) + 1;
}

long long getLca(long long a, long long b) {
	if(a > b) swap(a, b);

	int diff = getDepth(b) - getDepth(a);
	while(diff--) b = getParent(b);

	while(a != b) {
		a = getParent(a);
		b = getParent(b);
	}
	return a;
}

long long T[1000005];
bool Active[500005];
void add(int node, int b, int e, int pos, long long d) {
	if(b == e) {
		if(!Active[pos]) {
			Active[pos] = 1;
			T[node] = 0;
		}
		T[node] += d;
	}
	else {
		int m = (b + e) >> 1;
		if(m >= pos) {
			add(node * 2, b, m, pos, d);
		} else {
			add(node * 2 + 1, m + 1, e, pos, d);
		}
		T[node] = max(T[node * 2], T[node * 2 + 1]);
	}
}

long long query(int node, int b, int e, int x, int y) {
	if(b >= x && e <= y) return T[node];
	if(x > e || y < b) return -INF;
	int m = b + e >> 1;
	return max(query(node * 2, b, m, x, y),
			   query(node * 2 + 1, m + 1, e, x, y));
}

void build(int node, int b, int e) {
	T[node] = -INF;
	if(b == e) return;
	int m = b + e >> 1;
	build(node * 2, b, m);
	build(node * 2 + 1, m + 1, e);
}

void dump(int node, int b, int e) {
	cerr << node << " " << b << " " << e << " " << T[node] << '\n';
	if(b == e) return;
	int m = b + e >> 1;
	dump(node * 2, b, m);
	dump(node * 2 + 1, m + 1, e);
}

int main() {
	Nodes[0] = Nodes[1] = 1;
	Sons[0] = 1;
	Sons[1] = 2;

	for(int i = 2; i <= 7; ++i) {
		Nodes[i] = Nodes[i - 1] * (Nodes[i - 1] + Nodes[i - 2]);
		Sons[i] = Nodes[i - 1] + Nodes[i - 2];
	}
	Sons[8] = Nodes[7] + Nodes[6];

	long long x = 1e18;
	cerr << getDepth(x) << " " << getParent(x) << " " << getLca(x, x - 1) << '\n';

	int q, t;
	long long a, b, d;
	cin >> q;
	while(q--) {
		cin >> t;
		if(t == 1) {
			cin >> a >> b >> d;
			auto lc = getLca(a, b);
			Map[lc] = 1;
			Queries.push_back({1, lc, d});
		} else {
			cin >> a >> b;
			Map[a] = Map[b] = 1;
			Queries.push_back({2, a, b});
		}
	}

	for(auto p : Map) V.push_back(p.first);
	sort(V.begin(), V.end());
	for(auto x : V) Map[x] = ++vals;

	build(1, 1, vals);

	for(auto &q : Queries) {
		if(q[0] == 1) {
			add(1, 1, vals, Map[q[1]], q[2]);
		} else {
			auto ans = query(1, 1, vals, Map[q[1]], Map[q[2]]);
			if(ans == -INF) cout << "Comisia\n";
			else cout << ans << '\n';
		}
		//dump(1, 1, vals);
	}

}