```go
package main

import (
	"fmt"
	"io"
	"os"
)

const MOD int64 = 1000000007
const INF int64 = 1 << 60

func analyze(s []byte, vertical bool) (int, int, int, []int, []int) {
	cur, maxv, minv := 0, 0, 0
	if vertical {
		for _, ch := range s {
			if ch == 'D' {
				cur++
			} else if ch == 'U' {
				cur--
			}
			if cur > maxv {
				maxv = cur
			}
			if cur < minv {
				minv = cur
			}
		}
	} else {
		for _, ch := range s {
			if ch == 'R' {
				cur++
			} else if ch == 'L' {
				cur--
			}
			if cur > maxv {
				maxv = cur
			}
			if cur < minv {
				minv = cur
			}
		}
	}

	d := cur
	mPos := maxv
	mNeg := -minv
	firstPos := make([]int, mPos+1)
	firstNeg := make([]int, mNeg+1)

	cur = 0
	if vertical {
		for i, ch := range s {
			if ch == 'D' {
				cur++
			} else if ch == 'U' {
				cur--
			}
			if cur > 0 && firstPos[cur] == 0 {
				firstPos[cur] = i + 1
			}
			if cur < 0 && firstNeg[-cur] == 0 {
				firstNeg[-cur] = i + 1
			}
		}
	} else {
		for i, ch := range s {
			if ch == 'R' {
				cur++
			} else if ch == 'L' {
				cur--
			}
			if cur > 0 && firstPos[cur] == 0 {
				firstPos[cur] = i + 1
			}
			if cur < 0 && firstNeg[-cur] == 0 {
				firstNeg[-cur] = i + 1
			}
		}
	}

	return d, mPos, mNeg, firstPos, firstNeg
}

func buildEvents(n, capv, d, mPos, mNeg int, firstPos, firstNeg []int) []int64 {
	size := capv
	if d == 0 && mPos+mNeg < size {
		size = mPos + mNeg
	}
	events := make([]int64, 0, size)

	posTime := func(idx int) int64 {
		if idx <= mPos {
			return int64(firstPos[idx])
		}
		if d <= 0 {
			return INF
		}
		extra := idx - mPos - 1
		cycle := extra/d + 1
		q := extra%d + 1
		base := mPos - d + q
		return int64(cycle)*int64(n) + int64(firstPos[base])
	}

	negTime := func(idx int) int64 {
		if idx <= mNeg {
			return int64(firstNeg[idx])
		}
		if d >= 0 {
			return INF
		}
		step := -d
		extra := idx - mNeg - 1
		cycle := extra/step + 1
		q := extra%step + 1
		base := mNeg - step + q
		return int64(cycle)*int64(n) + int64(firstNeg[base])
	}

	iPos, iNeg := 1, 1
	for len(events) < capv {
		tp := posTime(iPos)
		tn := negTime(iNeg)
		if tp == INF && tn == INF {
			break
		}
		if tp < tn {
			events = append(events, tp)
			iPos++
		} else {
			events = append(events, tn)
			iNeg++
		}
	}

	return events
}

func main() {
	data, _ := io.ReadAll(os.Stdin)
	p := 0

	nextInt := func() int {
		for p < len(data) && data[p] <= ' ' {
			p++
		}
		sign := 1
		if data[p] == '-' {
			sign = -1
			p++
		}
		val := 0
		for p < len(data) && data[p] > ' ' {
			val = val*10 + int(data[p]-'0')
			p++
		}
		return sign * val
	}

	nextToken := func() []byte {
		for p < len(data) && data[p] <= ' ' {
			p++
		}
		start := p
		for p < len(data) && data[p] > ' ' {
			p++
		}
		return data[start:p]
	}

	n := nextInt()
	h := nextInt()
	w := nextInt()
	s := nextToken()

	dv, mvPos, mvNeg, fvPos, fvNeg := analyze(s, true)
	dh, mhPos, mhNeg, fhPos, fhNeg := analyze(s, false)

	if dv == 0 && mvPos+mvNeg < h && dh == 0 && mhPos+mhNeg < w {
		fmt.Print("-1")
		return
	}

	evV := buildEvents(n, h, dv, mvPos, mvNeg, fvPos, fvNeg)
	evH := buildEvents(n, w, dh, mhPos, mhNeg, fhPos, fhNeg)

	iV, iH := 0, 0
	pV, pH := 0, 0
	cur := int64(0)
	ans := int64(0)

	for iV < h && iH < w {
		nv, nh := INF, INF
		if pV < len(evV) {
			nv = evV[pV]
		}
		if pH < len(evH) {
			nh = evH[pH]
		}
		next := nv
		if nh < next {
			next = nh
		}
		if next == INF {
			fmt.Print("-1")
			return
		}

		length := next - cur
		rows := int64(h - iV)
		cols := int64(w - iH)
		ans = (ans + (length%MOD)*((rows%MOD)*(cols%MOD)%MOD)) % MOD

		cur = next
		for pV < len(evV) && evV[pV] == cur {
			iV++
			pV++
		}
		for pH < len(evH) && evH[pH] == cur {
			iH++
			pH++
		}
	}

	fmt.Print(ans % MOD)
}
```