#include <vector>
#include <list>
#include <map>
#include <set>
#include <deque>
#include <queue>
#include <stack>
#include <bitset>
#include <algorithm>
#include <functional>
#include <numeric>
#include <utility>
#include <sstream>
#include <iostream>
#include <iomanip>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <cctype>
#include <string>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <cstdlib>
#include <ctime>
#include <string.h>
#include <fstream>
#include <cassert>
using namespace std;

#define sz(a) int((a).size())
#define rep(i, s, n)  for(int i = s; i <= (n); ++i)
#define rev(i, n, s)  for(int i = (n); i >= s; --i)
#define fore(x, a) for(auto &&x : a)
typedef long long ll;
const int mod = 1000000007;
const int N = 100005;

int arr[N], k , m, l[N], r[N];
pair<int, int> ab[N], ba[N];

bool all_bad(int s, int e) {
  if (e - s + 1 < m) return 1;
  for (int i = s, j = e; i <= e && j >= s && i <= j; i++, j--) {
    if (l[i]<s && r[i]>e) return all_bad(s, i - 1) && all_bad(i + 1, e);
    if (l[j]<s && r[j]>e) return all_bad(s, j - 1) && all_bad(j + 1, e);
  }
  return 0;
}

bool cmp(pair<int, int> o1, pair<int, int> o2) {
  if (o1.first != o2.first) return o1.first < o2.first;
  return o1.second > o2.second;
}
set<int> c1, c2;

class FindingFriends {
public:
  int shortestDistance( int n, vector <int> init, int a, int b, int c, int d, int m2 ) {
    m = m2;
    int mx = -1, mn = mod;
    rep(i, 0, sz(init) - 1) {
      arr[i] = init[i];
    }
    rep(i, sz(init), n - 1) {
      arr[i] = (arr[i - 1] * 1LL * a + b * 1LL * i + c) % d;
    }
    rep(i, 0, n - 1) {
      mn = min(mn, arr[i]);
      mx = max(mx, arr[i]);
      ab[i] = make_pair(arr[i], i);
      ba[i] = make_pair(arr[i], i);
    }
    sort(ab, ab + n);
    sort(ba, ba + n, cmp);
    int hi = mx - mn, lo = 0;
    while (lo < hi) {
      k = (hi + lo) / 2;
      rep(i, 0, n - 1) {
        l[i] = -1, r[i] = n;
      }
      c1.clear(); c2.clear(); c1.insert(-1); c2.insert(n);
      int j1 = 0, j2 = 0;
      rep(i, 0, n - 1) {
        while (j1 < i && ab[j1].first < ab[i].first - k) {
          c1.erase(ab[j1].second);
          j1++;
        }
        while (j2 < i && ba[j2].first < ba[i].first - k) {
          c2.erase(ba[j2].second);
          j2++;
        }
        auto it = c1.lower_bound(ab[i].second);
        it--;
        l[ab[i].second] = max(l[ab[i].second], *it);
        r[ba[i].second] = min(r[ba[i].second], *(c2.upper_bound(ba[i].second)));
        c1.insert(ab[i].second);
        c2.insert(ba[i].second);
      }
      j1 = n - 1; j2 = n - 1;
      c1.clear(); c2.clear(); c1.insert(-1); c2.insert(n);
      rev(i, n - 1, 0) {
        while (j1 > i && ab[j1].first > ab[i].first + k) {
          c1.erase(ab[j1].second);
          j1--;
        }
        while (j2 > i && ba[j2].first > ba[i].first + k) {
          c2.erase(ba[j2].second);
          j2--;
        }
        auto it = c1.lower_bound(ab[i].second);
        it--;
        l[ab[i].second] = max(l[ab[i].second], *it);
        r[ba[i].second] = min(r[ba[i].second], *(c2.upper_bound(ba[i].second)));
        c1.insert(ab[i].second);
        c2.insert(ba[i].second);
      }
      bool can = (!all_bad(0, n - 1));
      if (can) hi = k;
      else lo = k + 1;
    }
    return lo;
  }
};

// BEGIN CUT HERE
#include <cstdio>
#include <ctime>
#include <iostream>
#include <string>
#include <vector>
namespace moj_harness {
	using std::string;
	using std::vector;
	int run_test_case(int);
	void run_test(int casenum = -1, bool quiet = false) {
		if (casenum != -1) {
			if (run_test_case(casenum) == -1 && !quiet) {
				std::cerr << "Illegal input! Test case " << casenum << " does not exist." << std::endl;
			}
			return;
		}
		
		int correct = 0, total = 0;
		for (int i=0;; ++i) {
			int x = run_test_case(i);
			if (x == -1) {
				if (i >= 100) break;
				continue;
			}
			correct += x;
			++total;
		}
		
		if (total == 0) {
			std::cerr << "No test cases run." << std::endl;
		} else if (correct < total) {
			std::cerr << "Some cases FAILED (passed " << correct << " of " << total << ")." << std::endl;
		} else {
			std::cerr << "All " << total << " tests passed!" << std::endl;
		}
	}
	
	int verify_case(int casenum, const int &expected, const int &received, std::clock_t elapsed) { 
		std::cerr << "Example " << casenum << "... "; 
		
		string verdict;
		vector<string> info;
		char buf[100];
		
		if (elapsed > CLOCKS_PER_SEC / 200) {
			std::sprintf(buf, "time %.2fs", elapsed * (1.0/CLOCKS_PER_SEC));
			info.push_back(buf);
		}
		
		if (expected == received) {
			verdict = "PASSED";
		} else {
			verdict = "FAILED";
		}
		
		std::cerr << verdict;
		if (!info.empty()) {
			std::cerr << " (";
			for (size_t i=0; i<info.size(); ++i) {
				if (i > 0) std::cerr << ", ";
				std::cerr << info[i];
			}
			std::cerr << ")";
		}
		std::cerr << std::endl;
		
		if (verdict == "FAILED") {
			std::cerr << "    Expected: " << expected << std::endl; 
			std::cerr << "    Received: " << received << std::endl; 
		}
		
		return verdict == "PASSED";
	}

	int run_test_case(int casenum__) {
		switch (casenum__) {
		case 0: {
			int len                   = 6;
			int init[]                = {8,1,10,2,9,7};
			int a                     = 12;
			int b                     = 34;
			int c                     = 56;
			int d                     = 78;
			int m                     = 2;
			int expected__            = 1;

			std::clock_t start__      = std::clock();
			int received__            = FindingFriends().shortestDistance(len, vector <int>(init, init + (sizeof init / sizeof init[0])), a, b, c, d, m);
			return verify_case(casenum__, expected__, received__, clock()-start__);
		}
		case 1: {
			int len                   = 7;
			int init[]                = {1};
			int a                     = 1;
			int b                     = 0;
			int c                     = 0;
			int d                     = 12345678;
			int m                     = 5;
			int expected__            = 0;

			std::clock_t start__      = std::clock();
			int received__            = FindingFriends().shortestDistance(len, vector <int>(init, init + (sizeof init / sizeof init[0])), a, b, c, d, m);
			return verify_case(casenum__, expected__, received__, clock()-start__);
		}
		case 2: {
			int len                   = 12;
			int init[]                = {0};
			int a                     = 1;
			int b                     = 0;
			int c                     = 1;
			int d                     = 6;
			int m                     = 3;
			int expected__            = 0;

			std::clock_t start__      = std::clock();
			int received__            = FindingFriends().shortestDistance(len, vector <int>(init, init + (sizeof init / sizeof init[0])), a, b, c, d, m);
			return verify_case(casenum__, expected__, received__, clock()-start__);
		}
		case 3: {
			int len                   = 10;
			int init[]                = {3,4,5};
			int a                     = 23;
			int b                     = 34;
			int c                     = 35;
			int d                     = 46;
			int m                     = 4;
			int expected__            = 4;

			std::clock_t start__      = std::clock();
			int received__            = FindingFriends().shortestDistance(len, vector <int>(init, init + (sizeof init / sizeof init[0])), a, b, c, d, m);
			return verify_case(casenum__, expected__, received__, clock()-start__);
		}
		case 4: {
			int len                   = 2;
			int init[]                = {0,1000000000};
			int a                     = 0;
			int b                     = 0;
			int c                     = 0;
			int d                     = 1;
			int m                     = 2;
			int expected__            = 1000000000;

			std::clock_t start__      = std::clock();
			int received__            = FindingFriends().shortestDistance(len, vector <int>(init, init + (sizeof init / sizeof init[0])), a, b, c, d, m);
			return verify_case(casenum__, expected__, received__, clock()-start__);
		}
		case 5: {
			int len                   = 5;
			int init[]                = {1,2,1000,3,4};
			int a                     = 9;
			int b                     = 8;
			int c                     = 7;
			int d                     = 10;
			int m                     = 3;
			int expected__            = 996;

			std::clock_t start__      = std::clock();
			int received__            = FindingFriends().shortestDistance(len, vector <int>(init, init + (sizeof init / sizeof init[0])), a, b, c, d, m);
			return verify_case(casenum__, expected__, received__, clock()-start__);
		}
		case 6: {
			int len                   = 100000;
			int init[]                = {565990974};
			int a                     = 168649977;
			int b                     = 191924440;
			int c                     = 138092623;
			int d                     = 192724723;
			int m                     = 100000;
			int expected__            = 373269838;

			std::clock_t start__      = std::clock();
			int received__            = FindingFriends().shortestDistance(len, vector <int>(init, init + (sizeof init / sizeof init[0])), a, b, c, d, m);
			return verify_case(casenum__, expected__, received__, clock()-start__);
		}

		// custom cases

/*      case 7: {
			int len                   = ;
			int init[]                = ;
			int a                     = ;
			int b                     = ;
			int c                     = ;
			int d                     = ;
			int m                     = ;
			int expected__            = ;

			std::clock_t start__      = std::clock();
			int received__            = FindingFriends().shortestDistance(len, vector <int>(init, init + (sizeof init / sizeof init[0])), a, b, c, d, m);
			return verify_case(casenum__, expected__, received__, clock()-start__);
		}*/
/*      case 8: {
			int len                   = ;
			int init[]                = ;
			int a                     = ;
			int b                     = ;
			int c                     = ;
			int d                     = ;
			int m                     = ;
			int expected__            = ;

			std::clock_t start__      = std::clock();
			int received__            = FindingFriends().shortestDistance(len, vector <int>(init, init + (sizeof init / sizeof init[0])), a, b, c, d, m);
			return verify_case(casenum__, expected__, received__, clock()-start__);
		}*/
/*      case 9: {
			int len                   = ;
			int init[]                = ;
			int a                     = ;
			int b                     = ;
			int c                     = ;
			int d                     = ;
			int m                     = ;
			int expected__            = ;

			std::clock_t start__      = std::clock();
			int received__            = FindingFriends().shortestDistance(len, vector <int>(init, init + (sizeof init / sizeof init[0])), a, b, c, d, m);
			return verify_case(casenum__, expected__, received__, clock()-start__);
		}*/
/*      case 10: {
			int len                   = ;
			int init[]                = ;
			int a                     = ;
			int b                     = ;
			int c                     = ;
			int d                     = ;
			int m                     = ;
			int expected__            = ;

			std::clock_t start__      = std::clock();
			int received__            = FindingFriends().shortestDistance(len, vector <int>(init, init + (sizeof init / sizeof init[0])), a, b, c, d, m);
			return verify_case(casenum__, expected__, received__, clock()-start__);
		}*/
/*      case 11: {
			int len                   = ;
			int init[]                = ;
			int a                     = ;
			int b                     = ;
			int c                     = ;
			int d                     = ;
			int m                     = ;
			int expected__            = ;

			std::clock_t start__      = std::clock();
			int received__            = FindingFriends().shortestDistance(len, vector <int>(init, init + (sizeof init / sizeof init[0])), a, b, c, d, m);
			return verify_case(casenum__, expected__, received__, clock()-start__);
		}*/
		default:
			return -1;
		}
	}
}


int main() {
#ifdef loc
  if(!freopen((string(FOLDER) + "inp.txt").c_str(), "r", stdin)) {
    assert(0);
  }
  freopen((string(FOLDER) + "out.txt").c_str(), "a", stdout);
  freopen((string(FOLDER) + "out.txt").c_str(), "a", stderr);
#endif
  moj_harness::run_test();
}

// END CUT HERE