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.
class UnionFind:
    def __init__(self, n):
        self.parent = [i for i in range(n + 1)]
        self.rank = [0] * (n + 1)

    def find(self, x):
        if self.parent[x] != x:
            self.parent[x] = self.find(self.parent[x])
        return self.parent[x]

    def union(self, x, y):
        root_x = self.find(x)
        root_y = self.find(y)

        if root_x != root_y:
            if self.rank[root_x] < self.rank[root_y]:
                root_x, root_y = root_y, root_x
            self.parent[root_y] = root_x
            if self.rank[root_x] == self.rank[root_y]:
                self.rank[root_x] += 1

def kruskal(n, edges, excluded_edge):
    edges.sort(key=lambda x: x[2])
    uf = UnionFind(n)

    total_weight = 0
    included_edges = set()

    for edge in edges:
        u, v, w = edge
        if (u, v, w) != excluded_edge and uf.find(u) != uf.find(v):
            uf.union(u, v)
            total_weight += w
            included_edges.add((u, v, w))

    return total_weight, included_edges

def main():
    n, m = map(int, input().split())
    edges = [tuple(map(int, input().split())) for _ in range(m)]

    for i in range(m):
        excluded_edge = edges[i]
        weight, included_edges = kruskal(n, edges, excluded_edge)

        if len(included_edges) == n - 1:
            print("any")
        elif weight == 0:
            print("none")
        else:
            print("at least one")

if __name__ == "__main__":
    main()
