#include <iostream>
#include <numeric>
#include <bitset>
#include <vector>
#include <array>
#include <unordered_set>
#include <unordered_map>
#include <sstream>
#include <algorithm>
#include <iomanip>
#include <map>
#include <chrono>
#include <random>
#include <cstring>

#define ll long long
#define ull unsigned long long

using namespace std;

mt19937_64 myRand64(chrono::steady_clock::now().time_since_epoch().count());

// unordered_map<ull, int> name;
// vector<pair<ull, int>> name;
unordered_map<string, int> idx;
vector<pair<ull, pair<int, int>>> pairwise;
// unordered_map<ull, pair<int, int>> pairwise;
vector<string> names;
vector<ull> values;
int m;

int n;
ull value3[4010];
// unordered_set<ull> haveValue3;
vector<ull> haveValue3;
vector<int> graph[4010];

ull vis[4010];
vector<vector<int>> lists;
pair<int, int> res[2010];

ull GetVal(const string& s) {
    auto it = idx.find(s);
    if (it == idx.end()) {
        idx[s] = values.size();
        ull key = myRand64();
        // while (name.count(key)) {
        //     key = myRand64();
        // }
        // name[key] = values.size();
        names.push_back(s);
        values.push_back(key);
        return key;
    }
    return values[it->second];
}

bool SearchList(int a) {
    vis[a] = true;
    lists.back().push_back(a);
    if (graph[a].size() == 2) {
        for (auto& x : graph[a]) {
            if (!vis[x]) {
                if (!SearchList(x)) {
                    return false;
                }
                break;
            }
        }
    }
    return true;
}

int Get(int a) {
    if (res[a].first == -1) {
        return 0;
    }
    if (res[a].second == -1) {
        return 1;
    }
    return 2;
}

bool Check() {
    for (int i = 0; i < m; i++) {
        if (Get(i) != 2) {
            return false;
        }
    }
    vector<pair<int, int>> copy(res, res + m);
    sort(copy.begin(), copy.end());
    for (int i = 1; i < m; i++) {
        if (copy[i].first <= copy[i - 1].first || copy[i].second <= copy[i - 1].second) {
            return false;
        }
    }
    return true;
}

bool AddEdge(int a, int b) {
    graph[a].push_back(b);
    graph[b].push_back(a);
    if (graph[b].size() > 2 || graph[a].size() > 2) {
        return false;
    }
    return true;
}

// int CountName(ull a) {
//     return lower_bound(name.begin(), name.end(), (pair<ull, int>) { a + 1, 0 })
//         - lower_bound(name.begin(), name.end(), (pair<ull, int>) { a, 0 });
// }

pair<int, int> FindPairwise(ull a) {
    // cout << "Find " << endl;
    auto it = lower_bound(pairwise.begin(), pairwise.end(), (pair<ull, pair<int, int>>) { a, { -1, -1 } });
    // cout << it->first << endl;
    if (it == pairwise.end() || it->first != a) {
        // cout << a << " fail" << endl;
        // cout << it->first << ',' << a << endl;
        return { -1, -1 };
    }
    // cout << "success" << endl;
    return it->second;
}

int CountVal3(ull a) {
    auto [l, r] = equal_range(haveValue3.begin(), haveValue3.end(), a);
    return r - l;
}

bool Res() {
    for (int i = 0; i < n - 1; i++) {
        bool base = (FindPairwise(value3[i]) != (pair<int, int>) { -1, -1 });
        for (int j = i + 1; j < n; j++) {
            auto key = FindPairwise(value3[i] - value3[j]);
            if (key.first != -1 || key.second != -1) {
                if (key.first == -1 || key.second == -1) {
                    if (!AddEdge(i, j)) {
                        return false;
                    }
                    continue;
                }
                if (!base) {
                    ull mid = value3[j] - values[key.second];
                    ull mid2 = value3[j] + values[key.first];
                    // cout << value3[i] << ',' << value3[j] - values[key.second] + values[key.first] << endl;
                    if (CountVal3(mid) == 0 && CountVal3(mid2) == 0) {
                        if (!AddEdge(i, j)) {
                            return false;
                        }
                        // cout << i << ',' << j << endl;
                    }
                }
            }
            // if (graph[j].size() > 1) {
            //     continue;
            // }
            // auto it = lower_bound(pairwise.begin(), pairwise.end(), (pair<ull, pair<int, int>>) { value3[j] - value3[i], { 0, 0 } });
            // // auto it = pairwise.find(value3[j] - value3[i]);
            // if (it != pairwise.end() && it->first == value3[j] - value3[i]) {
            //     ull mid = value3[i] - values[it->second.second];
            //     ull mid2 = value3[i] + values[it->second.first];
            //     if (CountVal3(mid) == 0 && CountVal3(mid2) == 0) {
            //         if (!AddEdge(i, j)) {
            //             return false;
            //         }
            //     }
            // }
        }
    }
    // for (int i = 0; i < n; i++) {
    //     cout << i << ':';
    //     for (auto& x : graph[i]) {
    //         cout << x << ',';
    //     }
    //     cout << endl;
    // }
    // for (auto& x : graph) {
    //     for (auto& y : x) {
    //         cout << y << ',';
    //     }
    //     cout << endl;
    // }
    // cout << endl;
    for (int i = 0; i < n; i++) {
        if (graph[i].empty()) {
            vis[i] = true;
            lists.push_back({ i });
            continue;
        }
        if (!vis[i] && graph[i].size() == 1) {
            vis[i] = true;
            lists.push_back({ i });
            SearchList(graph[i][0]);
        }
    }
    // for (auto& x : lists) {
    //     for (auto& y : x) {
    //         cout << y << ',';
    //     }
    //     cout << endl;
    // }
    for (int i = 0; i < n; i++) {
        if (!vis[i]) {
            return false;
        }
    }
    int cc = 0;
    for (auto& x : lists) {
        int k = x.size();
        // auto it = name.find(value3[x[0]]);
        // if (it == name.end()) {
        auto key = FindPairwise(value3[x[0]]);
        if (key.first == -1 || key.second != -1) {
            // cout << x[0] << endl;
            // cout << value3[x[0]] << endl;
            // cout << values[idx["A"]] << endl;
            // cout << FindPairwise(value3[x[0]]).second << endl;
            return false;
        }
        int cur = key.first;
        if (Get(cur) != 0) {
            return false;
        }
        res[cur].first = cc;
        cc++;
        for (int i = 1; i < k; i++) {
            ull diff = value3[x[i]] - value3[x[i - 1]];
            // it = name.find(diff);
            // if (it != name.end()) {
            key = FindPairwise(diff);
            // cout << i << ',' << key.first << ',' << key.second << endl;
            if (key.first == -1) {
                if (key.second == -1) {
                    return false;
                }
                cur = key.second;
                if (Get(cur) != 1) {
                    return false;
                }
                res[cur].second = cc;
                cc++;
                continue;
            }
            if (key.second == -1) {
                cur = key.first;
                if (Get(cur) != 0) {
                    return false;
                }
                res[cur].first = cc;
                cc++;
                continue;
            }
            if (Get(key.first) != 0 || Get(key.second) != 1) {
                return false;
            }
            res[key.first].first = cc;
            res[key.second].second = cc;
            cc++;
            continue;
            // if (it != name.end() && it->first == diff) {
            //     cur = it->second;
            //     if (Get(cur) != 0) {
            //         return false;
            //     }
            //     res[cur].first = cc;
            //     cc++;
            //     continue;
            // }
            // // it = name.find(-diff);
            // // if (it != name.end()) {
            // it = lower_bound(name.begin(), name.end(), (pair<ull, int>) { -diff, 0 });
            // if (it != name.end() && it->first == -diff) {
            //     cur = it->second;
            //     if (Get(cur) != 1) {
            //         return false;
            //     }
            //     res[cur].second = cc;
            //     cc++;
            //     continue;
            // }
            // // auto it2 = pairwise.find(diff);
            // // if (it2 != pairwise.end()) {
            // auto it2 = lower_bound(pairwise.begin(), pairwise.end(), (pair<ull, pair<int, int>>) { diff, { 0, 0 } });
            // if (it2 != pairwise.end() && it2->first == diff) {
            //     auto cur2 = it2->second;
            //     if (Get(cur2.first) != 0 || Get(cur2.second) != 1) {
            //         return false;
            //     }
            //     res[cur2.first].first = cc;
            //     res[cur2.second].second = cc;
            //     cc++;
            //     continue;
            // }
            // return false;
        }
        // it = name.find(value3[x[k - 1]]);
        // if (it == name.end()) {
        key = FindPairwise(-value3[x[k - 1]]);
        // it = lower_bound(name.begin(), name.end(), (pair<ull, int>) { value3[x[k - 1]], 0 });
        // if (it == name.end() || it->first != value3[x[k - 1]]) {
        if (key.first != -1 || key.second == -1) {
            return false;
        }
        cur = key.second;
        if (Get(cur) != 1) {
            return false;
        }
        res[cur].second = cc;
        cc++;
    }
    // cout << "Finish?" << endl;
    return Check();
}

void Solve() {
    string s;
    cin >> n;
    getline(cin, s);
    // value3.resize(n);
    // graph.resize(n);
    // vis.resize(n);
    for (int i = 0; i < n; i++) {
        getline(cin, s);
        s += ' ';
        // istringstream ss(s);
        int cc = s.find(' ');
        // cout << s.substr(cc) << endl;
        int k = stoi(s.substr(0, cc));
        // cout << k << endl;
        for (int j = 0; j < k; j++) {
            int cc2 = s.find(' ', cc + 1);
            string cur = s.substr(cc + 1, cc2 - cc - 1);
            // cout << cur << endl;
            cc = cc2;
            value3[i] += GetVal(cur);
        }
        haveValue3.push_back(value3[i]);
    }
    sort(haveValue3.begin(), haveValue3.end());
    // return;
    // cout << values[idx["B"]] << '\n';
    // cout << GetVal("B") << '\n';
    // cout << (value3[0] ^ value3[1]) << endl;
    m = values.size();
    // name.resize(m);
    for (int i = 0; i < m; i++) {
        pairwise.push_back({ values[i], {i, -1} });
        pairwise.push_back({ -values[i], {-1, i} });
        // name[i] = { values[i], i };
    }
    // sort(name.begin(), name.end());
    // cout << "m=" << m << endl;
    memset(res, -1, sizeof(res));
    // res.assign(m, { -1, -1 });
    // cout << "fuck" << endl;
    for (int i = 0; i < m; i++) {
        for (int j = 0; j < m; j++) {
            if (i != j) {
                // pairwise[values[i] - values[j]] = { i, j };
                pairwise.push_back({ values[i] - values[j], {i, j} });
            }
        }
    }
    // cout << pairwise.size() << endl;
    sort(pairwise.begin(), pairwise.end());
    // for (auto& [x, y] : pairwise) {
    //     cout << x << endl;
    // }
    // cout << "fuck" << endl;
    // cout << "fuck" << endl;
    if (!Res()) {
        cout << "IMPOSSIBLE";
        return;
    }
    for (int i = 0; i < m; i++) {
        cout << names[i] << ' ' << res[i].first << ' ' << res[i].second << '\n';
    }
}

int main() {
    ios::sync_with_stdio(false);
    cin.tie(nullptr);
    // int T;
    // cin >> T;
    // for (int i = 1; i <= T; i++) {
    Solve();
    //     cout << "Case #" << i << ": " << s2 << '\n';
    // }
    return 0;
}