#include <bits/stdc++.h>
using namespace std;
const long long INF = 1LL << 60;
const double DINF = 1e30;
const long long mod = 1000000007;
const long long MAX_FLOW_MAX_V = 10000;
const long long MIN_COST_FLOW_MAX_V = 10000;
const long long BIPARTITE_MATCHING_MAX_V = 10000;
const long long dx[4] = {1, 0, -1, 0};
const long long dy[4] = {0, -1, 0, 1};
const complex<double> I = complex<double>(0, 1);
const double EPS = 1e-10;
template <typename T>
T tmin(T a, T b) {
  return a > b ? b : a;
};
template <typename T>
T tmax(T a, T b) {
  return a > b ? a : b;
};
template <typename T>
T tadd(T a, T b) {
  return a + b;
};
template <typename T>
T tmul(T a, T b) {
  return a * b;
};
template <typename T>
T tpow(T a, T b) {
  return a * b;
};
long long gcd(long long a, long long b) {
  if (b == 0) return a;
  return gcd(b, a % b);
}
long long extgcd(long long a, long long b, long long &x, long long &y) {
  if (b == 0) {
    x = 1, y = 0;
    return a;
  }
  long long q = a / b, g = extgcd(b, a - q * b, x, y);
  long long z = x - q * y;
  x = y;
  y = z;
  return g;
}
long long invmod(long long a, long long m) {
  long long x, y;
  extgcd(a, m, x, y);
  x %= m;
  if (x < 0) x += m;
  return x;
}
long long nCk(long long n, long long k, long long mod) {
  long long ans = 1;
  for (long long i = n, j = 1; j <= k; i--, j++)
    ans = (((ans * i) % mod) * invmod(j, mod)) % mod;
  return ans;
}
long long lmin(long long a, long long b) { return a > b ? b : a; };
long long lmax(long long a, long long b) { return a > b ? a : b; };
long long lsum(long long a, long long b) { return a + b; };
template <typename T>
struct Matrix {
  long long x, y;
  vector<vector<T> > d;
  Matrix(long long _y, long long _x = -1) {
    if (_x == -1) _x = _y;
    x = _x, y = _y;
    for (int i = 0; i < y; i++)
      for (int j = 0; j < x; j++) d[i][j] = 0;
  }
  void unit() {
    for (int i = 0; i < y; i++)
      for (int j = 0; j < x; j++) d[i][j] = i == j ? 1 : 0;
  }
  Matrix copy() {
    Matrix m(y, x);
    for (int i = 0; i < y; i++)
      for (int j = 0; j < x; j++) m.d[i][j] = d[i][j];
    return m;
  }
  Matrix<T> operator+(Matrix<T> &t) {
    Matrix<T> m(y, x);
    for (int i = 0; i < y; i++)
      for (int j = 0; j < x; j++) m.d[i][j] = d[i][j] + t.d[i][j];
    return m;
  }
  Matrix<T> operator-(Matrix<T> &t) {
    Matrix<T> m(y, x);
    for (int i = 0; i < y; i++)
      for (int j = 0; j < x; j++) m.d[i][j] = d[i][j] - t.d[i][j];
    return m;
  }
  Matrix<T> operator*(T t) {
    Matrix<T> m(y, x);
    for (int i = 0; i < y; i++)
      for (int j = 0; j < x; j++) m.d[i][j] = d[i][j] * t;
    return m;
  }
  Matrix<T> det(Matrix<T> &t) {
    Matrix<T> m(y, x);
    for (int i = 0; i < y; i++)
      for (int j = 0; j < x; j++)
        for (int k = 0; k < t.x; k++) m.d[i][j] += d[i][k] * t.d[k][j];
    return m;
  }
};
template <typename T>
class Zip {
  vector<T> d;
  bool flag;

 public:
  Zip() { flag = false; }
  void add(T x) {
    d.push_back(x);
    flag = true;
  }
  long long getNum(T x) {
    if (flag) {
      sort(d.begin(), d.end());
      d.erase(unique(d.begin(), d.end()), d.end());
      flag = false;
    }
    return lower_bound(d.begin(), d.end(), x) - d.begin();
  }
  long long size() {
    if (flag) {
      sort(d.begin(), d.end());
      d.erase(unique(d.begin(), d.end()), d.end());
      flag = false;
    }
    return (long long)d.size();
  }
};
class UnionFind {
  vector<long long> par, rank;

 public:
  void init(long long n) {
    par.resize(n, 1);
    rank.resize(n, 0);
  }
  long long getSize(long long x) { return par[find(x)]; }
  long long find(long long x) {
    if (par[x] > 0) return x;
    return -(par[x] = -find(-par[x]));
  }
  void merge(long long x, long long y) {
    x = find(x);
    y = find(y);
    if (x == y) return;
    if (rank[x] < rank[y]) {
      par[y] += par[x];
      par[x] = -y;
    } else {
      par[x] += par[y];
      par[y] = -x;
      if (rank[x] == rank[y]) rank[x]++;
    }
  }
  bool isSame(long long x, long long y) { return find(x) == find(y); }
};
template <typename T>
struct UnionFindT {
  vector<long long> par;
  vector<long long> rank;
  vector<T> diff_weight;
  UnionFindT(long long n = 1, T SUM_UNITY = 0) { init(n, SUM_UNITY); }
  void init(long long n = 1, T SUM_UNITY = 0) {
    par.resize(n);
    rank.resize(n);
    diff_weight.resize(n);
    for (long long i = 0; i < n; ++i)
      par[i] = i, rank[i] = 0, diff_weight[i] = SUM_UNITY;
  }
  long long find(long long x) {
    if (par[x] == x) {
      return x;
    } else {
      long long r = find(par[x]);
      diff_weight[x] += diff_weight[par[x]];
      return par[x] = r;
    }
  }
  T weight(long long x) {
    find(x);
    return diff_weight[x];
  }
  bool isSame(long long x, long long y) { return find(x) == find(y); }
  bool merge(long long x, long long y, T w) {
    w += weight(x);
    w -= weight(y);
    x = find(x);
    y = find(y);
    if (x == y) return false;
    if (rank[x] < rank[y]) swap(x, y), w = -w;
    if (rank[x] == rank[y]) ++rank[x];
    par[y] = x;
    diff_weight[y] = w;
    return true;
  }
  T diff(long long x, long long y) { return weight(y) - weight(x); }
};
class PersistentUnionFind {
  vector<long long> rank, fin, par;
  long long index;

 public:
  void init(long long n) {
    index = 0;
    par.resize(n);
    rank.resize(n, 1);
    fin.resize(n, 0);
    for (long long i = 0; i < n; i++) par[i] = i;
  }
  long long find(long long x, long long t) {
    if (t >= fin[x] && par[x] != x) return find(par[x], t);
    return x;
  }
  void merge(long long x, long long y) {
    x = find(x, index);
    y = find(y, index);
    index++;
    if (x == y) return;
    if (rank[x] < rank[y])
      par[x] = y, fin[x] = index;
    else {
      par[y] = x, fin[y] = index;
      if (rank[x] == rank[y]) rank[x]++;
    }
  }
  bool isSame(long long x, long long y, long long t) {
    return find(x, t) == find(y, t);
  }
};
template <typename T>
class SegmentTree {
  long long n;
  vector<T> node;
  function<T(T, T)> fun, fun2;
  bool customChange;
  T outValue, initValue;

 public:
  void init(long long num, function<T(T, T)> resultFunction, T init, T out,
            function<T(T, T)> changeFunction = NULL) {
    fun = resultFunction;
    fun2 = changeFunction;
    customChange = changeFunction != NULL;
    n = 1;
    while (n < num) n *= 2;
    node.resize(2 * n - 1, init);
    outValue = out;
    initValue = init;
  }
  void valueChange(long long num, T value) {
    num += n - 1;
    if (customChange)
      node[num] = fun2(value, node[num]);
    else
      node[num] = value;
    while (num > 0)
      num = (num - 1) / 2,
      node[num] = fun(node[num * 2 + 1], node[num * 2 + 2]);
  }
  T rangeQuery(long long a, long long b, long long l = 0, long long r = -1,
               long long k = 0) {
    if (r == -1) r = n;
    if (a <= l && r <= b) return node[k];
    if (b <= l || r <= a) return outValue;
    long long mid = (l + r) / 2;
    return fun(rangeQuery(a, b, l, mid, 2 * k + 1),
               rangeQuery(a, b, mid, r, 2 * k + 2));
  }
};
template <typename T>
class LazySegmentTree {
  long long n;
  vector<T> node;
  vector<T> lazyNode;
  function<T(T, T)> fun, fun2;
  function<T(T, long long)> fun3;
  T outValue, initValue;
  T substitution(T a, T b) { return a; }
  void eval(long long k, long long l, long long r) {
    if (lazyNode[k] == 0) return;
    node[k] = fun2(fun3(lazyNode[k], r - l), node[k]);
    if (r - l > 1) {
      lazyNode[2 * k + 1] = fun2(lazyNode[k], lazyNode[2 * k + 1]);
      lazyNode[2 * k + 2] = fun2(lazyNode[k], lazyNode[2 * k + 2]);
    }
    lazyNode[k] = initValue;
  }

 public:
  void init(long long num, function<T(T, T)> resultFunction,
            function<T(T, T)> changeFunction,
            function<T(T, long long)> lazyFunction, T init, T out) {
    fun = resultFunction;
    fun2 = changeFunction;
    fun3 = lazyFunction;
    n = 1;
    while (n < num) n *= 2;
    node.resize(2 * n - 1, init);
    lazyNode.resize(2 * n - 1, init);
    outValue = out;
    initValue = init;
  }
  void rangeChange(long long a, long long b, T value, long long l = 0,
                   long long r = -1, long long k = 0) {
    if (r == -1) r = n;
    eval(k, l, r);
    if (b <= l || r <= a) return;
    if (a <= l && r <= b) {
      lazyNode[k] = fun2(value, lazyNode[k]);
      eval(k, l, r);
    } else {
      long long mid = (l + r) / 2;
      rangeChange(a, b, value, l, mid, 2 * k + 1);
      rangeChange(a, b, value, mid, r, 2 * k + 2);
      node[k] = fun(node[2 * k + 1], node[2 * k + 2]);
    }
  }
  T rangeQuery(long long a, long long b, long long l = 0, long long r = -1,
               long long k = 0) {
    if (r == -1) r = n;
    if (b <= l || r <= a) return outValue;
    eval(k, l, r);
    if (a <= l && r <= b) return node[k];
    long long mid = (l + r) / 2;
    return fun(rangeQuery(a, b, l, mid, 2 * k + 1),
               rangeQuery(a, b, mid, r, 2 * k + 2));
  }
};
class MaxFlow {
 public:
  struct edge {
    long long to, cap, rev;
  };
  vector<edge> G[MAX_FLOW_MAX_V];
  bool used[MAX_FLOW_MAX_V];
  long long level[MAX_FLOW_MAX_V];
  long long iter[MAX_FLOW_MAX_V];
  void init() {
    for (long long i = 0; i < MAX_FLOW_MAX_V; i++) {
      G[i].clear();
    }
  }
  void add_edge(long long from, long long to, long long cap) {
    G[from].push_back((edge){to, cap, (long long)G[to].size()});
    G[to].push_back((edge){from, 0, (long long)G[from].size() - 1});
  }
  void add_undirected_edge(long long e1, long long e2, long long cap) {
    G[e1].push_back((edge){e2, cap, (long long)G[e2].size()});
    G[e2].push_back((edge){e1, cap, (long long)G[e1].size() - 1});
  }
  long long dfs(long long v, long long t, long long f) {
    if (v == t) return f;
    used[v] = true;
    for (long long i = 0; i < (long long)G[v].size(); i++) {
      edge &e = G[v][i];
      if (!used[e.to] && e.cap > 0) {
        long long d = dfs(e.to, t, min(f, e.cap));
        if (d > 0) {
          e.cap -= d;
          G[e.to][e.rev].cap += d;
          return d;
        }
      }
    }
    return 0;
  }
  long long max_flow(long long s, long long t) {
    long long flow = 0;
    while (1) {
      memset(used, 0, sizeof(used));
      long long f = dfs(s, t, INF);
      if (f == 0) return flow;
      flow += f;
    }
  }
  void bfs(long long s) {
    memset(level, -1, sizeof(level));
    queue<long long> que;
    level[s] = 0;
    que.push(s);
    while (!que.empty()) {
      long long v = que.front();
      que.pop();
      for (long long i = 0; i < (long long)G[v].size(); i++) {
        edge &e = G[v][i];
        if (e.cap > 0 && level[e.to] < 0) {
          level[e.to] = level[v] + 1;
          que.push(e.to);
        }
      }
    }
  }
  long long dinic_dfs(long long v, long long t, long long f) {
    if (v == t) return f;
    for (long long &i = iter[v]; i < (long long)G[v].size(); i++) {
      edge &e = G[v][i];
      if (e.cap > 0 && level[v] < level[e.to]) {
        long long d = dinic_dfs(e.to, t, min(f, e.cap));
        if (d > 0) {
          e.cap -= d;
          G[e.to][e.rev].cap += d;
          return d;
        }
      }
    }
    return 0;
  }
  long long dinic(long long s, long long t) {
    long long flow = 0;
    while (1) {
      bfs(s);
      if (level[t] < 0) return flow;
      memset(iter, 0, sizeof(iter));
      long long f;
      while ((f = dinic_dfs(s, t, INF)) > 0) {
        flow += f;
      }
    }
  }
};
class BipartiteMatching {
 public:
  long long V;
  vector<long long> G[BIPARTITE_MATCHING_MAX_V];
  long long match[BIPARTITE_MATCHING_MAX_V];
  bool used[BIPARTITE_MATCHING_MAX_V];
  BipartiteMatching(long long v) { V = v; }
  void init(long long v) {
    V = v;
    for (long long i = 0; i < BIPARTITE_MATCHING_MAX_V; i++) {
      G[i].clear();
    }
  }
  void add_edge(long long u, long long v) {
    G[u].push_back(v);
    G[v].push_back(u);
  }
  bool dfs(long long v) {
    used[v] = true;
    for (long long i = 0; i < (long long)G[v].size(); i++) {
      long long u = G[v][i], w = match[u];
      if (w < 0 || !used[w] && dfs(w)) {
        match[v] = u;
        match[u] = v;
        return true;
      }
    }
    return false;
  }
  long long max_matching() {
    long long res = 0;
    memset(match, -1, sizeof(match));
    for (long long v = 0; v < V; v++) {
      if (match[v] < 0) {
        memset(used, 0, sizeof(used));
        if (dfs(v)) {
          res++;
        }
      }
    }
    return res;
  }
};
class MinCostFlow {
 public:
  struct edge {
    long long to, cap, cost, rev;
  };
  long long V;
  vector<edge> G[MIN_COST_FLOW_MAX_V];
  long long dist[MIN_COST_FLOW_MAX_V];
  long long prevv[MIN_COST_FLOW_MAX_V];
  long long preve[MIN_COST_FLOW_MAX_V];
  long long h[MIN_COST_FLOW_MAX_V];
  MinCostFlow(long long v) { V = v; }
  void init() {
    for (long long i = 0; i < MAX_FLOW_MAX_V; i++) {
      G[i].clear();
    }
  }
  void add_edge(long long from, long long to, long long cap, long long cost) {
    G[from].push_back((edge){to, cap, cost, (long long)G[to].size()});
    G[to].push_back((edge){from, 0, -cost, (long long)G[from].size() - 1});
  }
  void add_undirected_edge(long long e1, long long e2, long long cap,
                           long long cost) {
    add_edge(e1, e2, cap, cost);
    add_edge(e2, e1, cap, cost);
  }
  long long min_cost_flow(long long s, long long t, long long f) {
    long long res = 0;
    while (f > 0) {
      fill(dist, dist + V, INF);
      dist[s] = 0;
      bool update = true;
      while (update) {
        update = false;
        for (long long v = 0; v < V; v++) {
          if (dist[v] == INF) continue;
          for (long long i = 0; i < (long long)G[v].size(); i++) {
            edge &e = G[v][i];
            if (e.cap > 0 && dist[e.to] > dist[v] + e.cost) {
              dist[e.to] = dist[v] + e.cost;
              prevv[e.to] = v;
              preve[e.to] = i;
              update = true;
            }
          }
        }
      }
      if (dist[t] == INF) {
        return -1;
      }
      long long d = f;
      for (long long v = t; v != s; v = prevv[v]) {
        d = min(d, G[prevv[v]][preve[v]].cap);
      }
      f -= d;
      res += d * dist[t];
      for (long long v = t; v != s; v = prevv[v]) {
        edge &e = G[prevv[v]][preve[v]];
        e.cap -= d;
        G[v][e.rev].cap += d;
      }
    }
    return res;
  }
  long long min_cost_flow_dijkstra(long long s, long long t, long long f) {
    long long res = 0;
    fill(h, h + V, 0);
    while (f > 0) {
      priority_queue<pair<long long, long long>,
                     vector<pair<long long, long long> >,
                     greater<pair<long long, long long> > >
          que;
      fill(dist, dist + V, 0);
      dist[s] = 0;
      que.push(pair<long long, long long>(0, s));
      while (!que.empty()) {
        pair<long long, long long> p = que.top();
        que.pop();
        int v = p.second;
        if (dist[v] < p.first) continue;
        for (int i = 0; i < G[v].size(); i++) {
          edge &e = G[v][i];
          if (e.cap > 0 && dist[e.to] > dist[v] + e.cost + h[v] - h[e.to]) {
            dist[e.to] = dist[v] + e.cost + h[v] - h[e.to];
            prevv[e.to] = v;
            preve[e.to] = i;
            que.push(pair<long long, long long>(dist[e.to], e.to));
          }
        }
      }
      if (dist[t] == INF) {
        return -1;
      }
      for (int v = 0; v < V; v++) h[v] += dist[v];
      int d = f;
      for (int v = t; v != s; v = prevv[v]) {
        d = tmin<long long>(d, G[prevv[v]][preve[v]].cap);
      }
      f -= d;
      res += d * h[t];
      for (int v = t; v != s; v = prevv[v]) {
        edge &e = G[prevv[v]][preve[v]];
        e.cap -= d;
        G[v][e.rev].cap += d;
      }
      return res;
    }
    return 0;
  }
};
long long lis(long long *a, long long n, long long *dp) {
  fill(dp, dp + n, INF);
  for (long long i = 0; i < n; i++) *lower_bound(dp, dp + n, a[i]) = a[i];
  return (long long)(lower_bound(dp, dp + n, INF) - dp);
}
bool isEqual(double a, double b) { return abs(a - b) < EPS; }
bool isCEqual(complex<double> a, complex<double> b) {
  return isEqual(a.real(), a.imag()) && isEqual(a.imag(), a.imag());
}
bool isZero(double a) { return abs(a) < EPS; }
bool isUZero(double a) { return a > EPS; }
bool isUEZero(double a) { return a > -EPS; }
bool isLZero(double a) { return a < -EPS; }
bool isLEZero(double a) { return a < EPS; }
complex<double> getUnitVector(complex<double> a) {
  double len = abs(a);
  return isZero(len) ? complex<double>(0.0, 0.0) : a / len;
}
double dot(complex<double> a, complex<double> b) {
  return a.real() * b.real() + a.imag() * b.imag();
}
double det(complex<double> a, complex<double> b) {
  return a.real() * b.imag() - a.imag() * b.real();
}
bool isLineOrthogonal(complex<double> a1, complex<double> a2,
                      complex<double> b1, complex<double> b2) {
  return isZero(dot(a1 - a2, b1 - b2));
}
bool isLineParallel(complex<double> a1, complex<double> a2, complex<double> b1,
                    complex<double> b2) {
  return isZero(det(a1 - a2, b1 - b2));
}
bool isPointOnLine(complex<double> a, complex<double> b, complex<double> c) {
  return isZero(det(b - a, c - a));
}
bool isPointOnLineSegment(complex<double> a, complex<double> b,
                          complex<double> c) {
  return isZero(abs(a - c) + abs(c - b) - abs(a - b));
}
double distanceLineAndPoint(complex<double> a, complex<double> b,
                            complex<double> c) {
  return abs(det(b - a, c - a)) / abs(b - a);
}
double distanceLineSegmentAndPoint(complex<double> a, complex<double> b,
                                   complex<double> c) {
  if (isLEZero(dot(b - a, c - a))) return abs(c - a);
  if (isLEZero(dot(a - b, c - b))) return abs(c - b);
  return abs(det(b - a, c - a)) / abs(b - a);
}
bool isIntersectedLine(complex<double> a1, complex<double> a2,
                       complex<double> b1, complex<double> b2) {
  return !isLineParallel(a1, a2, b1, b2);
}
complex<double> intersectionLine(complex<double> a1, complex<double> a2,
                                 complex<double> b1, complex<double> b2) {
  complex<double> a = a2 - a1, b = b2 - b1;
  return a1 + a * det(b, b1 - a1) / det(b, a);
}
long long n, q;
char s[200001], t[200000], d[200000];
int main() {
  scanf("%lld%lld", &n, &q);
  scanf("%s", s);
  for (long long i = 0; i < q; i++) {
    char temp1[10], temp2[10];
    scanf("%s%s", temp1, temp2);
    t[i] = temp1[0];
    d[i] = temp2[0];
  }
  long long lb = -1, ub = n - 1;
  while (lb + 1 < ub) {
    long long mid = (lb + ub) / 2;
    long long now = mid;
    bool ok = true;
    for (long long i = 0; i < q; i++)
      if (s[now] == t[i]) {
        if (d[i] == 'L')
          now--;
        else
          now++;
        if (now < 0) {
          ok = false;
          break;
        }
        if (now == n) break;
      }
    if (ok)
      ub = mid;
    else
      lb = mid;
  }
  long long left = ub;
  lb = 0, ub = n;
  while (lb + 1 < ub) {
    long long mid = (lb + ub) / 2;
    long long now = mid;
    bool ok = true;
    for (long long i = 0; i < q; i++)
      if (s[now] == t[i]) {
        if (d[i] == 'L')
          now--;
        else
          now++;
        if (now == n) {
          ok = false;
          break;
        }
        if (now == -1) break;
      }
    if (ok)
      lb = mid;
    else
      ub = mid;
  }
  long long right = lb;
  printf("%lld\n", right - left + 1);
}
