#include <iostream>
#include <vector>
#include <algorithm>
#include <string>
#include <cmath>
#include <cstdio>
#include <queue>
#include <deque>
#include <bitset>
#include <set>
#include <unordered_set>
#include <map>
#include <unordered_map>
#include <random>
#include <ctime>
#include <utility>
#include <fstream>

#pragma GCC optimize("Ofast")
#pragma GCC optimize("no-stack-protector")
#pragma GCC optimize("unroll-loops")
#pragma GCC target("sse,sse2,sse3,ssse3,popcnt,abm,mmx,tune=native")
#pragma GCC optimize("fast-math")
#pragma comment(linker, "/STACK:256000000")
#pragma warning(disable:4996)

using namespace std;

typedef long long ll;
typedef long double ld;

const char el = '\n';
const int inf = 1e9;
const ll llinf = 1e18, mod = 1000'000'007ll;
const ld pi = 3.141592653589793238462643383279502884197169399375105820974944592307816406286208998628034825;

#define forn(i, n) for (int i = 0; i < (int)n; ++i)
#define firn(i, n) for (int i = 1; i < (int)n; ++i)
#define all(v) v.begin(), v.end()
#define x first
#define y second

template<typename T> bool uin(T &a, T b) { if (b < a) { a = b; return 1; } return 0; }
template<typename T> bool uax(T &a, T b) { if (b > a) { a = b; return 1; } return 0; }
template<class iterator> void output(iterator begin, iterator end, char p = ' ', ostream & out = cout) { while (begin != end) { out << (*begin) << p; begin++; } out << '\n'; }
template<class T> void output(T x, char p = ' ', ostream & out = cout) { output(all(x), p, out); }

mt19937 rnd(time(NULL));

string to_str(ll a) {
	string ans;
	while (a > 0) {
		ans += char(a % 10 + '0');
		a /= 10;
	}
	while ((int)ans.size() < 20) ans += '0';
	reverse(all(ans));
	return ans;
}

int g[10][10];
vector<int> comp;
vector<bool> used;
void dfs(int i) {
	used[i] = 1;
	comp.push_back(i);
	for (int to = 1; to < 10; ++to)
		if (g[i][to] && !used[to])
			dfs(to);
}
int main() {
	ios_base::sync_with_stdio(false);
	cin.tie(NULL);
	int n;
	cin >> n;
	vector<pair<ll, ll>> a(n);
	forn(i, n)
		cin >> a[i].x >> a[i].y;
	vector<pair<string, string>> b(n);
	forn(i, n)
		b[i].x = to_str(a[i].x), b[i].y = to_str(a[i].y);
	vector<ll> st(19, 1);
	firn(i, 19) st[i] = st[i - 1] * 10ll;
	firn(i, 10)
	for (int j = i + 1; j < 10; ++j) {
		bool good = 1;
		for (int k = 0; k < n && good; ++k) {
			forn(l, 20) {
				if (b[k].x[l] != b[k].y[l]) break;
				if (b[k].x[l] == '0' + i) {
					ll tmp1 = a[k].x + (j - i) * 1ll * st[19 - l];
					ll tmp2 = a[k].y + (j - i) * 1ll * st[19 - l];
					int in = lower_bound(all(a), pair<ll, ll>{ tmp1 + 1, 0 }) - a.begin() - 1;
					if (in < 0 || a[in].y < tmp2) {
						good = 0;
						break;
					}
					continue;
				}
				if (b[k].x[l] == '0' + j) {
					ll tmp1 = a[k].x + (i - j) * 1ll * st[19 - l];
					ll tmp2 = a[k].y + (i - j) * 1ll * st[19 - l];
					int in = lower_bound(all(a), pair<ll, ll>{ tmp1 + 1, 0 }) - a.begin() - 1;
					if (in < 0 || a[in].y < tmp2) {
						good = 0;
						break;
					}
				}
			}
			if (!good) break;
			int mn = 0;
			for (; mn < 20 && b[k].x[mn] == b[k].y[mn]; ++mn);
			for (int l = mn; l < 20; ++l) {
				if (b[k].x[l] > '0' + j || l == mn && b[k].y[l] < j + '0') continue;
				ll tmp1 = a[k].x + (i - (b[k].x[l] - '0')) * 1ll * st[19 - l];
				if (b[k].x[l] < '0' + j) tmp1 = (tmp1 / st[19 - l]) * st[19 - l];
				ll tmp2 = (tmp1 / st[19 - l]) * st[19 - l] + (st[19 - l] - 1);
				if (l == mn && b[k].y[l] == j + '0') tmp2 = a[k].y + (i - j) * 1ll * st[19 - l];
				int in = lower_bound(all(a), pair<ll, ll>{ tmp1 + 1, 0 }) - a.begin() - 1;
				if (in < 0 || a[in].y < tmp2) {
					good = 0;
					break;
				}
			}
			if (!good) break;
			for (int l = mn; l < 20; ++l) {
				if (b[k].y[l] < '0' + i || l == mn && b[k].x[l] > i + '0') continue;
				ll tmp2 = a[k].y + (j - (b[k].y[l] - '0')) * 1ll * st[19 - l];
				if (b[k].y[l] > '0' + i) tmp2 = (tmp2 / st[19 - l]) * st[19 - l] + st[19 - l] - 1;
				ll tmp1 = (tmp2 / st[19 - l]) * st[19 - l];
				if (l == mn && b[k].x[l] == i + '0') tmp1 = a[k].x + (j - i) * 1ll * st[19 - l];
				int in = lower_bound(all(a), pair<ll, ll>{ tmp1 + 1, 0 }) - a.begin() - 1;
				if (in < 0 || a[in].y < tmp2) {
					good = 0;
					break;
				}
			}
		}
		if (good) g[i][j] = g[j][i] = 1;
	}
	used.assign(10, 0);
	firn(i, 10) {
		if (used[i]) continue;
		dfs(i);
		sort(all(comp));
		forn(j, comp.size())
			cout << comp[j];
		comp.clear();
		cout << el;
	}
#ifdef _DEBUG
	system("pause");
#endif
	return 0;
}