#include "bits/extc++.h"

using namespace std;

template <typename T, typename... U>
void dbgh(const T& t, const U&... u) {
    cerr << t;
    ((cerr << " | " << u), ...);
    cerr << endl;
}

#ifdef DEBUG
#define dbg(...)                                           \
    cerr << "L" << __LINE__ << " [" << #__VA_ARGS__ << "]" \
         << ": ";                                          \
    dbgh(__VA_ARGS__)
#else
#define cerr   \
    if (false) \
    cerr
#define dbg(...)
#endif

#define endl "\n"
#define long int64_t
#define sz(x) int(std::size(x))

bool on(int mask, int bit) {
    return (mask >> bit) & 1;
}

constexpr int N = 6;

struct S {
    array<int, 1 << N> arr;
    array<array<array<int, 2>, N>, N> cnt;

    void set_arr(int mask, int nx) {
        for (int j = 0; j < N; j++) {
            cnt[arr[mask]][j][on(mask, j)]--;
        }

        arr[mask] = nx;

        for (int j = 0; j < N; j++) {
            cnt[arr[mask]][j][on(mask, j)]++;
        }
    }

    static array<array<array<int, 2>, N>, N> compute_cnt(
        const array<int, 1 << N>& arr) {
        array<array<array<int, 2>, N>, N> ans {};

        for (int i = 0; i < (1 << N); i++) {
            for (int j = 0; j < N; j++) {
                ans[arr[i]][j][on(i, j)]++;
            }
        }

        return ans;
    }

    static S c_from(const array<int, 1 << N>& arr) {
        return {arr, compute_cnt(arr)};
    }
};

pair<int, int> compute_opt(const S& s, int cur) {
    pair<int, int> opt {};

    for (int i = 0; i < N; i++) {
        int ccnt = 0;

        for (int j = 0; j < N; j++) {
            ccnt += s.cnt[j][i][on(cur, j)];
        }

        opt = max(opt, {ccnt, i});
    }

    return opt;
}

int compute_score(const S& s) {
    int ans = 0;

    for (int i = 0; i < (1 << N); i++) {
        ans += compute_opt(s, i).first;
    }

    return ans;
}

struct ScoreManager {
    static void write(const S& s) {
        ofstream out("output.txt");

        for (auto& a : s.arr) {
            out << a;
        }
    }

    int best_score = -1, last_iter = -1;
    S opt_state;

    void update(int n_score, int iters, const S& s) {
        if (iters - last_iter == int(1e5)) {
            dbg("SAVED", best_score);
            write(opt_state);
        }
        if (n_score <= best_score) {
            return;
        }

        last_iter = iters;
        best_score = n_score;
        opt_state = s;
        dbg(best_score);
    }
};

struct R {
    mt19937_64 cowng;

    R() : cowng(chrono::steady_clock::now().time_since_epoch().count()) {}

    long rint(long l, long r) {
        return cowng() % (r - l + 1) + l;
    }

    bool rprob(double p) {
        return uniform_real_distribution<double>(0, 1)(cowng) < p;
    }
} R;

void sa() {
    S state = S::c_from([&]() {
        array<int, 1 << N> carr;

        for (auto& a : carr) {
            a = R.rint(0, N - 1);
        }

        return carr;
    }());

    auto accept_prob = [&](int n_score, int cur_score, double temp) -> double {
        if (n_score > cur_score) {
            return 1;
        }

        return exp((n_score - cur_score) / temp);
    };

    double temp = 1e5;
    int cur_score = compute_score(state), iters = 0;
    ScoreManager manager;

    while (true) {
        manager.update(cur_score, iters, state);
        temp *= 0.999999;
        if (++iters % 1000 == 0) {
            dbg(temp, manager.best_score, cur_score);
        }

        int ind = R.rint(0, (1 << N) - 1), px = state.arr[ind],
            nx = R.rint(0, N - 1);

        state.set_arr(ind, nx);
        int n_score = compute_score(state);
        assert(n_score);

        if (R.rprob(accept_prob(n_score, cur_score, temp))) {
            cur_score = n_score;
        } else {
            state.set_arr(ind, px);
        }
    }
    dbg(compute_score(state) / double(1 << (2 * N)));
}

S state = []() {
    auto data =
        "3255225522222222445544554400440011554455222222224455445544114430";

    array<int, 1 << N> arr;
    for (int i = 0; i < (1 << N); i++) {
        arr[i] = data[i] - '0';
    }

    return S::c_from(arr);
}();

void solve_first(int kv, const string& s) {
    vector<int> out;

    for (int i = 0; i < kv; i++) {
        int ql = i * N, cx = 0;
        for (int j = 0; j < N; j++) {
            cx |= (s[ql + j] - '0') << j;
        }

        out.push_back(ql + state.arr[cx]);
    }

    for (int i = 0; i < kv; i++) {
        cout << out[i] + 1 << " \n"[i == kv - 1];
    }
}

void solve_second(int kv, const string& s) {
    vector<int> out;

    for (int i = 0; i < kv; i++) {
        int ql = i * N, cx = 0;
        for (int j = 0; j < N; j++) {
            cx |= (s[ql + j] - '0') << j;
        }

        out.push_back(ql + compute_opt(state, cx).second);
    }

    for (int i = 0; i < kv; i++) {
        cout << out[i] + 1 << " \n"[i == kv - 1];
    }
}

void solve() {
    dbg(compute_score(state));
    string name, s;
    int n, kv;
    cin >> name >> n >> kv >> s;

    if (name == "Flim") {
        solve_first(kv, s);
    } else {
        solve_second(kv, s);
    }
}

int main() {
    cin.tie(nullptr);
    cin.exceptions(ios::failbit);
    ios_base::sync_with_stdio(false);
    solve();
}