OI XXXIII - ste

// https://szkopul.edu.pl/problemset/problem/Vc3EYISNd8DRaR6CC1g_4Dhy/site/?key=statement

#include <bits/stdc++.h>

// #define GARY_DBG
#define GARY_LIB

constexpr int sizik = 1000 * 1001;

#define ar std::array

typedef std::vector<std::vector<int>> _kra;

int k;

constexpr int WIADOMOSC_SIZE = 980;
constexpr int WIADOMOSC_STR_SIZE = 200000;
constexpr int GRID_SIZE = 1000;
constexpr int MAGIC_VAL = 40016;

char str[WIADOMOSC_STR_SIZE + 7];
char grid[GRID_SIZE + 7][GRID_SIZE + 7];

void set_grid(int& i, int& j, int val) {
    if (j < WIADOMOSC_SIZE) {
        grid[i][j++] = val;
    } else {
        i = i + 1, j = 0;
        grid[i][j++] = val;
    }
}

void zak(int& last_idx, int& i, int& j) {
    int num = 0;
    num += (str[last_idx + 0] > 0) * (str[last_idx + 0] - 'a' + 1);
    num += (str[last_idx + 1] > 0) * 27 * (str[last_idx + 1] - 'a' + 1);
    num += (str[last_idx + 2] > 0) * 729 * (str[last_idx + 2] - 'a' + 1);
    num += (str[last_idx + 3] > 0) * 19683 * (str[last_idx + 3] - 'a' + 1);
    num += (str[last_idx + 4] > 0) * 531441 * (str[last_idx + 4] - 'a' + 1);
    last_idx += 5;
    for (int k = 0; k < 24; k++) {
        set_grid(i, j, (!!(num & (1 << k)) + '0'));
    }
}

void print(int decoder1 = 0, std::ostream& d = std::cout) {
    for (int i = 0 + decoder1; i < GRID_SIZE + decoder1; i++) {
        for (int j = 0 + decoder1; j < GRID_SIZE + decoder1; j++) {
            d << grid[i][j];
        }
        d << '\n';
    }
}

void encoder() {
    int n;
    std::cin >> n;

    std::string s;
    std::cin >> s;

    for (int i = 0; i < n; i++) {
        str[i] = s[i];
    }

    for (int i = 0; i < GRID_SIZE; i++) {
        for (int j = 0; j < GRID_SIZE; j++) {
            grid[i][j] = '0';
        }
    }

    int last_idx = 0;
    int i = 0;
    int j = 0;
    int cnt = 0;
    while (i < WIADOMOSC_SIZE) {
        zak(last_idx, i, j);
        cnt += 5;
        if (cnt > n) break;
    }

    for (int i = 0; i < WIADOMOSC_SIZE + 10; i++) {
        for (int j = WIADOMOSC_SIZE; j < WIADOMOSC_SIZE + 10; j++) {
            grid[i][j] = '1';
        }
    }

    for (int i = 0; i < WIADOMOSC_SIZE + 10; i++) {
        for (int j = WIADOMOSC_SIZE + 10; j < GRID_SIZE; j++) {
            grid[i][j] = !!((i + 1) & (1 << (j - WIADOMOSC_SIZE - 10))) + '0';
        }
    }

    for (int i = GRID_SIZE - 1; i >= GRID_SIZE - 10; i--) {
        for (int j = WIADOMOSC_SIZE + 10 + GRID_SIZE - 1 - i; j < GRID_SIZE; j++) {
            grid[i][j] = '1';
        }
    }

    for (int i = WIADOMOSC_SIZE; i < WIADOMOSC_SIZE + 10; i++) {
        for (int j = 0; j < WIADOMOSC_SIZE; j++) {
            grid[i][j] = !!((j + 1) & (1 << (i - WIADOMOSC_SIZE))) + '0';
        }
    }

    print();
}

int schodki_idx[11];
int schodki_col_idx[11];
std::map<int, int> row_idx;
std::map<int, int> col_idx;

bool dek(int& i, int& j, std::string& res) {
    int num = 0;
    for (int k = 0; k < 24; k++) {
        if (j <= WIADOMOSC_SIZE) {
        } else {
            i++;
            j = 1;
        }
        num += (grid[row_idx[i]][col_idx[j]] - '0') << k;
        j++;
    }
    int tmp = num;
    for (int k = 0; k < 5; k++) {
        int w = tmp % 27;
        tmp /= 27;

        if (w == 0) return true;
        res += (char)(w - 1 + 'a');
    }
    return false;
}

void decoder() {
    for (int i = 1; i <= GRID_SIZE; i++) {
        for (int j = 1; j <= GRID_SIZE; j++) {
            std::cin >> grid[i][j];
        }
    }

    std::map<int, int> sch;
    for (int i = 1; i <= GRID_SIZE; i++) {
        int cnt = 0;
        for (int j = 1; j <= GRID_SIZE; j++) {
            cnt += (grid[i][j] == '1');
        }
        if (1 <= cnt && cnt <= 10) {
            schodki_idx[cnt] = i;
            sch[i]++;
        }
    }

    std::map<int, int> cols;
    std::map<int, int> vals;
    for (int i = 1; i <= 10; i++) {
        for (int j = 1; j <= GRID_SIZE; j++) {
            if (grid[schodki_idx[i]][j] == '1') {
                vals[j]++;
            }
        }
        for (const auto& [a, b] : vals) {
            if (b == 1) {
                schodki_col_idx[i] = a;
                cols[a]++;
            }
        }
    }

    for (int i = 1; i <= GRID_SIZE; i++) {
        if (sch[i]) continue;
        int num = 0;
        for (int j = 10, k = 0; j >= 1; j--, k++) {
            num += (grid[i][schodki_col_idx[j]] - '0') << k;
        }
        row_idx[num] = i;
    }

    for (int j = 1; j <= GRID_SIZE; j++) {
        if (cols[j]) continue;
        int cnt = 0;
        for (int i = 1; i <= GRID_SIZE; i++) {
            cnt += grid[i][j] == '1';
        }
        if (cnt == 990) {
            cols[j]++;
        }
    }

    for (int j = 1; j <= GRID_SIZE; j++) {
        if (cols[j]) continue;

        int num = 0;
        for (int i = WIADOMOSC_SIZE + 1; i <= WIADOMOSC_SIZE + 10; i++) {
            num += (grid[row_idx[i]][j] == '1') << (i - WIADOMOSC_SIZE - 1);
        }
        col_idx[num] = j;
    }

    std::string res;
    int i = 1, j = 1;
    while (true) {
        bool b = dek(i, j, res);
        if (b) break;
    }

    std::cout << res;
}

void solve() {
    std::cin >> k;

    std::string s;
    std::cin >> s;

    if (s == "encoder") {
        encoder();
    } else {
        decoder();
    }
}

int32_t main() {
#ifndef GARY_DBG
    std::ios_base::sync_with_stdio(0);
    std::cin.tie(0);
    std::cout.tie(0);
#endif

    int t = 1;
    // std::cin >> t;

    for (; t > 0; t--) {
        solve();
    }

    return 0;
}