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;
int a, s, f[100002], ds[100002], fx[100002], fx1[100002], low[100002],
    cur[100002], y, g, h, j, k, l, i, n, m;
vector<pair<int, int> > v[100002];
struct edge {
  int val;
  int a;
  int b;
  int idx;
};
edge d[100005];
bool cmp(edge a, edge b) { return a.val < b.val; }
int gpar(int i) { return ds[i] == i ? i : ds[i] = gpar(ds[i]); }
void dsu(int i1, int i2) { ds[gpar(i1)] = gpar(i2); }
void dfs(int idx, int par) {
  if (fx1[idx] == h) return;
  fx1[idx] = h;
  y++;
  cur[idx] = y;
  low[idx] = y;
  for (auto it : v[idx]) {
    if (it.second == par) continue;
    dfs(it.first, it.second);
    if (low[it.first] > cur[idx]) f[it.second] = 1;
    low[idx] = min(low[idx], low[it.first]);
  }
}
void sol(int l, int r) {
  int e, R;
  for (int i = l; i < r; i++) {
    e = gpar(d[i].a);
    R = gpar(d[i].b);
    if (e == R) {
      f[d[i].idx] = 3;
      continue;
    }
    if (fx[e] != h) {
      fx[e] = h;
      v[e].clear();
    }
    if (fx[R] != h) {
      fx[R] = h;
      v[R].clear();
    }
    v[e].push_back({R, d[i].idx});
    v[R].push_back({e, d[i].idx});
  }
  for (int i = l; i < r; i++) {
    y = 0;
    if (fx1[gpar(d[i].a)] != h) dfs(gpar(d[i].a), -1);
    dsu(d[i].a, d[i].b);
  }
}
int main() {
  cin >> n >> m;
  for (i = 0; i < m; i++) {
    scanf("%d%d%d", &d[i].a, &d[i].b, &d[i].val);
    d[i].idx = i;
  }
  for (i = 1; i <= n; i++) ds[i] = i;
  sort(d, d + m, cmp);
  for (i = 0; i < m; i++) {
    if (d[i].val == d[l].val) continue;
    h++;
    sol(l, i);
    l = i;
  }
  h++;
  sol(l, m);
  for (i = 0; i < m; i++) {
    if (f[i] == 1) cout << "any\n";
    if (f[i] == 0) cout << "at least one\n";
    if (f[i] == 3) cout << "none\n";
  }
}
