#include <bits/stdc++.h>

using namespace std;

typedef long long int64;
const int INF = 1 << 30;

struct SparseTable
{
  int sz;
  vector< int > small[20], lookup;

  SparseTable(vector< int > &xs) : sz(xs.size())
  {
    lookup.resize(xs.size() + 1);
    lookup[0] = lookup[1] = 0;
    for(int i = 2; i <= xs.size(); i++) lookup[i] = lookup[i >> 1] + 1;
    small[0] = xs;
    for(int i = 1; i < 20; ++i) {
      small[i].resize(xs.size());
      for(int j = 0; j < xs.size(); ++j) {
        small[i][j] = min(small[i - 1][j], small[i - 1][min((int) xs.size() - 1, j + (1 << (i - 1)))]);
      }
    }
  }

  int query(int l, int r)
  {
    const int d = lookup[r - l];
    return min(small[d][l], small[d][r - (1 << d)]);
  }
};


int N, M;
int64 x, d;
string S[800000];
int latte[3000000], malta[3000000];

int main()
{
  cin >> N;

  int all = 0;
  for(int i = 0; i < N; i++) {
    cin >> S[i];
    all += S[i].size();
  }

  cin >> M >> x >> d;
  for(int k = 0; k < M; k++) {
    latte[k] = (x / (N - 1)) + 1;
    malta[k] = (x % (N - 1)) + 1;
    if(latte[k] > malta[k]) swap(latte[k], malta[k]);
    else malta[k] = malta[k] + 1;
    x = (x + d) % (1LL * N * (N - 1));
  }


  vector< int > order(N), rev(N);
  iota(begin(order), end(order), 0);
  sort(begin(order), end(order), [&](int a, int b)
  {
    return (S[a] < S[b]);
  });
  for(int i = 0; i < N; i++) rev[order[i]] = i;


  vector< int > qs(N);
  for(int i = 1; i < N; i++) {
    int tail = 0, sz = min(S[order[i - 1]].size(), S[order[i]].size());
    while(tail < sz && S[order[i - 1]][tail] == S[order[i]][tail]) ++tail;
    qs[i - 1] = tail;
  }
  SparseTable rmq(qs);
  int64 ret = 0;
  for(int i = 0; i < M; i++) {
    auto get = minmax(rev[--latte[i]], rev[--malta[i]]);
    ret += rmq.query(get.first, get.second);
  }
  cout << ret << endl;
}