// ¿Son equivalentes dos DFA? Lee dos autómatas separados por una línea --- y responde
// equivalentes, o distintos y una cadena más corta que uno acepta y el otro no.
#include <iostream>
#include <string>
#include <vector>

// Los cinco componentes de M = (Q, Σ, δ, q0, F), con los nombres del formato.
// Los tipos son una propuesta: cada estado y cada símbolo se guarda por su posición en la
// lista, para que seguir una transición no dependa de buscar un nombre. Pueden cambiarlos.
struct Dfa {
    std::vector<std::string> states;      // Q: los nombres, en el orden de la entrada
    std::vector<char> alphabet;           // Σ
    std::vector<std::vector<int>> delta;  // δ: delta[i][j] es el estado al que va states[i] con alphabet[j]
    int start = 0;                        // q0, como posición en states
    std::vector<bool> accept;             // F: accept[i] dice si states[i] es de aceptación
};

// Por hacer: leer una descripción línea por línea con std::getline, hasta la línea --- o
// hasta el final de la entrada. Las líneas que empiezan con # son comentarios.
static Dfa read_dfa(std::istream& in) {
    Dfa m;
    std::string line;
    while (std::getline(in, line)) {
        if (line == "---") {
            break;
        }
    }
    return m;
}

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

    Dfa a = read_dfa(std::cin);
    Dfa b = read_dfa(std::cin);
    // Por hacer: buscar en anchura desde el par (a.start, b.start), generando solo los pares
    // a los que se llega. Si aparece un par en el que un estado es de aceptación y el otro no,
    // imprimir "distintos" y la cadena que llevó hasta él (eps si es la vacía).
    // Si la búsqueda termina sin encontrarlo, imprimir "equivalentes".
    // Este esqueleto no imprime nada, así que el juez da WA en todos los casos.
    return static_cast<int>(a.states.size() + b.states.size());
}
