#include <bits/stdc++.h>
using namespace std;

int main(){
    // Define the Morse code mapping
    // Letters A-Z
    vector<pair<char, string>> morse_map = {
        {'A', ".-"}, {'B', "-..."}, {'C', "-.-."}, {'D', "-.."},
        {'E', "."}, {'F', "..-."}, {'G', "--."}, {'H', "...."},
        {'I', ".."}, {'J', ".---"}, {'K', "-.-"}, {'L', ".-.."},
        {'M', "--"}, {'N', "-."}, {'O', "---"}, {'P', ".--."},
        {'Q', "--.-"}, {'R', ".-."}, {'S', "..."}, {'T', "-"},
        {'U', "..-"}, {'V', "...-"}, {'W', ".--"}, {'X', "-..-"},
        {'Y', "-.--"}, {'Z', "--.."},
        // Digits 0-9
        {'0', "-----"}, {'1', ".----"}, {'2', "..---"}, {'3', "...--"},
        {'4', "....-"}, {'5', "....."}, {'6', "-...."}, {'7', "--..."},
        {'8', "---.."}, {'9', "----."}
    };

    // Create a map from Morse code to character for quick lookup
    unordered_map<string, char> morse_to_char;
    for(auto &p : morse_map){
        morse_to_char[p.second] = p.first;
    }

    // Read the input
    string input;
    getline(cin, input);

    // Filter the input to keep only alphanumeric characters and convert to uppercase
    string filtered;
    for(char c : input){
        if(isalnum(c)){
            filtered += toupper(c);
        }
    }

    // Convert to Morse code
    string S = "";
    for(char c : filtered){
        // Find the Morse code for c
        // 'A' to 'Z' are first 26, '0' to '9' are next 10
        string mc = "";
        if(c >= 'A' && c <= 'Z'){
            mc = morse_map[c - 'A'].second;
        }
        else { // '0' to '9'
            mc = morse_map[26 + (c - '0')].second;
        }
        S += mc;
    }

    // Check if S is a palindrome
    string RevS = S;
    reverse(RevS.begin(), RevS.end());
    if(S == RevS){
        cout << "0" << endl;
        return 0;
    }

    // Initialize variables to store the minimal number of characters and the append string
    int min_chars = INT32_MAX;
    string min_append = "";

    // Precompute the reverse of S
    string reversed_S = RevS;

    // Precompute the length of S
    int N = S.length();

    // Iterate k from 0 to len(RevS)
    for(int k=0; k <= reversed_S.length(); k++){
        // Check if S ends with reversed_S[0:k]
        if(k > N) continue; // Cannot have overlap longer than S
        bool match = true;
        for(int i=0; i<k; i++){
            if(S[N - k + i] != reversed_S[i]){
                match = false;
                break;
            }
        }
        if(!match) continue;
        // T is reversed_S[k:]
        string T = reversed_S.substr(k);
        // Now, perform word break on T
        int L = T.length();
        // Initialize DP
        vector<int> dp(L + 1, INT32_MAX);
        dp[0] = 0;
        // To reconstruct the path
        vector<char> back_char(L + 1, 0);
        // Iterate over T
        for(int i=1; i<=L; i++){
            for(auto &p : morse_map){
                string mc = p.second;
                int len_c = mc.length();
                if(i >= len_c && T.substr(i - len_c, len_c) == mc){
                    if(dp[i - len_c] != INT32_MAX && dp[i - len_c] + 1 < dp[i]){
                        dp[i] = dp[i - len_c] + 1;
                        back_char[i] = p.first;
                    }
                }
            }
        }
        // Check if T can be built
        if(dp[L] != INT32_MAX){
            // Reconstruct the string
            string append_str = "";
            int idx = L;
            while(idx > 0){
                char c = back_char[idx];
                append_str += c;
                // Find the length of Morse code for c
                string mc = "";
                if(c >= 'A' && c <= 'Z'){
                    mc = morse_map[c - 'A'].second;
                }
                else { // '0' to '9'
                    mc = morse_map[26 + (c - '0')].second;
                }
                idx -= mc.length();
            }
            // Since we reconstructed in reverse, reverse it back
            reverse(append_str.begin(), append_str.end());
            // Update minimal characters and append string
            if(dp[L] < min_chars){
                min_chars = dp[L];
                min_append = append_str;
            }
            // If same number of characters, we can keep the first one found
        }
    }

    // After all k, check if we found a solution
    if(min_chars != INT32_MAX){
        // If min_chars is 0, it means no need to append
        if(min_chars == 0){
            cout << "0" << endl;
        }
        else{
            cout << min_chars;
            // According to the problem statement, if not 0, we need to output a space and the append string
            cout << " " << min_append << endl;
        }
    }
    else{
        // According to the problem statement, it's always possible, but to be safe
        // Output the entire reversed_S as appended string
        // But need to build it from Morse codes, which should have been handled above
        // So this case should not occur
        cout << "0" << endl;
    }

    return 0;
}