#include <bits/stdc++.h>
using namespace std;

unsigned long long Count10[19];
unsigned long long Count16[19];

void Initialize() {
	for (int i = 1; i <= 10; i++) {
		unsigned long long sum = 1;
		for (int j = 1; j <= i; j++) {
			unsigned long long x = (j == i ? 9 : 10 - (i - j));
			sum *= x;
		}
		Count10[i] = Count10[i - 1] + sum;
	}
	for (int i = 1; i <= 16; i++) {
		unsigned long long sum = 1;
		for (int j = 1; j <= i; j++) {
			unsigned long long x = (j == i ? 15 : 16 - (i - j));
			sum *= x;
		}
		Count16[i] = Count16[i - 1] + sum;
	}
	return;
}

char Convert(int x) {
	if (x >= 10) return ('a' + (x - 10));
	return ('0' + x);
}

unsigned long long Convert2(char chr) {
	if (chr >= '0' && chr <= '9') return (chr - '0');
	return 10 + (chr - 'a');
}

unsigned long long Integer(string str, unsigned long long d) {
	unsigned long long s = 0;
	for (int i = 0; i < str.size(); i++) {
		s *= d;
		s += Convert2(str[i]);
	}
	return s;
}

string String(unsigned long long intg, unsigned long long d) {
	if (intg == 0) return "0";
	string str = "";
	while (intg > 0) {
		str += Convert(intg % d);
		intg /= d;
	}
	reverse(str.begin(), str.end());
	return str;
}


// ====================================================================== Answer Query 1
string Query1(unsigned long long order, int d) {
	if (order == 1) return "0";
	order--;

	// Simulation
	for (int i = 1; i <= d; i++) {
		if (d == 10 && order > Count10[i]) continue;
		if (d == 16 && order > Count16[i]) continue;
		if (d == 10) order -= (Count10[i - 1] + 1);
		if (d == 16) order -= (Count16[i - 1] + 1);

		// Get Answer
		vector<long long> vec(i, 0);
		vector<bool> used(d, false);
		for (int j = 0; j < i; j++) {
			unsigned long long x = (j == i - 1 ? d - 1 : d + 1 - (i - j));
			vec[j] = (order % x);
			order /= x;
		}

		// Get String
		string str = "";
		for (int j = i - 1; j >= 0; j--) {
			int cnt = 0;
			for (int k = 0; k < d; k++) {
				if (j == i - 1 && k == 0) continue;
				if (used[k] == true) continue;
				if (cnt == vec[j]) {
					str += Convert(k);
					used[k] = true;
					break;
				}
				cnt++;
			}
		}
		return str;
	}
	return "-";
}


// ====================================================================== Answer Query 0
bool Check(string str) {
	sort(str.begin(), str.end());
	for (int i = 0; i < (int)str.size() - 1; i++) {
		if (str[i] == str[i + 1]) return false;
	}
	return true;
}

unsigned long long Query0(string str, int d) {
	if (str == "0") return 0;

	// Solve Init
	unsigned long long Answer = 0;
	if (d == 10) Answer += Count10[str.size() - 1] + 1;
	if (d == 16) Answer += Count16[str.size() - 1] + 1;

	// Solve Main
	vector<bool> used(d, false);
	for (int i = 0; i < str.size(); i++) {
		int x = Convert2(str[i]);
		int cnt = 0;
		for (int j = 0; j < x; j++) {
			if (j == 0 && i == 0) continue;
			if (used[j] == false) cnt++;
		}

		// Get Numways
		unsigned long long ushiro = 1;
		for (int j = i + 1; j < (int)str.size(); j++) ushiro *= (unsigned long long)(d - j);

		// First Case
		if (used[x] == true) {
			Answer += 1ULL * cnt * ushiro;
			break;
		}
		else {
			Answer += 1ULL * cnt * ushiro;
			used[x] = true;
		}
	}
	return Answer;
}


// ====================================================================== Main
int main() {
	Initialize();
	int T; cin >> T;
	for (int t = 1; t <= T; t++) {
		char kata; int typ; cin >> kata >> typ;
		if (typ == 0) {
			string S, T; cin >> S >> T;
			unsigned long long v1 = Query0(S, (kata == 'd' ? 10 : 16));
			unsigned long long v2 = Query0(T, (kata == 'd' ? 10 : 16));
			unsigned long long ans = v2 - v1;
			if (Check(T) == true) ans += 1;
			cout << String(ans, (kata == 'd' ? 10 : 16)) << endl;
		}
		if (typ == 1) {
			string S; cin >> S;
			unsigned long long Order = Integer(S, (kata == 'd' ? 10 : 16));
			cout << Query1(Order, (kata == 'd' ? 10 : 16)) << endl;
		}
	}
	return 0;
}