```go
package main

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

func main() {
	in := bufio.NewReader(os.Stdin)
	var alpha string
	if _, err := fmt.Fscan(in, &alpha); err != nil {
		return
	}
	l := len(alpha)

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

	typ := make([]byte, 256)
	minV, minC := -1, -1
	for i := 0; i < l; i++ {
		c := byte('a' + i)
		typ[c] = alpha[i]
		if alpha[i] == 'V' && minV == -1 {
			minV = int(c)
		}
		if alpha[i] == 'C' && minC == -1 {
			minC = int(c)
		}
	}

	adj := make([][]int, 2*n)
	for i := 0; i < m; i++ {
		var p1 int
		var t1 string
		var p2 int
		var t2 string
		fmt.Fscan(in, &p1, &t1, &p2, &t2)
		u := 2 * (p1 - 1)
		if t1 == "V" {
			u++
		}
		v := 2 * (p2 - 1)
		if t2 == "V" {
			v++
		}
		adj[u] = append(adj[u], v)
		adj[v^1] = append(adj[v^1], u^1)
	}

	var s string
	fmt.Fscan(in, &s)

	if minV == -1 {
		for i := 0; i < n; i++ {
			adj[2*i+1] = append(adj[2*i+1], 2*i)
		}
	}
	if minC == -1 {
		for i := 0; i < n; i++ {
			adj[2*i] = append(adj[2*i], 2*i+1)
		}
	}

	dfn := make([]int, 2*n)
	low := make([]int, 2*n)
	for i := range dfn {
		dfn[i] = -1
	}
	inStack := make([]bool, 2*n)
	var stack []int
	scc := make([]int, 2*n)
	timer := 0
	sccCount := 0

	var tarjan func(int)
	tarjan = func(u int) {
		dfn[u] = timer
		low[u] = timer
		timer++
		stack = append(stack, u)
		inStack[u] = true

		for _, v := range adj[u] {
			if dfn[v] == -1 {
				tarjan(v)
				if low[v] < low[u] {
					low[u] = low[v]
				}
			} else if inStack[v] {
				if dfn[v] < low[u] {
					low[u] = dfn[v]
				}
			}
		}

		if low[u] == dfn[u] {
			for {
				v := stack[len(stack)-1]
				stack = stack[:len(stack)-1]
				inStack[v] = false
				scc[v] = sccCount
				if u == v {
					break
				}
			}
			sccCount++
		}
	}

	for i := 0; i < 2*n; i++ {
		if dfn[i] == -1 {
			tarjan(i)
		}
	}

	for i := 0; i < n; i++ {
		if scc[2*i] == scc[2*i+1] {
			fmt.Println("-1")
			return
		}
	}

	forced := make([]int, n)
	for i := range forced {
		forced[i] = -1
	}
	ans := make([]byte, n)

	mark := make([]bool, 2*n)
	q := make([]int, 0, 2*n)

	check := func() bool {
		for i := 0; i < 2*n; i++ {
			mark[i] = false
		}
		q = q[:0]

		for i := 0; i < n; i++ {
			if forced[i] == 1 {
				if mark[2*i] {
					return false
				}
				if !mark[2*i+1] {
					mark[2*i+1] = true
					q = append(q, 2*i+1)
				}
			} else if forced[i] == 0 {
				if mark[2*i+1] {
					return false
				}
				if !mark[2*i] {
					mark[2*i] = true
					q = append(q, 2*i)
				}
			}
		}

		for head := 0; head < len(q); head++ {
			u := q[head]
			if mark[u^1] {
				return false
			}
			for _, v := range adj[u] {
				if !mark[v] {
					if mark[v^1] {
						return false
					}
					mark[v] = true
					q = append(q, v)
				}
			}
		}
		return true
	}

	findSmallest := func(t byte, minChar byte) byte {
		for c := minChar; c < byte('a'+l); c++ {
			if typ[c] == t {
				return c
			}
		}
		return 0
	}

	type Candidate struct {
		c      byte
		typ    byte
		matchS bool
	}

	var dfs func(pos int, matchS bool) bool
	dfs = func(pos int, matchS bool) bool {
		if pos == n {
			return true
		}

		var candidates []Candidate
		if matchS {
			candidates = append(candidates, Candidate{
				c:      s[pos],
				typ:    typ[s[pos]],
				matchS: true,
			})
			v := findSmallest('V', s[pos]+1)
			if v != 0 {
				candidates = append(candidates, Candidate{c: v, typ: 'V', matchS: false})
			}
			c := findSmallest('C', s[pos]+1)
			if c != 0 {
				candidates = append(candidates, Candidate{c: c, typ: 'C', matchS: false})
			}
		} else {
			if minV != -1 {
				candidates = append(candidates, Candidate{c: byte(minV), typ: 'V', matchS: false})
			}
			if minC != -1 {
				candidates = append(candidates, Candidate{c: byte(minC), typ: 'C', matchS: false})
			}
		}

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

		for _, cand := range candidates {
			if cand.typ == 'V' {
				forced[pos] = 1
			} else {
				forced[pos] = 0
			}

			if check() {
				ans[pos] = cand.c
				if dfs(pos+1, cand.matchS) {
					return true
				}
			}
		}
		forced[pos] = -1
		return false
	}

	if dfs(0, true) {
		fmt.Println(string(ans))
	} else {
		fmt.Println("-1")
	}
}
```