#include <cstdio>
#include <cstring>
#include <cassert>

#include <bit>
#include <utility>
#include <algorithm>
#include <functional>

// This solution should get three points.

static bool matrix[10][10] = {{false}};
static int col_sums[10] = {0};
static int row_sums[10] = {0};
static int row_index[10] = {0};

static const int index_pattern[10][4] = {
    {0, 0, 0, 0},
    {0, 0, 0, 1},
    {0, 0, 1, 0},
    {0, 0, 1, 1},
    {0, 1, 0, 1},
    {0, 1, 1, 0},
    {0, 1, 1, 1},
    {1, 0, 0, 1},
    {1, 0, 1, 1},
    {1, 1, 1, 1},
};

static const int NUM_CODINGS_PER_COLUMN = 364;

static int precomputed_encode[NUM_CODINGS_PER_COLUMN];
static int precomputed_decode[1024];

static void precompute_coding() {
    int x = 0;
    for (int y = 0; y < 1024; y++) {
        int popcount = std::popcount((unsigned int)y);
        if (popcount <= 2 || popcount == 5 || popcount >= 8) {
            precomputed_encode[x] = y;
            precomputed_decode[y] = x;
            x++;
        } else {
            precomputed_decode[y] = -1;
        }
    }
    assert(x == NUM_CODINGS_PER_COLUMN);
}

static void swap_rows(int x, int y) {
    if (x == y) {
        return;
    }
    for (int i = 0; i < 10; i++) {
        std::swap(matrix[x][i], matrix[y][i]);
    }
    std::swap(row_sums[x], row_sums[y]);
    std::swap(row_index[x], row_index[y]);
}

static void swap_cols(int x, int y) {
    if (x == y) {
        return;
    }
    for (int i = 0; i < 10; i++) {
        std::swap(matrix[i][x], matrix[i][y]);
    }
    std::swap(col_sums[x], col_sums[y]);
}

static void encode_as_per_column_values(int* buffer, long long int rem) {
    int startpos = 0;
    for (int i = 6; i > 0; i--) {
        while (true) {
            // How many configs are there that have a bit set at `startpos`?
            long long int how_many = 1;
            for (int j = 1; j < i; j++) {
                how_many *= NUM_CODINGS_PER_COLUMN - (startpos + j);
                how_many /= j;
            }
            startpos++;
            if (rem < how_many) {
                buffer[i-1] = startpos - 1;
                break;
            }
            rem -= how_many;
        }
    }
}

static long long int decode_from_per_column_values(const int* buffer) {
    long long int ret = 0;
    int startpos = 0;
    for (int i = 6; i > 0; i--) {
        while (true) {
            // How many configs are there that have a bit set at `startpos`?
            long long int how_many = 1;
            for (int j = 1; j < i; j++) {
                how_many *= NUM_CODINGS_PER_COLUMN - (startpos + j);
                how_many /= j;
            }
            startpos++;
            if (startpos - 1 >= buffer[i-1]) {
                break;
            }
            ret += how_many;
        }
    }
    return ret;
}

static void algosia() {
    long long int num;
    scanf("%lld", &num);
    assert(num > 0);
    num -= 1;

    int per_column_values[6];
    encode_as_per_column_values(per_column_values, num);

    for (int row = 0; row < 10; row++) {
        for (int col = 0; col < 4; col++) {
            matrix[row][col] = (index_pattern[row][col] != 0) ? 1 : 0;
        }
    }
    for (int col = 4; col < 10; col++) {
        int final_encoded = precomputed_encode[per_column_values[col - 4]];
        for (int row = 0; row < 10; row++) {
            matrix[row][col] = (final_encoded & (1 << row));
        }
    }

    char write_buffer[128];
    for (int row = 0; row < 10; row++) {
        for (int col = 0; col < 10; col++) {
            write_buffer[11 * row + col] = matrix[row][col] ? '1' : '0';
        }
        write_buffer[11 * row + 10] = '\n';
    }
    fwrite(write_buffer, sizeof(char), 10 * 11, stdout);
    fflush(stdout);
}

static void bajtek() {
    for (int i = 0; i < 10; i++) {
        col_sums[i] = 0;
        row_sums[i] = 0;
    }

    char buffer[16];
    for (int row = 0; row < 10; row++) {
        scanf("%s", buffer);
        for (int col = 0; col < 10; col++) {
            matrix[row][col] = (buffer[col] == '1');
            col_sums[col] += matrix[row][col] ? 1 : 0;
            row_sums[row] += matrix[row][col] ? 1 : 0;
        }
    }

    // Recover the indexes
    for (int col = 0; col < 10; col++) {
        if (col_sums[col] == 3) {
            swap_cols(0, col);
        }
    }
    for (int col = 0; col < 10; col++) {
        if (col_sums[col] == 4) {
            swap_cols(1, col);
        }
    }
    for (int col = 0; col < 10; col++) {
        if (col_sums[col] == 6) {
            swap_cols(2, col);
        }
    }
    for (int col = 0; col < 10; col++) {
        if (col_sums[col] == 7) {
            swap_cols(3, col);
        }
    }
    assert(col_sums[0] == 3);
    assert(col_sums[1] == 4);
    assert(col_sums[2] == 6);
    assert(col_sums[3] == 7);
    for (int row = 0; row < 10; row++) {
        row_index[row] = 0;
        for (int col = 0; col < 4; col++) {
            row_index[row] |= (matrix[row][col] ? 1 : 0) << (3 - col);
        }
    }

    // Sort the rows
    for (int row1 = 0; row1 < 9; row1++) {
        for (int row2 = row1+1; row2 < 10; row2++) {
            if (row_index[row1] > row_index[row2]) {
                swap_rows(row1, row2);
            }
        }
    }

    // Extract the values
    int just_extracted[6];
    int extracted_count = 0;
    for (int col = 4; col < 10; col++) {
        assert(col_sums[col] <= 2 || col_sums[col] == 5 || col_sums[col] >= 8);
        int extracted = 0;
        for (int row = 0; row < 10; row++) {
            extracted |= (matrix[row][col] ? 1 : 0) << row;
        }
        just_extracted[extracted_count++] = precomputed_decode[extracted];
    }

    assert(extracted_count == 6);
    std::sort(just_extracted, just_extracted + extracted_count, std::greater<int>());

    long long int ans = decode_from_per_column_values(just_extracted) + 1;
    printf("%lld\n", ans);
    fflush(stdout);
}

int main() {
    char name[32];
    int n, t;

    scanf("%s", name);
    scanf("%d %d", &n, &t);

    precompute_coding();

    // fprintf(stderr, "name: %s, is algosia: %d, %d\n", name, strcmp(name, "Algosia") ? 1 : 0, (int)strlen(name));

    if (strcmp(name, "Algosia") == 0) {
        for (int i = 0; i < t; i++) {
            algosia();
        }
    } else {
        for (int i = 0; i < t; i++) {
            bajtek();
        }
    }

    return 0;
}