You are given a connected weighted undirected graph without any loops and multiple edges. 

Let us remind you that a graph's spanning tree is defined as an acyclic connected subgraph of the given graph that includes all of the graph's vertexes. The weight of a tree is defined as the sum of weights of the edges that the given tree contains. The minimum spanning tree (MST) of a graph is defined as the graph's spanning tree having the minimum possible weight. For any connected graph obviously exists the minimum spanning tree, but in the general case, a graph's minimum spanning tree is not unique.

Your task is to determine the following for each edge of the given graph: whether it is either included in any MST, or included at least in one MST, or not included in any MST.
The first line contains two integers *n* and *m* (2 ≤ *n* ≤ 10<sup class="upper-index">5</sup>, <img align="middle" class="tex-formula" src="https://espresso.codeforces.com/da07f7f89dfbf6f6c4ee7ebcc66e82f96647327c.png" style="max-width: 100.0%;max-height: 100.0%;"/>) — the number of the graph's vertexes and edges, correspondingly. Then follow *m* lines, each of them contains three integers — the description of the graph's edges as "*a*<sub class="lower-index">*i*</sub> *b*<sub class="lower-index">*i*</sub> *w*<sub class="lower-index">*i*</sub>" (1 ≤ *a*<sub class="lower-index">*i*</sub>, *b*<sub class="lower-index">*i*</sub> ≤ *n*, 1 ≤ *w*<sub class="lower-index">*i*</sub> ≤ 10<sup class="upper-index">6</sup>, *a*<sub class="lower-index">*i*</sub> ≠ *b*<sub class="lower-index">*i*</sub>), where *a*<sub class="lower-index">*i*</sub> and *b*<sub class="lower-index">*i*</sub> are the numbers of vertexes connected by the *i*-th edge, *w*<sub class="lower-index">*i*</sub> is the edge's weight. It is guaranteed that the graph is connected and doesn't contain loops or multiple edges.
N = 100010
n, m = map(int, input().split())

x = [0] * (N)
y = [0] * (N)
z = [0] * (N)
p = [0] * (N)
ans = [0] * (N)
f = [False] * (N)
h = [0] * (N)
pe = [0] * (N)
d = [0] * (N)
v = [[] for _ in range(N)]

# Função para comparar arestas com base em seus pesos (z)
def cmp(i, j):
    return z[i] < z[j]

# Função para encontrar o representante de um conjunto
def par(x):
    while pe[x]:
        x = pe[x]
    return x

# Função para unir dois conjuntos
def uni(x, y):
    x = par(x)
    y = par(y)
    v[x].clear()
    v[y].clear()
    f[x] = False
    f[y] = False
    if x == y:
        return
    if h[x] > h[y]:
        pe[y] = x
    else:
        pe[x] = y
        if h[x] == h[y]:
            h[y] += 1

# Função para adicionar uma aresta ao grafo
def add_edge(x, y, i):
    if x == y:
        return
    ans[i] = 1
    v[x].append((y, i))
    v[y].append((x, i))

# Função de busca em profundidade (DFS)
def dfs(c, g, h):
    f[c] = True
    d[c] = h
    for i in v[c]:
        if not f[i[0]]:
            dfs(i[0], i[1], h + 1)
            d[c] = min(d[c], d[i[0]])
        elif i[1] != g:
            d[c] = min(d[c], d[i[0]])
    if d[c] == h:
        ans[g] = 2

# Leitura das informações das arestas
for i in range(1, m + 1):
    x[i], y[i], z[i] = map(int, input().split())
    p[i] = i

# Ordena as arestas com base em seus pesos
p.sort(key=lambda i: z[i])

i = 1
while i <= m:
    j = i
    while j <= m and z[p[j]] == z[p[i]]:
        add_edge(par(x[p[j]]), par(y[p[j]]), p[j])
        j += 1
    j = i
    while j <= m and z[p[j]] == z[p[i]]:
        k = par(x[p[j]])
        if not f[k]:
            dfs(k, 0, 0)
        j += 1
    j = i
    while j <= m and z[p[j]] == z[p[i]]:
        uni(x[p[j]], y[p[j]])
        j += 1
    i = j

# Imprime o tipo de conectividade para cada aresta
for i in range(1, m + 1):
    if ans[i] == 0:
        print("none")
    elif ans[i] == 1:
        print("at least one")
    else:
        print("any")