#include <cmath>
#include <cstdio> 
#include <cstdlib> 
#include <cstdio> 
#include <cstdlib> 
#include <cstring>
#include <iostream>
#include <map>
#include <algorithm>
//#define gets gets_s
#define PINF 10000000
#define DINF -10000000

struct Node
{
    int l, r;
};

std::map<std::string, Node> ma[1005];
bool wr[1005];
char ch[1005];

Node genNode(char op[], int v)
{
    Node nd;
    if (strcmp(op, "<") == 0)
    {
        nd.r = v - 1;
        nd.l = DINF;
    }
    else if (strcmp(op, ">") == 0)
    {
        nd.r = PINF;
        nd.l = v + 1;

    }
    else if (strcmp(op, "<=") == 0)
    {
        nd.r = v;
        nd.l = DINF;
    }
    else if (strcmp(op, ">=") == 0)
    {
        nd.r = PINF;
        nd.l = v;
    }
    else
    {
        nd.r = nd.r = v;
    }
    return nd;
}

bool cbNode(Node &a, Node &b, char key[],int k)
{
    if (a.r < b.l || a.l > b.r)
    {
        return false;
    }
    Node c;
    c.l = std::max(a.l, b.l);
    c.r = std::min(a.r, b.r);
    ma[k][key] = c;
    return true;
}

void readCh(char ch[], char key[], char op[], int &v)
{
    int i = 0;
    while (ch[i] == ' ')
    {
        i++;
    }
    int j = 0;
    while (ch[i] >= 'a' && ch[i] <= 'z')
    {
        key[j++] = ch[i];
        i++;
    }
    key[j] = '\0';
    while (ch[i] == ' ')
    {
        i++;
    }
    j = 0;
    while (ch[i] == '>' || ch[i] == '<' || ch[i] == '=')
    {
        op[j++] = ch[i];
        i++;
    }
    op[j] = '\0';
    sscanf(ch + i, "%d", &v);
}

void pushNode(char ch[], int k)
{
    char key[105], op[15];
    int v;
    sscanf(ch, "%s%s%d", key, op, &v);
//    readCh(ch, key, op, v);
    std::map<std::string, Node>::iterator it = ma[k].find(key);
    Node nd = genNode(op, v);;
    if (it == ma[k].end())
    {
        ma[k][key] = nd;
    }
    else
    {
        if (!cbNode(it->second, nd, key, k))
        {
            wr[k] = true;
        }
    }
}

void ana(int k)
{
    int pre = 0;
    for (int i = 0; ch[i] != '\0'; ++i)
    {
        if (ch[i] == ',')
        {
            ch[i] = '\0';
            pushNode(ch + pre, k);
            if (wr[k])
            {
                return;
            }
            pre = i + 1;
        }
    }
    pushNode(ch + pre, k);

}

bool cflct(Node &a, Node &b)
{
    return a.r < b.l || a.l > b.r;
}

int main()
{
    int n;
    while (1 == scanf("%d", &n))
    {
        memset(wr, false, sizeof(wr));
        gets(ch);
        for (int i = 0; i < n; ++i)
        {
            ma[i].clear();
            gets(ch);
            ana(i);
            if (wr[i])
            {
                printf("unique\n");
                continue;
            }
            bool flag = false;
            for (int j = 0; j < i; j++)
            {
                if (wr[j])
                    continue;
                bool cfl = false;
                for (std::map<std::string, Node>::iterator it = ma[i].begin(); it != ma[i].end(); ++it)
                {
                    std::map<std::string, Node>::iterator jt = ma[j].find(it->first);
                    if (jt == ma[j].end())
                    {
                        continue;
                    }
                    if (cflct(it->second, jt->second))
                    {
                        cfl = true;
                        break;
                    }
                }
                if (!cfl)
                {
                    if (flag)
                        printf(" ");
                    printf("%d", j + 1);
                    flag = true;
                }
            }
            if (!flag)
            {
                printf("unique\n");
            }
            else
            {
                printf("\n");
            }
        }

    }
    return 0; 
}