#include <bits/stdc++.h>
using namespace std;
#define fwd(i, a, n) for (int i = (a); i < (n); i++)
#define rep(i, n)    fwd(i, 0, n)
#define all(X)       X.begin(), X.end()
#define sz(X)        int(size(X))
#define pb           push_back
#define eb           emplace_back
#define st           first
#define nd           second
using pii = pair<int, int>;
using vi = vector<int>;
using ll = long long;
using ld = long double;
#ifdef LOC
auto SS = signal(6, [](int) {
	*(int *)0 = 0;
});
#	define DTP(x, y)                                      \
		auto operator<<(auto &o, auto a)->decltype(y, o) { \
			o << "(";                                      \
			x;                                             \
			return o << ")";                               \
		}
DTP(o << a.st << ", " << a.nd, a.nd);
DTP(for (auto i : a) o << i << ", ", all(a));
void dump(auto... x) {
	((cerr << x << ", "), ...) << '\n';
}
#	define deb(x...) cerr << setw(4) << __LINE__ << ":[" #x "]: ", dump(x)
#else
#	define deb(...) 0
#endif

const int COLS = 10;
const int ROWS = 10;
const int ANCHOR_COLS = 3;
const int PAYLOAD_COLS = COLS - ANCHOR_COLS;
array<int, 3> ILLEGAL_POPCOUNTS = {4, 5, 6};

const int BITS = 4;

bool is_legal(int val) {
	for (auto illegal_popcount : ILLEGAL_POPCOUNTS) {
		if (__builtin_popcount(val) == illegal_popcount) {
			return false;
		}
	}
	return true;
}

int has_bit(int val, int bit) {
	return (val & (1 << bit)) > 0;
}

const int MAX_VAL = (1 << ROWS) - 1;

struct Edge {
	int prev_state;
	int prev_val;
};

const int MASKS = (1 << BITS);

vi legal_vals;
vector<Edge> edges[MASKS][MAX_VAL + 1];
ll paths[PAYLOAD_COLS][MASKS][MAX_VAL + 1];
ll total_paths = 0;

vector<Edge> final_edges;

void compute_legal_vals() {
	rep(i, MAX_VAL + 1) {
		if (is_legal(i)) {
			legal_vals.push_back(i);
		}
	}
}

void compute_first_edges() {
	for (auto val : legal_vals) {
		int msk = (val % MASKS);
		paths[0][msk][val] = 1;
	}
}

void compute_middle_edges() {
	for (auto val : legal_vals) {
		for (auto prev_val : legal_vals) {
			if (prev_val > val) {
				break;
			}
			int msk_xor = (val & (MASKS - 1));
			rep(prev_msk, MASKS) {
				int cur_msk = (msk_xor ^ prev_msk);
				edges[cur_msk][val].push_back({prev_msk, prev_val});
			}
		}
	}
}

void compute_final_edges() {
	for (auto val : legal_vals) {
		final_edges.push_back({5, val});
	}
}

void compute_paths() {
	fwd(col, 1, PAYLOAD_COLS) {
		for (auto val : legal_vals) {
			rep(cur_msk, MASKS) {
				for (auto [prev_msk, prev_val] : edges[cur_msk][val]) {
					paths[col][cur_msk][val] +=
						paths[col - 1][prev_msk][prev_val];
				}
			}
		}
	}
	for (auto [prev_msk, prev_val] : final_edges) {
		total_paths += paths[PAYLOAD_COLS - 1][prev_msk][prev_val];
	}
}

void preprocess_paths() {
	compute_legal_vals();
	compute_first_edges();
	compute_middle_edges();
	compute_final_edges();
	compute_paths();
	// cerr << "total paths: " << total_paths << '\n';
}

typedef array<int, PAYLOAD_COLS> Payload;
typedef array<int, ANCHOR_COLS> Anchor;
typedef array<int, COLS> Matrix;

vector<vi> anchor_rows = {
	{0, 0, 1},
	{0, 0, 1},
	{0, 1, 1},
	{0, 1, 1},
	{0, 0, 0},
	{1, 0, 0},
	{0, 1, 0},
	{1, 1, 0},
	{1, 0, 1},
	{1, 1, 1}};

Anchor get_anchor() {
	Anchor anchor{};

	rep(i, ROWS) {
		const auto row = anchor_rows[i];
		for (int j = 0; j < ANCHOR_COLS; ++j) {
			anchor[j] |= (row[j] << i);
		}
	}

	return anchor;
}

ll paths2[2][PAYLOAD_COLS][MASKS][MAX_VAL + 1];
// normalized payload
ll payload_rank(const Payload &payload) {
	rep(i, 2) rep(j, PAYLOAD_COLS) rep(k, MASKS) rep(l, MAX_VAL + 1)
		paths2[i][j][k][l] = 0;
	for (auto val : legal_vals) {
		if (val == payload[0]) {
			paths2[1][0][val % MASKS][val] = 1;
		} else if (val < payload[0]) {
			paths2[0][0][val % MASKS][val] = 1;
		}
	}
	fwd(col, 1, PAYLOAD_COLS) {
		for (auto val : legal_vals) {
			rep(cur_msk, MASKS) {
				for (auto [prev_msk, prev_val] : edges[cur_msk][val]) {
					if (val < payload[col]) {
						paths2[0][col][cur_msk][val] +=

							paths2[0][col - 1][prev_msk][prev_val] +
							paths2[1][col - 1][prev_msk][prev_val];
					} else if (val == payload[col]) {
						paths2[0][col][cur_msk][val] +=
							paths2[0][col - 1][prev_msk][prev_val];
						paths2[1][col][cur_msk][val] +=
							paths2[1][col - 1][prev_msk][prev_val];
					} else {
						paths2[0][col][cur_msk][val] +=
							paths2[0][col - 1][prev_msk][prev_val];
					}
				}
			}
		}
	}
	ll rank = 0;
	for (auto [prev_msk, prev_val] : final_edges) {
		rank += paths2[0][PAYLOAD_COLS - 1][5][prev_val];
	}
	return rank;
}

Payload payload_unrank(ll rank) {
	vector<Edge> cur_edges = final_edges;
	int cur_msk = 5;
	Payload payload{};
	fill(all(payload), 0);
	int cur_val = 0;
	for (int col = PAYLOAD_COLS - 1; col >= 0; --col) {
		int xr = cur_val % MASKS;
		for (auto [edge_prev_msk, edge_prev_val] : cur_edges) {
			// if ((cur_msk ^ xr) != edge_prev_msk) {
			// 	continue;
			// }
			ll paths_count = paths[col][edge_prev_msk][edge_prev_val];
			if (paths_count < rank) {
				rank -= paths_count;
			} else {
				payload[col] = edge_prev_val;
				cur_edges = edges[edge_prev_msk][edge_prev_val];
				cur_msk = edge_prev_msk;
				cur_val = edge_prev_val;
				break;
			}
		}
	}
	return payload;
}

void debug_human_readable_matrix(Matrix matrix) {
	for (int i = 0; i < ROWS; ++i) {
		string row_string;
		for (int j = 0; j < COLS; ++j) {
			row_string += (matrix[j] & (1 << i)) ? '1' : '0';
		}
		cerr << row_string << '\n';
	}
}

void debug_human_readable_anchor(Anchor anchor) {
	for (int i = 0; i < ROWS; ++i) {
		string row_string;
		for (int j = 0; j < ANCHOR_COLS; ++j) {
			row_string += (anchor[j] & (1 << i)) ? '1' : '0';
		}
		cerr << row_string << '\n';
	}
}

void debug_human_readable_payload(Payload payload) {
	for (int i = 0; i < ROWS; ++i) {
		string row_string;
		for (int j = 0; j < PAYLOAD_COLS; ++j) {
			row_string += (payload[j] & (1 << i)) ? '1' : '0';
		}
		cerr << row_string << '\n';
	}
}

Payload extract_payload(Matrix matrix) {
	sort(all(matrix), [](int col_a, int col_b) {
		return is_legal(col_a) < is_legal(col_b);
	});

	Anchor perturbed_anchor{};
	rep(i, ANCHOR_COLS) {
		perturbed_anchor[i] = matrix[i];
	}
	sort(all(perturbed_anchor), [](int col_a, int col_b) {
		return __builtin_popcount(col_a) < __builtin_popcount(col_b);
	});
	assert(__builtin_popcount(perturbed_anchor[0]) == 4);
	assert(__builtin_popcount(perturbed_anchor[1]) == 5);
	assert(__builtin_popcount(perturbed_anchor[2]) == 6);

	vector<pii> row_splits(ROWS);
	rep(i, ROWS) {
		row_splits[i] = {0, 0};
		rep(j, ANCHOR_COLS) {
			row_splits[i].first |= ((perturbed_anchor[j] >> i) & 1) << j;
		}
		fwd(j, ANCHOR_COLS, COLS) {
			row_splits[i].second |= ((matrix[j] >> i) & 1) << (j - ANCHOR_COLS);
		}
	}
	sort(all(row_splits), [](pii a, pii b) {
		auto [a_anchor, a_payload] = a;
		auto [b_anchor, b_payload] = b;
		bool is_four_a = a_anchor == 4;
		bool is_four_b = b_anchor == 4;
		bool is_six_a = a_anchor == 6;
		bool is_six_b = b_anchor == 6;
		bool is_special_a = is_four_a || is_six_a;
		bool is_special_b = is_four_b || is_six_b;
		if (is_special_a != is_special_b) {
			return is_special_a > is_special_b;
		}
		if (!is_special_a) {
			return a_anchor < b_anchor;
		}
		if (is_four_a != is_four_b) {
			return is_four_a > is_four_b;
		}
		return (__builtin_popcount(a_payload) & 1) >
			   (__builtin_popcount(b_payload) & 1);
	});

	auto debug_rows_human_readable = [&](vector<pii> rowers) {
		for (auto [anchor_part, payload_part] : rowers) {
			string anchor_str, payload_str;
			rep(j, ANCHOR_COLS) {
				anchor_str += ((anchor_part >> j) & 1) ? '1' : '0';
			}
			rep(j, PAYLOAD_COLS) {
				payload_str += ((payload_part >> j) & 1) ? '1' : '0';
			}
			cerr << anchor_str << " | " << payload_str << '\n';
		}
	};

	auto payload_from_rows = [&](const vector<pii> &rows) {
		Payload payload{};
		rep(i, PAYLOAD_COLS) {
			payload[i] = 0;
			rep(j, ROWS) {
				payload[i] |= ((rows[j].second >> i) & 1) << j;
			}
		}

		sort(all(payload));
		debug_human_readable_payload(payload);
		return payload;
	};

	return payload_from_rows(row_splits);
}

Matrix combine_anchor_and_payload(Anchor anchor, Payload payload) {
	Matrix matrix{};
	rep(i, ANCHOR_COLS) {
		matrix[i] = anchor[i];
	}
	rep(i, PAYLOAD_COLS) {
		matrix[ANCHOR_COLS + i] = payload[i];
	}
	return matrix;
}

void print_matrix(const Matrix &matrix) {
	rep(i, ROWS) {
		string row_string;
		rep(j, COLS) {
			row_string += (matrix[j] & (1 << i)) ? '1' : '0';
		}
		cout << row_string << '\n';
	}
	cout.flush();
}

void encode() {
	ll k;
	cin >> k;
	Payload payload = payload_unrank(k);
	Anchor anchor = get_anchor();
	// debug_human_readable_anchor(anchor);
	Matrix matrix = combine_anchor_and_payload(anchor, payload);
	print_matrix(matrix);
}

mt19937 rng(chrono::steady_clock::now().time_since_epoch().count());
Matrix read_matrix() {
	Matrix matrix{};
	vector<string> matrix_strings(ROWS);
	auto transpose_matrix_strings = [&]() {
		vector<string> transposed(COLS, string(ROWS, '0'));
		rep(i, ROWS) {
			rep(j, COLS) {
				transposed[j][i] = matrix_strings[i][j];
			}
		}
		return transposed;
	};
	rep(i, ROWS) {
		cin >> matrix_strings[i];
	}
	shuffle(all(matrix_strings), rng);
	matrix_strings = transpose_matrix_strings();
	shuffle(all(matrix_strings), rng);
	matrix_strings = transpose_matrix_strings();
	rep(i, ROWS) {
		string row_string = matrix_strings[i];
		rep(j, COLS) {
			if (row_string[j] == '1') {
				matrix[j] |= (1 << i);
			}
		}
	}
	return matrix;
}

void decode() {
	Matrix matrix = read_matrix();
	Payload payload = extract_payload(matrix);
	ll k = payload_rank(payload);
	cout << k << '\n';
	cout.flush();
}

int32_t main() {
	preprocess_paths();
	string whoami;
	cin >> whoami;
	bool encoder = (whoami == "Algosia");
	ll bound;
	cin >> bound;
	assert(bound <= total_paths);
	int tests;
	cin >> tests;
	rep(_, tests) {
		if (encoder) {
			encode();
		} else {
			decode();
		}
	}
#ifdef LOCF
	cout.flush();
	cerr << "- - - - - - - - -\n";
	(void)!system(
		"grep VmPeak /proc/$PPID/status | sed s/....kB/\' MB\'/1 >&2"); // 4x.kB
																		// ....kB
#endif
	return 0;
}