#include <bits/stdc++.h>
using namespace std;
#define rep(i,n) for (int i = 0; i < (int)(n); i++)
typedef long long ll;
typedef pair <int, int> PII;

class StringsNightmareAgain {
public:
	long long UniqueSubstrings(int, int, int, int, int);
};

const int N = 250005;
const int INF = 1000000000;
struct Node {
    Node *ch[2], *fa;
    int val, minLength, maxLength;
	bool isEnd;
    Node():
        val(0), fa(NULL) {
		minLength = INF;
		maxLength = -INF;
		isEnd = 0;
        memset(ch, 0, sizeof(ch));
    }
}pool[N * 2 + 5], *last, *root;
vector <Node *> vec[N];

namespace SAM {
    int cnt;

    void init() {
        if (cnt)
            for (int i = 0; i < cnt; i++)
                pool[i] = Node();
        cnt = 1;
        root = &pool[0];
        last = root;
    }

    void add(int c) {
        Node *p = last, *np = &pool[cnt++];
        last = np;
        np->val = p->val + 1;
        for  (; p && !p->ch[c]; p = p->fa)
            p->ch[c] = np;
        if (!p) {
            np->fa = root;
        } else {
            Node *q = p->ch[c];
            if (p->val + 1 == q->val) {
                 np->fa = q;
            } else {
                Node *nq = &pool[cnt++];
                *nq = *q;
                nq->val = p->val + 1;
                q->fa = nq;
                np->fa = nq;
                for (; p && p->ch[c] == q; p = p->fa)
                    p->ch[c] = nq;
            }
        }
    }

	ll gao() {
		static vector <int> E[N];
		rep (i, cnt) E[i].clear();
		rep (i, cnt) E[pool[i].val].push_back(i);
		for (Node *p = last; p != root; p = p->fa) p->isEnd = 1;
		ll ans = 0;
		for (int depth = cnt - 1; depth >= 1; depth--) {
			for (int &i : E[depth]) {
				Node *p = pool + i;
				if (p == last) {
					p->minLength = p->maxLength = 0;
				} else {
					rep (o, 2) {
						if (p->ch[o]) {
							p->minLength = min(p->minLength, p->ch[o]->minLength + 1);
							p->maxLength = max(p->maxLength, p->ch[o]->maxLength + 1);
						}
					}
					if (p->isEnd) p->minLength = 0;
					ans += max(0, min(p->val, p->maxLength - p->minLength) - p->fa->val);
				}
			}
		}
		return ans;
	}
}


string gen(int a, int b, int c, int d, int n) {
	string S = string(n, 'a');
	for (int i = 0; i < a; ++i) {
		b = (b*(ll)c+d)%n;
		S[b] = 'b';
	}
	return S;
}
long long StringsNightmareAgain::UniqueSubstrings(int a, int b, int c, int d, int n) {
	string s = gen(a, b, c, d, n);
	SAM::init();
	rep (i, n) {
		SAM::add(s[i] - 'a');
	}
	return SAM::gao();
}