/*

 求联通分量。

 */

 #include<bits/stdc++.h>

 using namespace std;

 typedef long long LL;

 inline int read() {

     int x=,f=;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-;

     for (;isdigit(ch);ch=getchar())x=x*+ch-'';return x*f;

 }

 const int N = ;

 int head[N],nxt[],to[];

 int dfn[N],low[N],st[N],bel[N];

 int Enum,TimeIndex,NumberPeople,BlockIndex,top;

 bool vis[N];

 map<string,int> p;

 struct Couple{

     string a,b;

 }c[N];

 inline void add_edge(int u,int v) {

     ++Enum;to[Enum] = v, nxt[Enum] = head[u],head[u] = Enum;

 }

 void tarjan(int u) {

     dfn[u] = low[u] = ++TimeIndex;

     st[++top] = u; // --

     vis[u] = true; // --

     for (int i=head[u]; i; i=nxt[i]) {

         int v = to[i];

         if (!dfn[v]) {

             tarjan(v);

             low[u] = min(low[u],low[v]);

         }

         else if (vis[v]) low[u] = min(low[u],dfn[v]);

     }

     if (dfn[u] == low[u]) {

         ++BlockIndex;

         do {

             bel[st[top]] = BlockIndex;

             vis[st[top]] = false; // --

             top--;

         } while (st[top+] != u);

     }

 }

 int main() {

     int n = read();

     string a,b;

     int tot = ;

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

         cin >> c[i].a >> c[i].b;

         p[c[i].a] = ++NumberPeople;

         p[c[i].b] = ++NumberPeople;

         add_edge(NumberPeople-,NumberPeople);

     }

     int m = read();

     for (int i=; i<=m; ++i) {

         cin >> a >> b;

         add_edge(p[b],p[a]);

     }

     for (int i=; i<=NumberPeople; ++i) { // -- i<=n

         if (!dfn[i]) tarjan(i);

     }

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

         if (bel[p[c[i].a]] == bel[p[c[i].b]]) puts("Unsafe");

         else puts("Safe");

     }

     return ;

 }

 /*

 读好题目。

 所有路径都是 深度小的->深度大的。

 所以，dfs一遍。

 */

 #include<bits/stdc++.h>

 using namespace std;

 typedef long long LL;

 inline int read() {

     int x=,f=;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-;

     for (;isdigit(ch);ch=getchar())x=x*+ch-'';return x*f;

 }

 const int N = ;

 int head[N],nxt[N<<],to[N<<],Enum;

 int w[N],S,Ans;

 map<int,int> cnt;

 inline void add_edge(int u,int v) {

     ++Enum;to[Enum] = v, nxt[Enum] = head[u],head[u] = Enum;

 }

 void dfs(int u,int fa,int sum) {

     if (cnt[sum - S]) Ans += cnt[sum - S];

     for (int i=head[u]; i; i=nxt[i]) {

         int v = to[i];

         if (v == fa) continue;

         cnt[sum+w[v]] ++;

         dfs(v,u,sum+w[v]);

         cnt[sum+w[v]] --;

     }

 }

 int main() {

     int n = read();S = read();

     for (int i=; i<=n; ++i) w[i] = read();

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

         int u = read(),v = read();

         add_edge(u,v);add_edge(v,u);

     }

     cnt[] = ;cnt[w[]] = ;

     dfs(,,w[]);

     cout << Ans;

     return ;

 }

 #include<bits/stdc++.h>

 using namespace std;

 typedef long long LL;

 inline int read() {

     int x=,f=;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-;

     for (;isdigit(ch);ch=getchar())x=x*+ch-'';return x*f;

 }

 const int N = ;

 struct Edge{

     int u,v;double w;

     Edge() {}

     Edge(int a,int b,double c) {u = a, v = b, w = c;} // double c

     bool operator < (const Edge &A) const {

         return w < A.w;

     }

 }e[N*N];

 int x[N],y[N],fa[N],a[N],Enum;

 int find(int x) {

     if (x == fa[x]) return x;

     return fa[x] = find(fa[x]);

 }

 int main() {

     int n = read();

     for (int i=; i<=n; ++i) a[i] = read();

     sort(a+,a+n+);

     int m = read();

     for (int i=; i<=m; ++i)

         x[i] = read(),y[i] = read();

     for (int i=; i<=m; ++i)

         for (int j=i+; j<=m; ++j) {

             double w = sqrt(1.0*(x[i]-x[j])*(x[i]-x[j])+1.0*(y[i]-y[j])*(y[i]-y[j]));

             e[++Enum] = Edge(i,j,w);

         }

     sort(e+,e+Enum+);

     for (int i=; i<=m; ++i) fa[i] = i; //-- i<=m

     int cnt = ;double mx;

     for (int i=; i<=Enum; ++i) {

         int u = find(e[i].u), v = find(e[i].v);

         if (u != v) {

             fa[u] = v;

             cnt ++;

             mx = e[i].w;

             if (cnt == m - ) break; // -- cnt=n-1

         }

     }

     int Ans = ;

     for (int i=n; i>=; --i) if (a[i] >= mx) Ans ++; //--居然反了。。

     cout << Ans;

     return ;

 }

 #include<bits/stdc++.h>

 using namespace std;

 typedef long long LL;

 inline int read() {

     int x=,f=;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-;

     for (;isdigit(ch);ch=getchar())x=x*+ch-'';return x*f;

 }

 const int N = ;

 struct SuffixAutomaton{

     int Last, Index, res, cur, fa[N], trans[N][], len[N];

     SuffixAutomaton() {Last = Index = cur = ; res = ;}

     void extend(int c) {

         int P = Last, NP = ++Index;

         len[NP] = len[P] + ;

         for (; P&&!trans[P][c]; P=fa[P]) trans[P][c] = NP;

         if (!P) fa[NP] = ;

         else {

             int Q = trans[P][c];

             if (len[P] +  == len[Q]) fa[NP] = Q;

             else {

                 int NQ = ++Index;

                 fa[NQ] = fa[Q];

                 len[NQ] = len[P] + ;

                 memcpy(trans[NQ], trans[Q], sizeof trans[Q]);

                 fa[Q] = NQ;

                 fa[NP] = NQ;

                 for (; P&&trans[P][c]==Q; P=fa[P]) trans[P][c] = NQ;

             }

         }

         Last = NP;

     }

     int solve(int c) {

         if (trans[cur][c]) {cur = trans[cur][c]; res++; return res;}

         for (; cur&&!trans[cur][c]; cur=fa[cur]);

         if (!cur) res = , cur = ;

         else res = len[cur] + , cur = trans[cur][c];

         return res;

     }

 }sam[];

 char s[N];

 char str[N];

 int main() {

     int n = ,t = ,len;

     scanf("%s",str+);

     while (scanf("%s",s+)!=EOF) {

         len = strlen(s + );

         for (int i=; i<=len; ++i)

             sam[t].extend(s[i] - 'a');

         t ++;

     }

     int ans = ;

     len = strlen(str+);

     for (int i=; i<=len; ++i) {

         int tmp = 1e9;

         for (int j=; j<t; ++j)

             tmp = min(tmp, sam[j].solve(str[i] - 'a'));

         ans = max(ans, tmp);

     }

     printf("%d",ans);

     return ;

 }

 /*

 二分，每个数对应一个区间，每次取区间的最小值。

 */

 #include<bits/stdc++.h>

 using namespace std;

 typedef long long LL;

 inline int read() {

     int x=,f=;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-;

     for (;isdigit(ch);ch=getchar())x=x*+ch-'';return x*f;

 }

 const int N = ;

 LL A[N], Sa, Sb, Sc, Sd, mod;

 int n;

 LL F(LL x) {

     LL x2 = x * x % mod, x3 = x2 * x % mod; //---

     return (Sa * x3 % mod + Sb * x2 % mod + Sc * x % mod + Sd) % mod;

 }

 void init() {

     Sa = read(), Sb = read(), Sc = read(), Sd = read(); A[] = read(); mod = read();

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

         A[i] = (F(A[i-]) + F(A[i-])) % mod;

 }

 bool check(LL x) {

     LL last = A[] - x;

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

         if (A[i] >= last) {

             last = max(A[i] - x, last);

         }

         else {

             if (A[i] + x < last) return false; //---

             last = min(A[i] + x, last);

         }

     }

     return true;

 }

 int main() {

     n = read();

     init();

     LL L = , R = mod, ans; //---

     while (L <= R) {

         LL mid = (L + R) >> ;

         if (check(mid)) ans = mid, R = mid - ;

         else L = mid + ;

     }

     cout << ans;

     return ;

 }

 /*

 找出最大的逆序对，然后答案是(mx-mn+1)/2

 如果将最大的逆序对可以提升的一个平台，那么其他的逆序对也都可在这一平台。

 下面摘自https://blog.csdn.net/vmurder/article/details/44096565

 我们把所有逆序对点都搞到同一高度。

 然后发现答案是距离最远的逆序对搞到一起的代价。

 */

 #include<bits/stdc++.h>

 using namespace std;

 typedef long long LL;

 inline int read() {

     int x=,f=;char ch=getchar();for(;!isdigit(ch);ch=getchar())if(ch=='-')f=-;

     for (;isdigit(ch);ch=getchar())x=x*+ch-'';return x*f;

 }

 const int N = ;

 LL A[N], Sa, Sb, Sc, Sd, mod;

 int n;

 LL F(LL x) {

     LL x2 = x * x % mod, x3 = x2 * x % mod;

     return (Sa * x3 % mod + Sb * x2 % mod + Sc * x % mod + Sd) % mod;

 }

 void init() {

     Sa = read(), Sb = read(), Sc = read(), Sd = read(); A[] = read(); mod = read();

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

         A[i] = (F(A[i-]) + F(A[i-])) % mod;

 }

 int main() {

     n = read();

     init();

     LL Mx = -1e9, ans = ;

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

         if (A[i] >= Mx) Mx = A[i];

         else ans = max(ans, (Mx - A[i] + ) / );

     }   

     cout << ans;

     return ;

 }