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;
struct edges {
  int id, u, v, w;
  bool operator<(const edges &ee) const { return w < ee.w; }
};
struct edges e[100010], st[100010];
vector<struct edges> tree[100010];
int f[100010], n, m, ans[100010], stp;
void init() {
  for (int i = 0; i < m; i++) {
    scanf("%d %d %d", &e[i].u, &e[i].v, &e[i].w);
    e[i].id = i;
    ans[i] = -1;
  }
  for (int i = 1; i <= n; i++) tree[i].clear();
  sort(e, e + m);
}
int find(int x) {
  int tmp = x;
  while (f[tmp] > 0) tmp = f[tmp];
  if (tmp != x) f[x] = tmp;
  return tmp;
}
void kruskal() {
  for (int i = 1; i <= n; i++) f[i] = -1;
  int left = n, p = 0, f1, f2, longest = 0;
  stp = 0;
  while (true) {
    f1 = find(e[p].u);
    f2 = find(e[p].v);
    if (f1 != f2) {
      ans[e[p].id] = 1;
      longest = e[p].w;
      f[f1] = f2;
      tree[e[p].u].push_back(e[p]);
      tree[e[p].v].push_back(e[p]);
      left--;
      if (left == 1) {
        p++;
        break;
      }
    } else
      st[stp++] = e[p];
    p++;
  }
  while (e[p].w == longest && p < m) {
    st[stp++] = e[p];
    p++;
  }
}
int dfn[100010], id;
int stfind(int w) {
  int l = 0, r = stp - 1, mid, i;
  while (r - l > 10) {
    mid = (l + r) >> 1;
    if (st[mid].w < w)
      l = mid + 1;
    else
      r = mid;
  }
  for (i = l; st[i].w != w && i <= r; i++)
    ;
  if (i > r) return stp;
  for (; st[i].w == w && st[i - 1].w == w; i--)
    ;
  return i;
}
void judge(int num, struct edges &edge) {
  for (int it = stfind(edge.w);; it++) {
    if (st[it].w != edge.w || it >= stp) break;
    if ((dfn[st[it].u] >= num && dfn[st[it].v] < num) ||
        (dfn[st[it].u] < num && dfn[st[it].v] >= num)) {
      ans[edge.id] = 0;
      ans[st[it].id] = 0;
    }
  }
}
void dfs(int u, int father) {
  dfn[u] = id++;
  int size = tree[u].size(), v, f;
  for (int i = 0; i < size; i++) {
    if (tree[u][i].u == u)
      v = tree[u][i].v;
    else
      v = tree[u][i].u;
    if (v == father) {
      f = i;
      continue;
    }
    dfs(v, u);
  }
  if (father != 0) judge(dfn[u], tree[u][f]);
}
int main() {
  while (scanf("%d %d", &n, &m) != EOF) {
    init();
    kruskal();
    for (int i = 1; i <= n; i++) dfn[i] = -1;
    id = 1;
    dfs(1, 0);
    for (int i = 0; i < m; i++) {
      if (ans[i] == -1)
        printf("none\n");
      else if (ans[i] == 0)
        printf("at least one\n");
      else
        printf("any\n");
    }
  }
  return 0;
}
