// De NFA a DFA. Lee un NFA con transiciones ε en formato .nfa y escribe un DFA equivalente en
// formato .dfa, con solo los subconjuntos alcanzables.
#include <cstdint>
#include <iostream>
#include <string>
#include <vector>

// Con |Q| ≤ 60, un conjunto de estados cabe en un entero de 64 bits: el bit i dice si el
// estado número i está en el conjunto. Es una propuesta: también sirve un std::set<int>.
using StateSet = std::uint64_t;

// Los cinco componentes de N = (Q, Σ, δ, q0, F), con los nombres del formato.
struct Nfa {
    std::vector<std::string> states;               // Q: los nombres, en el orden de la entrada
    std::vector<char> alphabet;                    // Σ
    std::vector<std::vector<StateSet>> delta;      // δ: delta[i][j] es el conjunto al que va states[i] con alphabet[j]
    std::vector<StateSet> eps;                     // δ(q, ε): eps[i] es el conjunto al que va states[i] sin leer nada
    int start = 0;                                 // q0, como posición en states
    StateSet accept = 0;                           // F
};

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

    Nfa n;
    std::string line;
    // Por hacer:
    //   1. Leer la descripción línea por línea, hasta el final de la entrada.
    //   2. Calcular la clausura ε con una búsqueda en el grafo de las transiciones ε.
    //   3. Generar los subconjuntos alcanzables con una cola, a partir de E({q0}), y darle a
    //      cada uno un nombre nuevo y corto: s0, s1, s2…
    //   4. Escribir el DFA en formato .dfa.
    while (std::getline(std::cin, line)) {
    }
    // Este esqueleto no escribe nada, así que el verificador da WA en todos los casos.
    return static_cast<int>(n.states.size());
}
