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.
# Função para encontrar o representante de um conjunto usando Union-Find
def encontrar_representante(vertice, pais):
    if pais[vertice] == vertice:
        return vertice
    pais[vertice] = encontrar_representante(pais[vertice], pais)
    return pais[vertice]

# Função para unir dois conjuntos usando Union-Find
def unir_conjuntos(vertice_a, vertice_b, pais, tamanho):
    representante_a = encontrar_representante(vertice_a, pais)
    representante_b = encontrar_representante(vertice_b, pais)

    if representante_a != representante_b:
        if tamanho[representante_a] < tamanho[representante_b]:
            representante_a, representante_b = representante_b, representante_a
        pais[representante_b] = representante_a
        tamanho[representante_a] += tamanho[representante_b]

# Função principal para encontrar a resposta
def encontrar_resposta(n, arestas):
    arestas_ordenadas = sorted(enumerate(arestas), key=lambda x: x[1][2])
    pais = list(range(n))
    tamanho = [1] * n
    resposta = ["none"] * len(arestas)

    for i, (indice, (u, v, peso)) in enumerate(arestas_ordenadas):
        if encontrar_representante(u, pais) != encontrar_representante(v, pais):
            resposta[indice] = "at least one"
            unir_conjuntos(u, v, pais, tamanho)

    pais = list(range(n))

    for i, (indice, (u, v, peso)) in enumerate(arestas_ordenadas):
        if encontrar_representante(u, pais) != encontrar_representante(v, pais):
            resposta[indice] = "any"
            unir_conjuntos(u, v, pais, tamanho)

    return resposta

# Leitura de entrada
n, m = map(int, input().split())
arestas = []

for i in range(m):
    u, v, peso = map(int, input().split())
    arestas.append((u - 1, v - 1, peso, i))

# Encontrar a resposta
resposta = encontrar_resposta(n, arestas)

# Imprimir a resposta
for r in resposta:
    print(r)
