```go
package main

import (
	"bufio"
	"os"
	"strconv"
)

var scanner *bufio.Scanner
var writer *bufio.Writer

func init() {
	scanner = bufio.NewScanner(os.Stdin)
	scanner.Split(bufio.ScanWords)
	writer = bufio.NewWriter(os.Stdout)
}

func nextInt() int {
	scanner.Scan()
	val, _ := strconv.Atoi(scanner.Text())
	return val
}

func main() {
	defer writer.Flush()

	if !scanner.Scan() {
		return
	}
	n, _ := strconv.Atoi(scanner.Text())
	q := nextInt()

	// Initial upper bounds: all bits allowed (up to 2^30 - 1)
	upper := make([]int, n+1)
	mask := (1 << 30) - 1
	for i := range upper {
		upper[i] = mask
	}

	type Constraint struct {
		u, v, x int
	}
	constraints := make([]Constraint, q)

	for k := 0; k < q; k++ {
		u := nextInt()
		v := nextInt()
		x := nextInt()
		constraints[k] = Constraint{u, v, x}

		// Update upper bounds: bits not in x cannot be in a[u] or a[v]
		upper[u] &= x
		upper[v] &= x
	}

	lower := make([]int, n+1)
	type Edge struct {
		to, x int
	}
	adj := make([][]Edge, n+1)

	for _, c := range constraints {
		u, v, x := c.u, c.v, c.x
		if u == v {
			// If u == v, a[u] | a[u] = x => a[u] = x. 
			// upper[u] already limits it to <= x, lower must force it to >= x.
			lower[u] |= x
		} else {
			// For a constraint a[u] | a[v] = x:
			// If upper[v] forbids a bit that is in x, then a[u] MUST have that bit.
			lower[u] |= (x &^ upper[v])
			lower[v] |= (x &^ upper[u])
			
			// Build adjacency for propagation in the greedy loop.
			// We only need to propagate from i to j where j > i.
			if u < v {
				adj[u] = append(adj[u], Edge{v, x})
			} else {
				adj[v] = append(adj[v], Edge{u, x})
			}
		}
	}

	a := make([]int, n+1)
	for i := 1; i <= n; i++ {
		// Greedy choice: pick the smallest possible value for a[i]
		val := lower[i]
		a[i] = val
		
		// Propagate requirements to future neighbors
		for _, e := range adj[i] {
			// For constraint a[i] | a[e.to] = e.x
			// Bits in e.x that are NOT provided by a[i] MUST be provided by a[e.to]
			req := e.x &^ val
			lower[e.to] |= req
		}
	}

	for i := 1; i <= n; i++ {
		if i > 1 {
			writer.WriteByte(' ')
		}
		writer.WriteString(strconv.Itoa(a[i]))
	}
	writer.WriteByte('\n')
}
```