```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"sort"
)

type Edge struct {
	u, v, w, id int
}

type NodeEdge struct {
	to, id int
}

type DSU struct {
	parent []int
}

func NewDSU(n int) *DSU {
	p := make([]int, n+1)
	for i := range p {
		p[i] = i
	}
	return &DSU{parent: p}
}

func (d *DSU) Find(i int) int {
	if d.parent[i] != i {
		d.parent[i] = d.Find(d.parent[i])
	}
	return d.parent[i]
}

func (d *DSU) Union(i, j int) {
	rootI := d.Find(i)
	rootJ := d.Find(j)
	if rootI != rootJ {
		d.parent[rootI] = rootJ
	}
}

var (
	tin, low []int
	timer    int
	adj      [][]NodeEdge
	ans      []string
)

func dfs(u, pEdgeId int) {
	tin[u] = timer
	low[u] = timer
	timer++
	for _, e := range adj[u] {
		if e.id == pEdgeId {
			continue
		}
		if tin[e.to] != -1 {
			if tin[e.to] < low[u] {
				low[u] = tin[e.to]
			}
		} else {
			dfs(e.to, e.id)
			if low[e.to] < low[u] {
				low[u] = low[e.to]
			}
			if low[e.to] > tin[u] {
				ans[e.id] = "any"
			}
		}
	}
}

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	defer out.Flush()

	var n, m int
	fmt.Fscan(in, &n, &m)

	edges := make([]Edge, m)
	for i := 0; i < m; i++ {
		fmt.Fscan(in, &edges[i].u, &edges[i].v, &edges[i].w)
		edges[i].id = i
	}

	sort.Slice(edges, func(i, j int) bool {
		return edges[i].w < edges[j].w
	})

	dsu := NewDSU(n)
	ans = make([]string, m)
	adj = make([][]NodeEdge, n+1)
	tin = make([]int, n+1)
	low = make([]int, n+1)
	for i := range tin {
		tin[i] = -1
	}

	activeNodes := make([]int, 0)

	for i := 0; i < m; {
		j := i
		for j < m && edges[j].w == edges[i].w {
			j++
		}

		activeNodes = activeNodes[:0]

		// Phase 1: Identify "none" vs candidates and build component graph
		for k := i; k < j; k++ {
			u := dsu.Find(edges[k].u)
			v := dsu.Find(edges[k].v)

			if u != v {
				ans[edges[k].id] = "at least one"
				adj[u] = append(adj[u], NodeEdge{to: v, id: edges[k].id})
				adj[v] = append(adj[v], NodeEdge{to: u, id: edges[k].id})
				activeNodes = append(activeNodes, u, v)
			} else {
				ans[edges[k].id] = "none"
			}
		}

		// Phase 2: Find bridges in component graph
		timer = 0
		for _, node := range activeNodes {
			if tin[node] == -1 {
				dfs(node, -1)
			}
		}

		// Phase 3: Merge components in DSU and cleanup
		for k := i; k < j; k++ {
			u := dsu.Find(edges[k].u)
			v := dsu.Find(edges[k].v)
			if u != v {
				dsu.Union(u, v)
			}
		}

		for _, node := range activeNodes {
			adj[node] = adj[node][:0]
			tin[node] = -1
			low[node] = -1
		}

		i = j
	}

	for i := 0; i < m; i++ {
		fmt.Fprintln(out, ans[i])
	}
}
```