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
def encontrar_representante(vertice, pai):
    if pai[vertice] == vertice:
        return vertice
    return encontrar_representante(pai[vertice], pai)

# Função para unir dois conjuntos
def unir_conjuntos(vertice_a, vertice_b, pai, altura):
    representante_a = encontrar_representante(vertice_a, pai)
    representante_b = encontrar_representante(vertice_b, pai)

    if representante_a != representante_b:
        if altura[representante_a] < altura[representante_b]:
            pai[representante_a] = representante_b
        elif altura[representante_a] > altura[representante_b]:
            pai[representante_b] = representante_a
        else:
            pai[representante_b] = representante_a
            altura[representante_a] += 1

# Função que encontra a MST e verifica a inclusão das arestas
def encontrar_mst_e_verificar_inclusao(n, arestas):
    pai = list(range(n + 1))
    altura = [0] * (n + 1)
    inclusao_mst = [False] * len(arestas)
    inclusao_pelo_menos_uma_mst = [False] * len(arestas)

    arestas.sort(key=lambda x: x[2])  # Ordena as arestas pelo peso

    mst_peso = 0  # Inicializa o peso da MST como 0
    num_conjuntos = n  # Inicializa o número de conjuntos como o número de vértices

    for i, (a, b, peso) in enumerate(arestas):
        representante_a = encontrar_representante(a, pai)
        representante_b = encontrar_representante(b, pai)

        if representante_a != representante_b:
            inclusao_mst[i] = True
            mst_peso += peso
            unir_conjuntos(a, b, pai, altura)
            num_conjuntos -= 1

    # Verifica a inclusão em pelo menos uma MST
    for i, (a, b, peso) in enumerate(arestas):
        if not inclusao_mst[i]:
            inclusao_pelo_menos_uma_mst[i] = num_conjuntos > 1

    return inclusao_mst, inclusao_pelo_menos_uma_mst

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

for _ in range(m):
    a, b, w = map(int, input().split())
    arestas.append((a, b, w))

# Encontra a inclusão das arestas em MSTs
inclusao_mst, inclusao_pelo_menos_uma_mst = encontrar_mst_e_verificar_inclusao(n, arestas)

# Imprime as respostas
for i in range(m):
    if inclusao_mst[i]:
        print("any")
    elif inclusao_pelo_menos_uma_mst[i]:
        print("at least one")
    else:
        print("none")
