```go
package main

import (
	"bufio"
	"fmt"
	"os"
	"strconv"
	"strings"
)

type Run struct {
	l int64
	c byte
}

func parseToken(tok string) (int64, byte) {
	parts := strings.Split(tok, "-")
	l, _ := strconv.ParseInt(parts[0], 10, 64)
	return l, parts[1][0]
}

func mergeRuns(a []Run) []Run {
	if len(a) == 0 {
		return a
	}
	res := make([]Run, 0, len(a))
	cur := a[0]
	for i := 1; i < len(a); i++ {
		if a[i].c == cur.c {
			cur.l += a[i].l
		} else {
			res = append(res, cur)
			cur = a[i]
		}
	}
	res = append(res, cur)
	return res
}

func equal(a, b Run) bool {
	return a.c == b.c && a.l == b.l
}

func prefixFunction(p []Run) []int {
	pi := make([]int, len(p))
	for i := 1; i < len(p); i++ {
		j := pi[i-1]
		for j > 0 && !equal(p[i], p[j]) {
			j = pi[j-1]
		}
		if equal(p[i], p[j]) {
			j++
		}
		pi[i] = j
	}
	return pi
}

func main() {
	in := bufio.NewReaderSize(os.Stdin, 1<<20)
	out := bufio.NewWriterSize(os.Stdout, 1<<20)
	defer out.Flush()

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

	t := make([]Run, 0, n)
	for i := 0; i < n; i++ {
		var tok string
		fmt.Fscan(in, &tok)
		l, c := parseToken(tok)
		t = append(t, Run{l, c})
	}
	s := make([]Run, 0, m)
	for i := 0; i < m; i++ {
		var tok string
		fmt.Fscan(in, &tok)
		l, c := parseToken(tok)
		s = append(s, Run{l, c})
	}

	t = mergeRuns(t)
	s = mergeRuns(s)

	var ans int64 = 0

	if len(s) == 1 {
		p := s[0]
		for _, r := range t {
			if r.c == p.c && r.l >= p.l {
				ans += r.l - p.l + 1
			}
		}
		fmt.Fprintln(out, ans)
		return
	}

	if len(s) == 2 {
		for i := 0; i+1 < len(t); i++ {
			if t[i].c == s[0].c && t[i+1].c == s[1].c && t[i].l >= s[0].l && t[i+1].l >= s[1].l {
				ans++
			}
		}
		fmt.Fprintln(out, ans)
		return
	}

	if len(t) < len(s) {
		fmt.Fprintln(out, 0)
		return
	}

	P := s[1 : len(s)-1]
	Tmid := t[1 : len(t)-1]
	pi := prefixFunction(P)
	j := 0
	plen := len(P)
	for i := 0; i < len(Tmid); i++ {
		for j > 0 && !equal(Tmid[i], P[j]) {
			j = pi[j-1]
		}
		if equal(Tmid[i], P[j]) {
			j++
		}
		if j == plen {
			k := i - plen + 1
			left := t[k]
			right := t[k+plen+1]
			if left.c == s[0].c && left.l >= s[0].l && right.c == s[len(s)-1].c && right.l >= s[len(s)-1].l {
				ans++
			}
			j = pi[j-1]
		}
	}

	fmt.Fprintln(out, ans)
}
```