// Un grep pequeño. Lee una expresión regular y una lista de líneas, e imprime por cada línea
// si la expresión la describe completa.
#include <iostream>
#include <string>
#include <vector>

// Un nodo del árbol de la expresión. Es una propuesta: pueden cambiarla.
// Los nodos se guardan en un std::vector y los hijos son posiciones en ese vector, así no
// hacen falta punteros.
struct Node {
    char kind;    // 'a' un símbolo, '|' unión, '.' concatenación, '*' estrella
    char symbol;  // solo si kind == 'a'
    int left;     // el hijo izquierdo, o el único hijo de una estrella; -1 si no tiene
    int right;    // el hijo derecho; -1 si no tiene
};

// El NFA de Thompson, también como propuesta. De cada estado sale una sola flecha con un
// símbolo o, como mucho, dos transiciones ε: δ cabe en tres arreglos indexados por el estado.
struct Nfa {
    std::vector<char> symbol;  // el símbolo de la flecha que sale del estado, o '\0' si no hay
    std::vector<int> next;     // a dónde lleva esa flecha
    std::vector<int> eps1;     // destinos de las transiciones ε, o -1
    std::vector<int> eps2;
    int start = 0;
    int accept = 0;
};

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

    std::string expression;
    std::getline(std::cin, expression);
    std::vector<Node> nodes;
    // Por hacer (paso 2): el árbol de expression, respetando la precedencia.

    Nfa n;
    // Por hacer (paso 3): el NFA de Thompson del árbol.

    std::string line;
    std::getline(std::cin, line);  // strings: k
    int k = std::stoi(line.substr(line.find(':') + 1));
    for (int i = 0; i < k; i++) {
        std::getline(std::cin, line);  // una línea vacía es la cadena ε
        // Por hacer (paso 4): simular n con line, llevando el conjunto de estados activos,
        // e imprimir acepta o rechaza.
    }
    // Este esqueleto no imprime nada, así que el juez da WA en todos los casos.
    return static_cast<int>(nodes.size() + n.symbol.size());
}
