#include <iostream>
#include <vector>
#include <string>
#include <unordered_map>

using namespace std;

// Кеш за вече изчислените блокове
unordered_map<string, pair<vector<int>, vector<int>>> cache;

// Функция, която намира оптималното разделяне за даден блок чрез 3^n груба сила
pair<vector<int>, vector<int>> solve_block_brute_force(const string& block) {
    int n = block.size();
    int max_len = -1;
    vector<int> best1, best2;

    // Ламбда функция за рекурсията, за да избегнем глобални променливи
    auto dfs = [&](auto& self, int idx, vector<int>& f1, vector<int>& f2, string& s1, string& s2) -> void {
        if (idx == n) {
            if (s1 == s2 && (int)f1.size() > max_len) {
                max_len = f1.size();
                best1 = f1;
                best2 = f2;
            }
            return;
        }

        // Избор 1: Пропускаме символа
        self(self, idx + 1, f1, f2, s1, s2);

        // Избор 2: Добавяме в Ограда 1
        f1.push_back(idx); s1.push_back(block[idx]);
        self(self, idx + 1, f1, f2, s1, s2);
        f1.pop_back(); s1.pop_back();

        // Избор 3: Добавяме в Ограда 2
        f2.push_back(idx); s2.push_back(block[idx]);
        self(self, idx + 1, f1, f2, s1, s2);
        f2.pop_back(); s2.pop_back();
    };

    vector<int> current_f1, current_f2;
    string current_s1 = "", current_s2 = "";
    
    // Стартираме търсенето за този блок
    dfs(dfs, 0, current_f1, current_f2, current_s1, current_s2);
    
    return {best1, best2};
}

// Функция, която връща резултата от кеша или го пресмята, ако липсва
pair<vector<int>, vector<int>> get_best_split(const string& block) {
    if (cache.find(block) != cache.end()) {
        return cache[block];
    }
    return cache[block] = solve_block_brute_force(block);
}

void solve_hybrid_pattern_match(int n, const string& s) {
    vector<int> fence1, fence2;
    int block_size = 10;

    // Обхождаме низа на стъпки от по 10
    for (int i = 0; i < n; i += block_size) {
        // Взимаме текущия блок (може да е по-малък от 10 накрая)
        string block = s.substr(i, block_size);
        
        // Взимаме оптималното решение за този шаблон
        pair<vector<int>, vector<int>> split = get_best_split(block);
        
        // Добавяме съответните индекси към главните огради, 
        // като ги отместваме с текущата позиция 'i'
        for (int idx : split.first) {
            fence1.push_back(i + idx);
        }
        for (int idx : split.second) {
            fence2.push_back(i + idx);
        }
    }

    int k = fence1.size();
    cout << k << "\n";
    for (int j = 0; j < k; ++j) cout << fence1[j] << (j == k - 1 ? "" : " ");
    cout << "\n";
    for (int j = 0; j < k; ++j) cout << fence2[j] << (j == k - 1 ? "" : " ");
    cout << "\n";
}

int main() {
    ios_base::sync_with_stdio(false); 
    cin.tie(NULL);
    
    int n, g;
    if (cin >> n >> g) {
        string s;
        cin >> s;
        solve_hybrid_pattern_match(n, s);
    }
    
    return 0;
}
