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úmero máximo de vértices
MAX_VERTICES = 100010

# Leitura do número de vértices e arestas
num_vertices, num_arestas = map(int, input().split())

# Listas para armazenar informações sobre as arestas
aresta_origem = [0] * MAX_VERTICES
aresta_destino = [0] * MAX_VERTICES
peso_aresta = [0] * MAX_VERTICES
indice_aresta = [0] * MAX_VERTICES

# Lista para armazenar o tipo de conectividade das arestas
tipo_conectividade = [0] * MAX_VERTICES

# Vetores auxiliares para algoritmo de conjuntos disjuntos
representante_conjunto = [0] * MAX_VERTICES
visitado = [False] * MAX_VERTICES
altura_conjunto = [0] * MAX_VERTICES
pai_conjunto = [0] * MAX_VERTICES
profundidade = [0] * MAX_VERTICES
grafo = [[] for _ in range(MAX_VERTICES)]

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

# Função para encontrar o representante de um conjunto
def encontrar_representante(vertice):
    while pai_conjunto[vertice]:
        vertice = pai_conjunto[vertice]
    return vertice

# Função para unir dois conjuntos
def unir_conjuntos(vertice_a, vertice_b):
    representante_a = encontrar_representante(vertice_a)
    representante_b = encontrar_representante(vertice_b)
    
    grafo[representante_a].clear()
    grafo[representante_b].clear()
    visitado[representante_a] = False
    visitado[representante_b] = False
    pai_conjunto[representante_a] = 0
    pai_conjunto[representante_b] = 0
    
    if representante_a == representante_b:
        return
    
    if altura_conjunto[representante_a] > altura_conjunto[representante_b]:
        pai_conjunto[representante_b] = representante_a
    else:
        pai_conjunto[representante_a] = representante_b
        if altura_conjunto[representante_a] == altura_conjunto[representante_b]:
            altura_conjunto[representante_b] += 1

# Função para adicionar uma aresta ao grafo
def adicionar_aresta(vertice_a, vertice_b, indice):
    if vertice_a == vertice_b:
        return
    tipo_conectividade[indice] = 1
    grafo[vertice_a].append((vertice_b, indice))
    grafo[vertice_b].append((vertice_a, indice))

# Função de busca em profundidade (DFS)
def dfs(vertice_atual, indice_aresta_atual, profundidade_atual):
    visitado[vertice_atual] = True
    profundidade[vertice_atual] = profundidade_atual
    
    for vizinho, indice_vizinho in grafo[vertice_atual]:
        if not visitado[vizinho]:
            dfs(vizinho, indice_vizinho, profundidade_atual + 1)
            profundidade[vertice_atual] = min(profundidade[vertice_atual], profundidade[vizinho])
        elif indice_vizinho != indice_aresta_atual:
            profundidade[vertice_atual] = min(profundidade[vertice_atual], profundidade[vizinho])
    
    if profundidade[vertice_atual] == profundidade_atual:
        tipo_conectividade[indice_aresta_atual] = 2

# Leitura das informações das arestas
for indice in range(1, num_arestas + 1):
    aresta_origem[indice], aresta_destino[indice], peso_aresta[indice] = map(int, input().split())
    indice_aresta[indice] = indice

# Ordena as arestas com base em seus pesos
indice_aresta.sort(key=lambda indice: peso_aresta[indice])

indice = 1
while indice <= num_arestas:
    j = indice
    while j <= num_arestas and peso_aresta[indice_aresta[j]] == peso_aresta[indice_aresta[indice]]:
        adicionar_aresta(encontrar_representante(aresta_origem[indice_aresta[j]]), encontrar_representante(aresta_destino[indice_aresta[j]]), indice_aresta[j])
        j += 1
    
    j = indice
    while j <= num_arestas and peso_aresta[indice_aresta[j]] == peso_aresta[indice_aresta[indice]]:
        conjunto_a = encontrar_representante(aresta_origem[indice_aresta[j]])
        if not visitado[conjunto_a]:
            dfs(conjunto_a, 0, 0)
        j += 1
    
    j = indice
    while j <= num_arestas and peso_aresta[indice_aresta[j]] == peso_aresta[indice_aresta[indice]]:
        unir_conjuntos(aresta_origem[indice_aresta[j]], aresta_destino[indice_aresta[j]])
        j += 1
    
    indice = j

# Impressão do tipo de conectividade para cada aresta
for indice in range(1, num_arestas + 1):
    if tipo_conectividade[indice] == 0:
        print("none")
    elif tipo_conectividade[indice] == 1:
        print("at least one")
    else:
        print("any")