use contest::io::Scanner;

fn main() {
    let mut sc = Scanner::new(std::io::stdin());
    let n = sc.next::<usize>();
    let q = sc.next::<usize>();
    let s = sc.next::<String>().chars().collect::<Vec<char>>();
    let mut t: Vec<char> = vec![];
    let mut d: Vec<char> = vec![];
    for _ in 0..q {
        t.push(sc.next::<String>().chars().collect::<Vec<char>>()[0]);
        d.push(sc.next::<String>().chars().collect::<Vec<char>>()[0]);
    }
    // println!("{:?}", s);
    let mut left = -1 as i32;
    let mut right = n as i32;
    while right - left > 1 {
        let mid = (left + right) / 2;
        let mut i = mid;
        let mut fall = false;
        for j in 0..q {
            if s[i as usize] == t[j] {
                i += if d[j] == 'L' { -1 } else { 1 };
            }
            if i < 0 {
                fall = true;
                break;
            } else if i >= (n as i32) {
                break;
            }
        }
        if fall {
            left = mid;
        } else {
            right = mid;
        }
    }
    let res1 = left;
    // println!("{}", res1);

    let mut left = -1 as i32;
    let mut right = n as i32;
    while right - left > 1 {
        let mid = (left + right) / 2;
        let mut i = mid;
        let mut fall = false;
        for j in 0..q {
            if s[i as usize] == t[j] {
                i += if d[j] == 'L' { -1 } else { 1 };
            }
            if i < 0 {
                break;
            } else if i >= (n as i32) {
                fall = true;
                break;
            }
        }
        if fall {
            right = mid;
        } else {
            left = mid;
        }
    }
    let res2 = right;
    let res = res2 - res1 - 1;
    println!("{}", res);
}
pub mod contest {
    pub mod io {
        /// Scanner
        ///
        /// # Example
        /// ```
        /// use contest::io::Scanner;
        /// let mut sc = Scanner::new("1 2 \n\n \r\t \n 3.5".as_bytes());
        /// assert_eq!("1".to_string(), sc.next::<String>());
        /// assert_eq!(2, sc.next());
        /// assert_eq!(3.5, sc.next());
        ///
        /// // To create a scanner from stdin:
        /// Scanner::new(std::io::stdin());
        /// ```
        use std;
        use std::io;
        use std::io::BufRead;

        pub struct Scanner<R: io::Read> {
            br: io::BufReader<R>,
            // Read tokens are stored in reversed order per line.
            buf: Vec<String>,
        }

        pub fn new<R: io::Read>(r: R) -> Scanner<R> {
            Scanner::new(r)
        }

        impl<R: io::Read> Scanner<R> {
            #[inline]
            pub fn new(r: R) -> Scanner<R> {
                Scanner {
                    br: io::BufReader::new(r),
                    buf: vec![],
                }
            }
            #[inline]
            pub fn next<T>(&mut self) -> T
            where
                T: std::str::FromStr,
                T::Err: std::fmt::Debug,
            {
                self.next_string()
                    .map(|s| s.parse::<T>().expect("Parse failed: "))
                    .expect("Unexpected EOF")
            }
            #[inline]
            pub fn next2<T1, T2>(&mut self) -> (T1, T2)
            where
                T1: std::str::FromStr,
                T2: std::str::FromStr,
                T1::Err: std::fmt::Debug,
                T2::Err: std::fmt::Debug,
            {
                (self.next(), self.next())
            }
            fn next_string(&mut self) -> Option<String> {
                self.buf.pop().or_else(|| match self.update() {
                    true => self.next_string(),
                    false => None,
                })
            }
            #[inline]
            fn update(&mut self) -> bool {
                let mut s = String::new();
                let res = self.br.read_line(&mut s);
                match res.expect("I/O error.") {
                    0 => false,
                    _ => {
                        self.buf = s.split_whitespace().map(|x| x.to_string()).rev().collect();
                        true
                    }
                }
            }
        }

        #[test]
        fn test_next() {
            let mut sc = new("hoge".as_bytes());
            let s: String = sc.next();
            assert_eq!("hoge", s);
        }
    }
}


Measured memory_bytes: 8572