Problem: Please pay attention to the unusual memory limit in this problem.

In a parallel universe, Satan is called "Trygub". For that reason, the letters of his namesake were deleted from the alphabet in ancient times.

The government has n workers standing in a row and numbered with integers from 1 to n from left to right. Their job categories can be represented as a string s of length n, where the character s_i represents the job category of the i-th worker.

A new law will be approved to increase the equality between the workers. The government decided to make everyone have the same job category by performing the following operation any number of times (possibly zero).

There is a fixed rational parameter k=\frac ab describing how easy it is to convince the public, and it will be used to determine the success of an operation.

In an operation, the government first selects a job category x with at least one worker at the current moment. Suppose i_1,…, i_m (i_1<…<i_m) are the positions of all the workers with job category x. If k⋅ (i_m-i_1+1)≤ m, the government is able to choose any job category y with at least one worker at the current moment and change the job category of all workers with job category x to job category y.

If it is possible to make all workers have job category x, we say that x is obtainable. Can you tell the government the set of obtainable job categories?

Input

The first line contains three integers n, a, b (1 ≤ n ≤ 5000, 1≤ a≤ b≤ 10^5) — the number of workers and the numerator and denominator of the parameter k, respectively.

The second line contains a string s of length n, consisting of lowercase English characters — the job categories of each worker. The characters 't', 'r', 'y', 'g', 'u', and 'b' do not appear in the string s.

Output

Print an integer c equal to the number of obtainable job categories followed by c space-separated characters — the obtainable job categories sorted in the lexicographical order.

Example

Input


7 1 2
comicom


Output


3 c m o

Note

The first operation must select the job category 'i' because all other job categories cannot satisfy the condition, therefore 'i' is not obtainable.

Below is showed how to obtain 'c', 'm', and 'o'. The square brackets denote the segment containing all workers of the selected category, the red color denotes this category and the blue color denotes the new category after the change.

  * Get 'c': 
    1. (com\color{red}{[i]}com → com\color{#1E90FF}{[o]}com) 
    2. (c\color{red}{[o}m\color{red}{o}c\color{red}{o]}m → c\color{#1E90FF}{[m}m\color{#1E90FF}{m}c\color{#1E90FF}{m]}m) 
    3. (c\color{red}{[mmm}c\color{red}{mm]} → c\color{#1E90FF}{[ccc}c\color{#1E90FF}{cc]}) 
  * Get 'm': 
    1. (com\color{red}{[i]}com → com\color{#1E90FF}{[o]}com) 
    2. (c\color{red}{[o}m\color{red}{o}c\color{red}{o]}m → c\color{#1E90FF}{[c}m\color{#1E90FF}{c}c\color{#1E90FF}{c]}m) 
    3. (\color{red}{[cc}m\color{red}{ccc]}m → \color{#1E90FF}{[mm}m\color{#1E90FF}{mmm]}m) 
  * Get 'o': 
    1. (com\color{red}{[i]}com → com\color{#1E90FF}{[c]}com) 
    2. (\color{red}{[c}om\color{red}{cc]}om → \color{#1E90FF}{[m}om\color{#1E90FF}{mm]}om) 
    3. (\color{red}{[m}o\color{red}{mmm}o\color{red}{m]} → \color{#1E90FF}{[o}o\color{#1E90FF}{ooo}o\color{#1E90FF}{o]}) 

Solution (in CPP):

Solution:
#include <bits/stdc++.h>

using namespace std;

template <typename A, typename B>
string to_string(pair<A, B> p);

template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p);

template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p);

string to_string(const string& s) {
  return '"' + s + '"';
}

string to_string(const char* s) {
  return to_string((string) s);
}

string to_string(bool b) {
  return (b ? "true" : "false");
}

string to_string(vector<bool> v) {
  bool first = true;
  string res = "{";
  for (int i = 0; i < static_cast<int>(v.size()); i++) {
    if (!first) {
      res += ", ";
    }
    first = false;
    res += to_string(v[i]);
  }
  res += "}";
  return res;
}

template <size_t N>
string to_string(bitset<N> v) {
  string res = "";
  for (size_t i = 0; i < N; i++) {
    res += static_cast<char>('0' + v[i]);
  }
  return res;
}

template <typename A>
string to_string(A v) {
  bool first = true;
  string res = "{";
  for (const auto &x : v) {
    if (!first) {
      res += ", ";
    }
    first = false;
    res += to_string(x);
  }
  res += "}";
  return res;
}

template <typename A, typename B>
string to_string(pair<A, B> p) {
  return "(" + to_string(p.first) + ", " + to_string(p.second) + ")";
}

template <typename A, typename B, typename C>
string to_string(tuple<A, B, C> p) {
  return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ")";
}

template <typename A, typename B, typename C, typename D>
string to_string(tuple<A, B, C, D> p) {
  return "(" + to_string(get<0>(p)) + ", " + to_string(get<1>(p)) + ", " + to_string(get<2>(p)) + ", " + to_string(get<3>(p)) + ")";
}

void debug_out() { cerr << endl; }

template <typename Head, typename... Tail>
void debug_out(Head H, Tail... T) {
  cerr << " " << to_string(H);
  debug_out(T...);
}

#define debug(...) cerr << "[" << #__VA_ARGS__ << "]:", debug_out(__VA_ARGS__);

int n, a, b;
string s;

int main() {
  cin >> n >> a >> b >> s;
  map<char, int> mp;
  int cnt = 0;
  vector<char> p;
  for(auto i : s) {
    mp[i] = 0;
  }
  for(auto &it : mp) {
    it.second = cnt++;
    p.push_back(it.first);
  }
  vector<int> L(cnt);
  vector<int> R(cnt);
  vector<int> F(cnt);
  for(int i = 0; i < n; i++) {
    int id = mp[s[i]];
    if(F[id] == 0) L[id] = i;
    F[id]++;
    R[id] = i;
  }
  vector<int> sL(1 << cnt, n);
  vector<int> sR(1 << cnt, -1);
  vector<int> sF(1 << cnt);
  for(int mask = 1; mask < (1 << cnt); mask++) {
    for(int i = 0; i < cnt; i++) {
      if((mask >> i) & 1) {
        sL[mask] = min(sL[mask], L[i]);
        sR[mask] = max(sR[mask], R[i]);
        sF[mask] += F[i];
      }
    }
  }
  vector<int> reachable(1 << cnt);
  for(int i = 0; i < cnt; i++) reachable[1 << i] = true;
  auto changeable = [&](int mask) {
    return (bool) ((1LL * (sR[mask] - sL[mask] + 1) * a) <= (1LL * sF[mask] * b));
  };
  auto pull = [&](int mask, int sub) {
    int rev = mask ^ sub;
    if(!reachable[rev] || !reachable[sub]) return false;
    return changeable(sub) || changeable(rev);
  };
  for(int mask = 1; mask < (1 << cnt); mask++) {
    if(reachable[mask]) continue;
    vector<int> pos;
    for(int i = 0; i < cnt; i++) if((mask >> i) & 1) pos.push_back(i);
    sort(pos.begin(), pos.end(), [&](int i, int j){return L[i] < L[j];});
    for(int i = 0; i < cnt; i++) if((mask >> i) & 1) reachable[mask] |= pull(mask, 1 << i);
    int sub = 0;
    for(int i = 0; i < (int) pos.size() - 1; i++) {
      sub ^= 1 << pos[i];
      reachable[mask] |= pull(mask, sub);
    }
  }
  if(!reachable.back()) {
    cout << 0;
    return 0;
  }
  vector<char> ret;
  for(int v = 0; v < cnt; v++) {
    vector<int> pos;
    for(int i = 0; i < cnt; i++) {
      if(i == v) continue;
      pos.push_back(i);
    }
    sort(pos.begin(), pos.end(), [&](int i, int j){return L[i] < L[j];});
    vector<int> dp(cnt);
    dp[0] = true;
    for(int i = 1; i < cnt; i++) {
      for(int j = i - 1; j >= 0; j--) {
        int mask = 0;
        for(int id = j; id < i; id++) mask ^= 1 << pos[id];
        if(changeable(mask) && reachable[mask]) dp[i] |= dp[j];
      }
    }
    if(dp[cnt - 1]) ret.push_back(p[v]);
  }
  cout << ret.size() << " ";
  for(auto i : ret) cout << i << " ";
  return 0;
}