#include <algorithm>
#include <array>
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstring>
#include <functional>
#include <iomanip>
#include <iostream>
#include <map>
#include <numeric>
#include <queue>
#include <random>
#include <set>
#include <vector>
using namespace std;

template<typename A, typename B> ostream& operator<<(ostream &os, const pair<A, B> &p) { return os << '(' << p.first << ", " << p.second << ')'; }
template<typename T_container, typename T = typename enable_if<!is_same<T_container, string>::value, typename T_container::value_type>::type> ostream& operator<<(ostream &os, const T_container &v) { os << '{'; string sep; for (const T &x : v) os << sep << x, sep = ", "; return os << '}'; }

void dbg_out() { cerr << endl; }
template<typename Head, typename... Tail> void dbg_out(Head H, Tail... T) { cerr << ' ' << H; dbg_out(T...); }

#ifdef NEAL_DEBUG
#define dbg(...) cerr << "(" << #__VA_ARGS__ << "):", dbg_out(__VA_ARGS__)
#else
#define dbg(...)
#endif


const int INF = int(1e9) + 5;

int main() {
    ios::sync_with_stdio(false);
#ifndef NEAL_DEBUG
    cin.tie(nullptr);
#endif

    int N, A, B;
    string str;
    cin >> N >> A >> B >> str;
    vector<int> S(N);
    vector<int> char_to_index(128, -1);
    string chars;
    int C = 0;

    for (int i = 0; i < N; i++) {
        char ch = str[i];

        if (char_to_index[ch] < 0) {
            char_to_index[ch] = C++;
            chars += ch;
        }

        S[i] = char_to_index[ch];
    }

    dbg(chars);

    vector<int> char_start(C, INF);
    vector<int> char_end(C, -INF);
    vector<int> occur(C, 0);

    for (int i = 0; i < N; i++) {
        char_start[S[i]] = min(char_start[S[i]], i);
        char_end[S[i]] = max(char_end[S[i]], i + 1);
        occur[S[i]]++;
    }

    vector<bool> succeeds(1 << C, false);

    for (int mask = 1; mask < 1 << C; mask++) {
        int start = INF, end = -INF, count = 0;

        for (int c = 0; c < C; c++)
            if (mask >> c & 1) {
                start = min(start, char_start[c]);
                end = max(end, char_end[c]);
                count += occur[c];
            }

        succeeds[mask] = count * B >= (end - start) * A;

        if (succeeds[mask])
            dbg(mask, "succeeds");
    }

    vector<int> dp(1 << C, 0);

    for (int c = 0; c < C; c++)
        dp[1 << c] = 1 << c;

    for (int mask = 0; mask < 1 << C; mask++) {
        for (int split = 0; split < C; split++) {
            int lower = mask & ((1 << split) - 1);
            int upper = mask & -(1 << split);
            assert((lower | upper) == mask && (lower & upper) == 0);

            if (succeeds[lower] && dp[lower] != 0) dp[mask] |= dp[upper];
            if (succeeds[upper] && dp[upper] != 0) dp[mask] |= dp[lower];
        }

        for (int single = 0; single < C; single++)
            if (mask >> single & 1) {
                int without = mask & ~(1 << single);

                if (succeeds[without] && dp[without] != 0)
                    dp[mask] |= 1 << single;
            }

        dbg(mask, dp[mask]);
    }

    int answer = dp[(1 << C) - 1];
    cout << __builtin_popcount(answer);
    string sorted;

    for (int c = 0; c < C; c++)
        if (answer >> c & 1)
            sorted += chars[c];

    sort(sorted.begin(), sorted.end());

    for (auto &ch : sorted)
        cout << ' ' << ch;

    cout << '\n';
}
