/**
 * @file code.c
 * @author Eliott
 * @author ESBELIN
 * @version finale
 * @date 20 avril 2025
 * @brief Mon code pour cryptarithm
 */

#include <stdio.h>
#include <string.h>
#include <stdlib.h>

/**
 * @def #define MAX_LETTRES 10
 * @brief défini une variable MAX_LETTRES à 10
 */

#define MAX_LETTRES 10

/**
 * @def #define MAX_MOTS 5
 * @brief défini une variable MAX_MOTS à 5
 */

#define MAX_MOTS 5

/**
 * @def #define MAX_LONGUEUR 100
 * @brief défini une variable MAX_LONGUEUR à 100
 */

#define MAX_LONGUEUR 100

/**
 * @fn int verifier_solution(char mots[MAX_MOTS][MAX_LONGUEUR], int N, char totalStr[MAX_LONGUEUR], int chiffres[], char lettres[], int nb_lettres)
 * @brief vérifie si la combinaison satisfait l'addition
 * @param mots un tableau de chaines de caractères
 * @param N un entier naturel
 * @param totalStr une chaine de caractères
 * @param chiffres un entier naturel
 * @param lettres une chaine de caractère
 * @param nb_lettres un entier naturel
 * @return 1 si l'addition est correcte
 * @return 0 si l'addition n'est pas correcte
 */

int verifier_solution(char mots[MAX_MOTS][MAX_LONGUEUR], int N, char totalStr[MAX_LONGUEUR], int chiffres[], char lettres[], int nb_lettres) {
    int valeurs[N + 1];

    for (int i = 0; i < N + 1; i++) {
        valeurs[i] = 0;
        char *mot = (i < N) ? mots[i] : totalStr;
        for (int j = 0; j < strlen(mot); j++) {
            int index = strchr(lettres, mot[j]) - lettres;
            valeurs[i] = valeurs[i] * 10 + chiffres[index];
        }
    }

    int somme = 0;
    for (int i = 0; i < N; i++) {
        somme += valeurs[i];
    }

    return (somme == valeurs[N]);
}

/**
 * @fn void permuter(int chiffres[], int index, int utilisé[], char mots[MAX_MOTS][MAX_LONGUEUR], int N, char totalStr[MAX_LONGUEUR], char lettres[], int nb_lettres)
 * @brief génère les permutations des chiffres
 * @param chiffres un tableau d'entier naturel
 * @param index un entier naturel
 * @param utilisé un tableau d'entier naturel
 * @param mots un tableau de chaines de caractères
 * @param N un entier naturel
 * @param totalStr une chaine de caractère
 * @param lettres une chaine de caractère
 * @param nb_lettres un entier naturel
 */

void permuter(int chiffres[], int index, int utilisé[], char mots[MAX_MOTS][MAX_LONGUEUR], int N, char totalStr[MAX_LONGUEUR], char lettres[], int nb_lettres) {
    if (index == nb_lettres) {
        if (verifier_solution(mots, N, totalStr, chiffres, lettres, nb_lettres)) {
            for (int i = 0; i < nb_lettres; i++) {
                printf("%c %d\n", lettres[i], chiffres[i]);
            }
        }
        return;
    }

    for (int i = 0; i < 10; i++) {
        if (!utilisé[i]) {
            int est_premiere_lettre = 0;
            for (int j = 0; j < N + 1; j++) {
                char *mot = (j < N) ? mots[j] : totalStr;
                if (lettres[index] == mot[0]) {
                    est_premiere_lettre = 1;
                    break;
                }
            }

            if (est_premiere_lettre && i == 0)
                continue;

            chiffres[index] = i;
            utilisé[i] = 1;
            permuter(chiffres, index + 1, utilisé, mots, N, totalStr, lettres, nb_lettres);
            utilisé[i] = 0;
        }
    }
}

int main() {
    int N;
    scanf("%d", &N);

    char mots[MAX_MOTS][MAX_LONGUEUR];
    for (int i = 0; i < N; i++) {
        scanf("%s", mots[i]);
    }

    char totalStr[MAX_LONGUEUR];
    scanf("%s", totalStr);

    char lettres[MAX_LETTRES] = "";
    for (int i = 0; i < N + 1; i++) {
        char *mot = (i < N) ? mots[i] : totalStr;
        for (int j = 0; j < strlen(mot); j++) {
            if (!strchr(lettres, mot[j])) {
                int len = strlen(lettres);
                lettres[len] = mot[j];
                lettres[len + 1] = '\0';
            }
        }
    }

    // Trier les lettres par ordre alphabétique
    int nb_lettres = strlen(lettres);
    qsort(lettres, nb_lettres, sizeof(char), (int (*)(const void *, const void *)) strcmp);

    int chiffres[MAX_LETTRES], utilisé[10] = {0};

    permuter(chiffres, 0, utilisé, mots, N, totalStr, lettres, nb_lettres);

    return 0;
}