// Un parser con CYK. Lee una gramática en forma normal de Chomsky y una lista de cadenas.
// Por cada cadena imprime si la gramática la genera y, si la genera, un árbol de derivación.
#include <iostream>
#include <string>
#include <utility>
#include <vector>

// Los cuatro componentes de G = (V, Σ, R, S), con los nombres del formato.
// Los tipos son una propuesta: cada variable se guarda por su posición en la lista, para que
// la tabla de CYK no tenga que comparar nombres, y las reglas se separan según su forma.
// Pueden cambiarlos.
struct Cfg {
    std::vector<std::string> variables;          // V: los nombres, en el orden de la entrada
    std::vector<char> terminals;                 // Σ
    std::vector<std::vector<int>> binary;        // R, las reglas A → B C: {A, B, C} como posiciones en variables
    std::vector<std::pair<int, char>> terminal;  // R, las reglas A → a: (A, a)
    bool start_to_eps = false;                   // R, la regla S → ε, si está
    int start = 0;                               // S, como posición en variables
};

int main() {
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);

    Cfg g;
    std::string line;
    // Por hacer: leer la gramática línea por línea con std::getline, hasta la línea strings:.
    // Después, leer las cadenas (una línea vacía es ε), llenar la tabla de CYK para cada una
    // y responder. Para las que se generan, recuperar un árbol de la tabla.
    while (std::getline(std::cin, line)) {
    }
    // Este esqueleto no imprime nada, así que el juez da WA en todos los casos.
    return static_cast<int>(g.variables.size());
}
