using type = int;

class iterator {

friend class range;

public:

using difference_type = range::type;

using value_type = range::type;

using pointer = const range::type *;

using reference = const range::type &;

using iterator_category = std::random_access_iterator_tag;

value_type operator*() const { return i_; }

const iterator &operator++() {

++i_;

return *this;

}

iterator operator++(int) {

iterator copy(*this);

++i_;

return copy;

}

const iterator &operator--() {

--i_;

return *this;

}

iterator operator--(int) {

iterator copy(*this);

--i_;

return copy;

}

difference_type operator-(const iterator &other) const { return i_ - other.i_; }

iterator operator+(const difference_type &delta) const { return iterator(i_ + delta); }

iterator &operator+=(const difference_type &delta) {

i_ += delta;

return *this;

}

iterator operator-(const difference_type &delta) const { return iterator(i_ - delta); }

iterator &operator-=(const difference_type &delta) {

i_ -= delta;

return *this;

}

bool operator==(const iterator &other) const { return i_ == other.i_; }

bool operator!=(const iterator &other) const { return i_ != other.i_; }

protected:

iterator(const value_type &start) : i_(start) {}

private:

value_type i_;

};

iterator begin() const { return begin_; }

iterator end() const { return end_; }

range(const type &begin, const type &end) : begin_(begin), end_(end) {}

range(const type &end) : begin_(0), end_(end) {}

iterator begin_;

iterator end_;

int *str;

int *sa;

int *ra;

int *lcp;

int *lgt;

int **rmq;

int n;

SuffixArray() : str(0), sa(0), ra(0), lcp(0), lgt(0), rmq(0), n(0) {}

int get(int pos) const {

assert(pos < n);

return str[pos];

}

void init(const vector<int> &s) {

n = (int)s.size();

str = new int[n];

for (int i = 0; i < n; ++i) str[i] = s[i];

__init();

}

void init(const string &s) {

n = (int)s.length();

str = new int[n];

for (int i = 0; i < n; ++i) str[i] = s[i];

__init();

}

void __init() {

initSa();

initLcp();

}

void initSa() {

sa = new int[n];

ra = new int[n];

int *s = new int[n];

int *c = new int[n];

int *cl = new int[n];

int *cnt = new int[n];

for (int i = 0; i < n; ++i) {

cl[i] = str[i];

sa[i] = n - i - 1;

}

stable_sort(sa, sa + n, [&](int l, int r){ return str[l] < str[r]; });

for (int len = 1; len < n; len <<= 1) {

memcpy(c, cl, n * sizeof(int));

memcpy(s, sa, n * sizeof(int));

for (int i = 0; i < n; ++i) cnt[i] = i;

int len2 = len >> 1;

for (int i = 0; i < n; ++i) {

//classes[sa[i]] = i > 0 && c[sa[i - 1]] == c[sa[i]] && sa[i - 1] + len < n && c[sa[i - 1] + len / 2] == c[sa[i] + len / 2] ? classes[sa[i - 1]] : i;

if (i > 0 && c[sa[i]] == c[sa[i - 1]] && sa[i - 1] + len < n && c[sa[i] + len2] == c[sa[i - 1] + len2]) {

cl[sa[i]] = cl[sa[i - 1]];

} else {

cl[sa[i]] = i;

}

}

for (int i = 0; i < n; ++i) {

int s1 = s[i] - len;

if (s1 >= 0) {

sa[cnt[cl[s1]]++] = s1;

}

}

}

for (int i = 0; i < n; ++i) {

ra[sa[i]] = i;

}

delete [] s;delete [] c;delete [] cl;delete [] cnt;

}

void initLcp() {

lcp = new int[n];

for (int i = 0, h = 0; i < n; ++i) {

if (ra[i] < n - 1) {

for (int j = sa[ra[i] + 1]; max(i, j) + h < n && str[i + h] == str[j + h]; ++h);

lcp[ra[i]] = h;

h = max(0, h - 1);

} else {

lcp[ra[i]] = 0;

}

}

lgt = new int[n + 1];

lgt[0] = lgt[1] = 0;

for (int i = 2; i <= n; ++i) lgt[i] = lgt[i >> 1] + 1;

rmq = new int*[lgt[n] + 1];

for (int i = 0; i <= lgt[n]; ++i) {

rmq[i] = new int[n];

}

for (int i = 0; i + 1 < n; ++i) {

rmq[0][i] = lcp[i];

}

for (int l = 1; (1 << l) < n; ++l) {

for (int i = 0; i + (1 << l) <= n; ++i) {

rmq[l][i] = min(rmq[l - 1][i], rmq[l - 1][i + (1 << (l - 1))]);

}

}

}

int getLcpForSuffixes(int l, int r) {

if (l == r) return n - l;

l = ra[l]; r = ra[r];

if (l > r) swap(l, r);

--r;

int j = lgt[r - l];

return min(rmq[j][l], rmq[j][r - (1 << j) + 1]);

}

~SuffixArray() {

if (str) delete [] str;

if (sa) delete [] sa;

if (ra) delete [] ra;

if (lgt) {

for (int i = 0; i <= lgt[n]; ++i) {

delete [] rmq[i];

}

delete [] lgt;

delete [] rmq;

}

}

int s;

int len;

int lcp(const Substring &r) const {

return min(len, min(r.len, sa.getLcpForSuffixes(s, r.s)));

}

int get(int pos) const {

if (pos >= len) {

return -1;

} else {

return sa.get(s + pos);

}

}

bool operator<(const Substring &r) const {

int lc = lcp(r);

return get(lc) < r.get(lc);

}

bool operator==(const Substring &r) const {

int lc = lcp(r);

return lc == len && lc == r.len;

}

vector <Node *> children;

Node *p;

int len;

int cnt;

Node() {

p = nullptr;

len = 0;

cnt = 0;

}

ll res = root->cnt;

if (root->children.empty()) {

res += 1;

} else {

ll q = 1;

for (auto c : root->children) {

q = q * solve(c, M) % M;

}

res += q;

res %= M;

}

return res;

sort(all(x));

auto root = new Node();

vector <Node *> st;

st.pb(root);

Substring last = Substring{0, 0};

for (auto s : x) {

int lcp = s.lcp(last);

Node *lastP = nullptr;

while (st.back()->len > lcp) {

lastP = st.back();

st.pop_back();

assert(!st.empty());

}

if (st.back()->len < lcp) {

auto to_add = new Node();

to_add->len = lcp;

to_add->p = st.back();

if (lastP) {

st.back()->children.pop_back();

to_add->children.push_back(lastP);

}

st.back()->children.push_back(to_add);

st.push_back(to_add);

}

if (st.back()->len < s.len) {

auto to_add = new Node();

to_add->len = s.len;

to_add->p = st.back();

st.back()->children.push_back(to_add);

st.push_back(to_add);

}

st.back()->cnt++;

last = s;

}

return solve(root, M);

int n = nxt();

int q = nxt();

string s;

cin >> s;

sa.init(s);

while (q--) {

int k = nxt();

vector <Substring> x;

ll M = nxt();

while (k--) {

int s = nxt() - 1;

int len = nxt() - s;

auto ss = Substring{s, len};

x.push_back(ss);

}

cout << solve(x, M) << "\n";

}

#ifdef LOCAL

freopen("input.txt", "r", stdin);

#else

#define fname "sequence"

//freopen(fname".in", "r", stdin);

//freopen(fname".out", "w", stdout);

#endif

pre();

::TTT = 1;

#ifdef LOCAL

#else

#endif

for (int test = 1; test <= ::TTT; ++test) {

solve(test);

}

#ifdef LOCAL

cerr << "Time elapsed: " << 1.0 * clock() / CLOCKS_PER_SEC * 1000 << " ms." << endl;

#endif

return 0;

while (y > 0) {

x %= y;

swap(x, y);

}

return x;

ostringstream os("");

os << a;

return os.str();

static int ed;

a = 0;

while (!isdigit(ed = getchar()) && ed != '-') {}

char neg = 0;

if (ed == '-') {

neg = 1;

ed = getchar();

}

while (isdigit(ed)) {

a = 10 * a + ed - '0';

ed = getchar();

}

if (neg) a = -a;

T res;

input(res);

return res;

assert(v);

if (v < 2) return false;

for (long long i = 2; i * i <= v; ++i) {

if (v % i == 0) {

return false;

}

}

return true;

T res = 1;

while (n) {

if (n & 1) {

res = res * a % m;

}

a = a * a % m;

n >>= 1;

}

return res;

T res = 1;

while (a > 1) {

res = res * (p - p / a) % p;

a = p % a;

}

return res;

if (b < a) {

a = b;

return true;

}

return false;

if (b > a) {

a = b;

return true;

}

return false;