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.

Input

The first line contains two integers n and m (2 ≤ n ≤ 105, <image>) — 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 "ai bi wi" (1 ≤ ai, bi ≤ n, 1 ≤ wi ≤ 106, ai ≠ bi), where ai and bi are the numbers of vertexes connected by the i-th edge, wi is the edge's weight. It is guaranteed that the graph is connected and doesn't contain loops or multiple edges.

Output

Print m lines — the answers for all edges. If the i-th edge is included in any MST, print "any"; if the i-th edge is included at least in one MST, print "at least one"; if the i-th edge isn't included in any MST, print "none". Print the answers for the edges in the order in which the edges are specified in the input.

Examples

Input

4 5
1 2 101
1 3 100
2 3 2
2 4 2
3 4 1


Output

none
any
at least one
at least one
any


Input

3 3
1 2 1
2 3 1
1 3 2


Output

any
any
none


Input

3 3
1 2 1
2 3 1
1 3 1


Output

at least one
at least one
at least one

Note

In the second sample the MST is unique for the given graph: it contains two first edges.

In the third sample any two edges form the MST for the given graph. That means that each edge is included at least in one MST.
#include <bits/stdc++.h>
using namespace std;
template <class T>
inline void read(T &x) {
  int f = 0, ch = 0;
  x = 0;
  for (; !isdigit(ch); ch = getchar())
    if (ch == '-') f = 1;
  for (; isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
  if (f) x = -x;
}
map<pair<int, int>, int> mp;
int Ans[(500005)], fa[(500005)], n, m;
struct Point {
  int x, y, z, id;
} e[(500005)];
inline bool cmp(Point A, Point B) { return A.z < B.z; }
inline int ask(int x) { return x == fa[x] ? x : fa[x] = ask(fa[x]); }
namespace Graph {
int dfn[(500005)], low[(500005)], Index;
struct Edge {
  int x, id;
};
vector<Edge> g[(500005)];
map<int, int> mp;
vector<int> s;
inline void Clear() {
  for (int i = 0; i < s.size(); i++) dfn[s[i]] = low[s[i]] = 0, g[s[i]].clear();
  s.clear(), mp.clear(), Index = 0;
}
inline void Add(int x, int y, int id) {
  g[x].push_back((Edge){y, id});
  g[y].push_back((Edge){x, id});
  if (!mp[x]) s.push_back(x), mp[x] = 1;
  if (!mp[y]) s.push_back(y), mp[y] = 1;
}
inline void dfs(int u, int fa) {
  dfn[u] = low[u] = ++Index;
  for (int i = 0; i < g[u].size(); i++) {
    int v = g[u][i].x;
    if (!dfn[v]) {
      dfs(v, u), low[u] = ((low[u]) < (low[v]) ? (low[u]) : (low[v]));
      if (low[v] > dfn[u]) Ans[g[u][i].id] = 2;
    } else if (v != fa)
      low[u] = ((low[u]) < (dfn[v]) ? (low[u]) : (dfn[v]));
  }
}
inline void solve() {
  for (int i = 0; i < s.size(); i++)
    if (!dfn[s[i]]) dfs(s[i], 0);
}
}  // namespace Graph
inline void solve(int l, int r) {
  Graph::Clear(), mp.clear();
  for (int i = l; i <= r; i++) {
    int p = ask(e[i].x), q = ask(e[i].y);
    if (p == q)
      Ans[e[i].id] = 1;
    else {
      pair<int, int> now = make_pair(min(p, q), max(p, q));
      if (++mp[now] == 1) Graph::Add(p, q, e[i].id);
    }
  }
  Graph::solve();
  for (int i = l; i <= r; i++) {
    int p = ask(e[i].x), q = ask(e[i].y);
    if (p == q) continue;
    if (mp[make_pair(min(p, q), max(p, q))] > 1) Ans[e[i].id] = 0;
  }
  for (int i = l; i <= r; i++) {
    int p = ask(e[i].x), q = ask(e[i].y);
    if (p != q) fa[p] = q;
  }
}
int main() {
  read(n), read(m);
  for (int i = 1; i <= n; i++) fa[i] = i;
  for (int i = 1, x, y, z; i <= m; i++) {
    read(x), read(y), read(z);
    e[i] = (Point){x, y, z, i};
  }
  sort(e + 1, e + m + 1, cmp), e[0].z = e[m + 1].z = -1;
  for (int i = 1, l = 1; i <= m; i++) {
    if (e[i].z != e[i - 1].z) l = i;
    if (e[i].z != e[i + 1].z) solve(l, i);
  }
  for (int i = 1; i <= m; i++) {
    if (Ans[i] == 0) puts("at least one");
    if (Ans[i] == 1) puts("none");
    if (Ans[i] == 2) puts("any");
  }
  return 0;
}
