package main

import (
	"bufio"
	"io"
	"os"
	"sort"
)

type FastScanner struct {
	data []byte
	idx  int
}

func NewFastScanner() *FastScanner {
	data, _ := io.ReadAll(os.Stdin)
	return &FastScanner{data: data}
}

func (fs *FastScanner) skip() {
	for fs.idx < len(fs.data) && fs.data[fs.idx] <= ' ' {
		fs.idx++
	}
}

func (fs *FastScanner) nextInt() int {
	fs.skip()
	val := 0
	for fs.idx < len(fs.data) && fs.data[fs.idx] > ' ' {
		val = val*10 + int(fs.data[fs.idx]-'0')
		fs.idx++
	}
	return val
}

func (fs *FastScanner) nextBytes() []byte {
	fs.skip()
	start := fs.idx
	for fs.idx < len(fs.data) && fs.data[fs.idx] > ' ' {
		fs.idx++
	}
	return fs.data[start:fs.idx]
}

func (fs *FastScanner) nextByte() byte {
	fs.skip()
	b := fs.data[fs.idx]
	for fs.idx < len(fs.data) && fs.data[fs.idx] > ' ' {
		fs.idx++
	}
	return b
}

type Fenwick struct {
	n    int
	tree []int
}

func NewFenwick(n int) *Fenwick {
	f := &Fenwick{n: n, tree: make([]int, n+1)}
	for i := 1; i <= n; i++ {
		f.tree[i]++
		j := i + (i & -i)
		if j <= n {
			f.tree[j] += f.tree[i]
		}
	}
	return f
}

func (f *Fenwick) Add(i, delta int) {
	for i <= f.n {
		f.tree[i] += delta
		i += i & -i
	}
}

func (f *Fenwick) Kth(k int) int {
	idx := 0
	bit := 1
	for bit<<1 <= f.n {
		bit <<= 1
	}
	for bit > 0 {
		nxt := idx + bit
		if nxt <= f.n && f.tree[nxt] < k {
			idx = nxt
			k -= f.tree[nxt]
		}
		bit >>= 1
	}
	return idx + 1
}

func find(parent []int, x int) int {
	for parent[x] != x {
		parent[x] = parent[parent[x]]
		x = parent[x]
	}
	return x
}

func main() {
	fs := NewFastScanner()
	n := fs.nextInt()
	m := fs.nextInt()
	s := fs.nextBytes()

	pos := make([][]int, 256)
	for i := 0; i < n; i++ {
		pos[s[i]] = append(pos[s[i]], i+1)
	}

	parent := make([][]int, 256)
	for c := 0; c < 256; c++ {
		l := len(pos[c])
		parent[c] = make([]int, l+1)
		for i := 0; i <= l; i++ {
			parent[c][i] = i
		}
	}

	alive := make([]bool, n+1)
	for i := 1; i <= n; i++ {
		alive[i] = true
	}

	bit := NewFenwick(n)

	for ; m > 0; m-- {
		l := fs.nextInt()
		r := fs.nextInt()
		c := fs.nextByte()

		L := bit.Kth(l)
		R := bit.Kth(r)

		list := pos[c]
		par := parent[c]

		idx := sort.SearchInts(list, L)
		idx = find(par, idx)

		for idx < len(list) && list[idx] <= R {
			p := list[idx]
			if alive[p] {
				alive[p] = false
				bit.Add(p, -1)
			}
			par[idx] = find(par, idx+1)
			idx = find(par, idx)
		}
	}

	out := make([]byte, 0, n)
	for i := 1; i <= n; i++ {
		if alive[i] {
			out = append(out, s[i-1])
		}
	}

	w := bufio.NewWriterSize(os.Stdout, 1<<20)
	w.Write(out)
	w.WriteByte('\n')
	w.Flush()
}