```go
package main

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

const N = 10000
const TN = 4 * (N + 1)
const BSS = (2*N + 100 + 63) / 64

var bits [TN][]uint64
var lazy [TN][]int

func main() {
	in := bufio.NewReader(os.Stdin)
	out := bufio.NewWriter(os.Stdout)
	var n, q int
	fmt.Fscan(in, &n, &q)
	type op struct {
		l, r, x int
	}
	ops := make([]op, q)
	for i := 0; i < q; i++ {
		fmt.Fscan(in, &ops[i].l, &ops[i].r, &ops[i].x)
	}
	for i := 0; i < TN; i++ {
		bits[i] = make([]uint64, BSS)
		lazy[i] = make([]int, 0)
	}
	build(1, 1, n)
	for _, o := range ops {
		if o.l <= o.r {
			update(1, 1, n, o.l, o.r, o.x)
		}
	}
	push(1, 1, n)
	bs := bits[1]
	var res []int
	for y := 1; y <= n; y++ {
		idx := y / 64
		bit := uint64(1) << (y % 64)
		if (bs[idx] & bit) != 0 {
			res = append(res, y)
		}
	}
	fmt.Fprintln(out, len(res))
	for i, v := range res {
		if i > 0 {
			fmt.Fprint(out, " ")
		}
		fmt.Fprint(out, v)
	}
	fmt.Fprintln(out)
}

func build(node, start, end int) {
	if start == end {
		bits[node][0] = 1
		return
	}
	mid := (start + end) / 2
	build(2*node, start, mid)
	build(2*node+1, mid+1, end)
	orbit(&bits[node], bits[2*node], bits[2*node+1])
}

func push(node, start, end int) {
	if len(lazy[node]) > 0 {
		for _, x := range lazy[node] {
			shiftOr(&bits[node], x)
		}
		if start != end {
			lazy[2*node] = append(lazy[2*node], lazy[node]...)
			lazy[2*node+1] = append(lazy[2*node+1], lazy[node]...)
		}
		lazy[node] = lazy[node][:0]
	}
}

func update(node, start, end, us, ue, x int) {
	push(node, start, end)
	if end < us || start > ue {
		return
	}
	if us <= start && end <= ue {
		shiftOr(&bits[node], x)
		if start != end {
			lazy[2*node] = append(lazy[2*node], x)
			lazy[2*node+1] = append(lazy[2*node+1], x)
		}
		return
	}
	mid := (start + end) / 2
	update(2*node, start, mid, us, ue, x)
	update(2*node+1, mid+1, end, us, ue, x)
	orbit(&bits[node], bits[2*node], bits[2*node+1])
}

func shiftOr(bs *[]uint64, x int) {
	if x == 0 || x > N {
		return
	}
	b := *bs
	shifted := make([]uint64, BSS)
	wordShift := x / 64
	bitShift := x % 64
	carry := uint64(0)
	for i := 0; i < BSS; i++ {
		tmp := b[i]
		if i+wordShift < BSS {
			shifted[i+wordShift] |= (tmp << bitShift) | carry
		}
		carry = tmp >> (64 - bitShift)
		if bitShift == 0 {
			carry = 0
		}
		if i+wordShift+1 < BSS {
			shifted[i+wordShift+1] |= carry
		}
	}
	for i := 0; i < BSS; i++ {
		b[i] |= shifted[i]
	}
}

func orbit(dest *[]uint64, a, b []uint64) {
	d := *dest
	for i := 0; i < BSS; i++ {
		d[i] = a[i] | b[i]
	}
}
```