#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))

template <typename T>
ostream& operator<<(ostream& out, const vector<T>& arr) {
    out << "[";
    for (int i = 0; i < sz(arr); i++) {
        if (i) {
            out << ", ";
        }
        out << arr[i];
    }
    return out << "]";
}

pair<vector<int>, vector<vector<char>>> row_reduce(vector<vector<char>> arr,
                                                   bool augmented,
                                                   bool rref) {
    int n = sz(arr), m = sz(arr[0]);

    auto add = [&](int u, int v) -> void {
        for (int i = 0; i < m; i++) {
            arr[v][i] ^= arr[u][i];
        }
    };

    int row = 0, col = 0;
    vector<int> pivots(n, -1);

    while (row < n && col + augmented < m) {
        for (int i = row; i < n; i++) {
            if (arr[i][col]) {
                swap(arr[i], arr[row]);
                break;
            }
        }

        if (!arr[row][col]) {
            col++;
            continue;
        }

        for (int i = row + 1; i < n; i++) {
            if (arr[i][col]) {
                add(row, i);
            }
        }

        pivots[row] = col;
        row++;
        col++;
    }

    if (rref) {
        for (int i = n - 1; i >= 0; i--) {
            int p = pivots[i];

            if (p == -1) {
                continue;
            }

            for (int j = 0; j < i; j++) {
                if (arr[j][p]) {
                    add(i, j);
                }
            }
        }
    }

    return {pivots, arr};
}

bool is_basis(vector<vector<char>> arr) {
    int n = sz(arr), m = sz(arr[0]);
    assert(n == m);

    return sz(row_reduce(arr, false, false).first) == n;
}

struct C {
    int c, kv, n, iters;
};

struct S {
    vector<vector<vector<char>>> arr;

    static S c_from(const C& cf, const string& s) {
        vector arr(cf.kv, vector(cf.n, vector(cf.n * cf.c, char(0))));

        int si = 0;

        for (auto& a : arr) {
            for (auto& b : a) {
                for (auto& c : b) {
                    c = s[si++] - '0';
                }
            }
        }

        return S {arr};
    }
};

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

    bool perm[cf.kv] {};
    fill_n(perm, cf.c, true);
    sort(perm, perm + cf.kv);

    do {
        vector<vector<char>> mat;

        for (int i = 0; i < cf.kv; i++) {
            if (!perm[i]) {
                continue;
            }

            mat.insert(end(mat), begin(s.arr[i]), end(s.arr[i]));
        }

        auto pivots = row_reduce(mat, false, false).first;

        ans += sz(pivots) - int(count(begin(pivots), end(pivots), -1));
    } while (next_permutation(perm, perm + cf.kv));

    return ans;
}

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

        for (auto& a : s.arr) {
            for (auto& b : a) {
                for (auto& c : b) {
                    out << char('0' + c);
                }
            }
        }
    }

    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() {
    C cf {3, 5, 3, 0};

    S state = [&]() {
        vector arr(cf.kv, vector(cf.n, vector(cf.n * cf.c, char(0))));

        for (auto& a : arr) {
            for (auto& b : a) {
                for (auto& c : b) {
                    c = R.rint(0, 1);
                }
            }
        }

        return S {arr};
    }();
    dbg(compute_score(cf, state));

    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 = 1000;
    int cur_score = compute_score(cf, 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 i1 = R.rint(0, cf.kv - 1), i2 = R.rint(0, cf.n - 1),
            i3 = R.rint(0, cf.n * cf.c - 1);
        state.arr[i1][i2][i3] ^= true;

        int n_score = compute_score(cf, state);

        if (R.rprob(accept_prob(n_score, cur_score, temp))) {
            cur_score = n_score;
        } else {
            state.arr[i1][i2][i3] ^= true;
        }
    }
}

map<array<int, 3>, S> STATES = []() {
    stringstream in(R"raw(3 4 2
011001000111111111110001010110101101110000000010
3 4 3
111110000000010110001110000111110110011001001101111001011110100010110110110111100000000001110100010011100001
2 4 2
11110010101010110011011010000100
2 4 3
111000100111111100010010100001100110101010111110110000101011000010001011
3 5 2
100011111010001011100111101001100100010111101011001001110110
3 5 3
001110001001000001000101011100011010000000001111000011000100011010010101110011011010011010000011101010100110111010001011011010110100100
)raw");

    map<array<int, 3>, S> ans;

    for (int it = 0; it < 6; it++) {
        int c, kv, n;
        string s;
        in >> c >> kv >> n >> s;

        ans[{c, kv, n}] = S::c_from(C {c, kv, n, -1}, s);
    }

    return ans;
}();

vector<string> encode2(int c, int kv, int n, const string& bits) {
    auto s = STATES[{c, kv, n}];

    vector<string> out;

    for (int i = 0; i < kv; i++) {
        string cs;
        for (int j = 0; j < n; j++) {
            char cb = 0;
            for (int k = 0; k < c * n; k++) {
                cb ^= s.arr[i][j][k] * (bits[k] - '0');
            }
            cs += char('0' + cb);
        }
        out.push_back(cs);
    }

    return out;
}

vector<string> encode(int c, int kv, int gn, string s) {
    vector<string> ans(kv);

    int si = 0;
    for (int i = 0; i < gn;) {
        int cn = 2;
        if (i + 3 == gn) {
            cn = 3;
        }

        auto cans = encode2(c, kv, cn, s.substr(si, c * cn));
        si += c * cn;

        i += cn;

        for (int j = 0; j < kv; j++) {
            ans[j] += cans[j];
        }
    }

    return ans;
}

string decode2(int c, int kv, int n, vector<string> arr, vector<int> a_inds) {
    auto s = STATES[{c, kv, n}];

    vector<vector<char>> mat;

    for (int i = 0; i < c; i++) {
        for (int j = 0; j < n; j++) {
            mat.push_back(s.arr[a_inds[i]][j]);
            mat.back().push_back(arr[i][j] - '0');
        }
    }

    mat = row_reduce(mat, true, true).second;

    string ans;
    for (auto& a : mat) {
        ans += char('0' + a.back());
    }

    return ans;
}

string decode(int c, int kv, int gn, vector<string> arr, vector<int> a_inds) {
    string ans;

    int si = 0;
    for (int i = 0; i < gn;) {
        int cn = 2;
        if (i + 3 == gn) {
            cn = 3;
        }

        vector<string> carr;
        for (auto& a : arr) {
            carr.push_back(a.substr(si, cn));
        }
        auto cans = decode2(c, kv, cn, carr, a_inds);
        si += cn;

        i += cn;
        ans += cans;
    }

    return ans;
}