#include <cstdio>
#include <string>
#include <vector>
#include <iostream>
using namespace std;

#define MAXNUM 10010

struct Gather
{
    string varName;
    int left, right;
    Gather()
    {
        left = - MAXNUM;
        right = MAXNUM;
    }
};

vector<Gather> Gathers[1010];
bool bLegal[1010];

void SkipSpace(const char *&sz)
{
    while (*sz && (*sz == ' ' || *sz == ',')) ++sz;
}

bool GetMixedRange(int l1, int r1, int l2, int r2, int &l, int &r)
{
    l = max(l1, l2);
    r = min(r1, r2);

    return l1 <= l2;
}

void AddtoGathers(int t, Gather obj)
{
    for (int i = 0; i < Gathers[t].size(); ++i)
    {
        if (Gathers[t][i].varName == obj.varName)
        {
            // 合并变量
            int l, r;
            if (GetMixedRange(Gathers[t][i].left, Gathers[t][i].right, 
                obj.left, obj.right, l, r))
            {
                Gathers[t][i].left = l;
                Gathers[t][i].right = r;
            }
            else
            {
                bLegal[t] = false;
            }
            return;
        }
    }

    Gathers[t].push_back(obj);
}

bool JudgeFixed(const Gather &a, const Gather &b)
{
    if (a.varName != b.varName) return true;

    int l = max(a.left, b.left), r = min(a.right, b.right);
    return l <= r;
}

void HandleGather(string str, int t)
{
    const char *sz = str.c_str();
    while (*sz)
    {
        string varName, oper;
        int opNum = 0;

        SkipSpace(sz);
        // varName
        while (isalpha(*sz))
        {
            varName += *sz;
            ++sz;
        }
        SkipSpace(sz);
        // oper
        while (*sz != ' ' && !isdigit(*sz))
        {
            oper += *sz;
            ++sz;
        }
        SkipSpace(sz);
        // obNum
        while (*sz && isdigit(*sz))
        {
            opNum = opNum * 10 + *sz - '0';
            ++sz;
        }

        Gather obj;
        obj.varName = varName;
        if (oper == "<")
        {
            obj.right = opNum - 1;
        }
        else if (oper == ">")
        {
            obj.left = opNum + 1;
        }
        else if (oper == "<=")
        {
            obj.right = opNum;
        }
        else if (oper == ">=")
        {
            obj.left = opNum;
        }
        else if (oper == "==")
        {
            obj.left = obj.right = opNum;
        }

        AddtoGathers(t, obj);
        if (!bLegal[t])
        {
            printf("unique\n");
            return;
        }
    }


    // begin to judge
    vector<int> result;
    for (int i = 0; i <= t - 1; ++i)
    {
        if (!bLegal[i]) continue;

        bool ok = true;
        for (int j = 0; j < Gathers[i].size(); ++j)
        {
            for (int k = 0; k < Gathers[t].size(); ++k)
            {
                if (!JudgeFixed(Gathers[i][j], Gathers[t][k]))
                {
                    ok = false;
                    break;
                }
            }
            if (!ok) break;
        }

        if (ok)
            result.push_back(i+1);
    }

    if (result.empty())
    {
        printf("unique\n");
    }
    else
    {
        printf("%d", result[0]);
        for (int i = 1; i < result.size(); ++i)
        {
            printf(" %d", result[i]);
        }
        printf("\n");
    }
}

int main()
{
    //freopen("input.txt", "r", stdin);

    int N;
    scanf("%d",&N);
    for (int i = 0; i < N; ++i)
    {
        bLegal[i] = true;
    }
    string str;
    getline(cin, str);
    for(int i = 0; i < N; ++i)
    {
        getline(cin, str);
        HandleGather(str, i);
    }
    return 0;
}