use std::io;

fn main() {
    let mut buf = String::new();
    io::stdin().read_line(&mut buf).unwrap();
    let mut n_and_q = buf.split_whitespace();
    n_and_q.next().unwrap();
    let q_len = n_and_q.next().unwrap().parse::<usize>().unwrap();
    drop(n_and_q);

    buf.clear();
    io::stdin().read_line(&mut buf).unwrap();
    buf.pop().unwrap();
    let s = buf;

    let mut spells = vec![String::new(); q_len];
    for spell in spells.iter_mut() {
        io::stdin().read_line(spell).unwrap();
    }

    let spells: Vec<_> = spells
        .into_iter()
        .map(|spell| {
            let mut iter = spell.split_whitespace();
            let t = iter.next().unwrap().chars().next().unwrap();
            let d = iter.next().unwrap().chars().next().unwrap();
            (t, d)
        })
        .collect();

    let mut indices = Vec::with_capacity(s.len());
    let mut golems = vec![1_u32; s.len()];
    for (t, d) in spells.into_iter() {
        s.chars()
            .enumerate()
            .map(|(i, s)| if s == t { indices.push(i); });

        indices
            .iter()
            .map(|&index| {
                match d {
                    'R' => {
                        if index != s.len() - 1 {
                            golems[index+1] += golems[index];
                        }
                        golems[index] = 0;
                    }
                    'L' => {
                        if index != 0 {
                            golems[index-1] += golems[index];
                        }
                        golems[index] = 0;
                    }
                    e @ _ => panic!("unexpected char '{}'", e),
                }
            });

        indices.clear();

    }

    println!("{}", golems.iter().sum::<u32>());
}
