Message In A Bottle With Queue

namespace MessageInABottle
{
    using System;
    using System.Collections.Generic;

    /// <summary>
    /// In a warm, sunny day Andrew found a bottle near the sea. It was a very special bottle, containing not one, but two messages. The first message contained a big sequence of digits (0-9). “This must be a secret code”, Andrew thought. And he was right. After seeing the second message everything became clearer. The second message said something like this: “A123C11B98”. Another idea struck Andrew: “Hmm may be this is the cipher, used for creating the secret code”. And again he was right.
    /// An alphabetical message, containing only capital English letters, is encoded with the given cipher. For every letter in the original message it is replaced by the given sequence of digits in the cipher.
    /// For example an original message ABC with a cipher A123C11B98 will be encoded as 1239811.
    /// Write a program that for a given secret code from the first bottle message and a given cipher from the second bottle message finds all possible original messages that can be encoded to the given secret code.
    /// </summary>
    public class MessageInABottle
    {
        public static void Main()
        {
            string message = Console.ReadLine();
            string code = Console.ReadLine();

            Dictionary<string, char> cipher = new Dictionary<string, char>();
            char letter = '.';
            string digit = string.Empty;
            for (int i = 0; i < code.Length; i++)
            {
                if (char.IsLetter(code[i]))
                {
                    if (digit != string.Empty)
                    {
                        cipher.Add(digit, letter);
                        digit = string.Empty;
                    }

                    letter = code[i];
                }
                else
                {
                    digit += code[i];
                }
            }

            if (digit != string.Empty)
            {
                cipher.Add(digit, letter);
            }

            List<string> results = new List<string>();

            Decode current = new Decode();
            current.Solved = string.Empty;
            current.Left = message;
            Queue<Decode> possibleSolutions = new Queue<Decode>();
            possibleSolutions.Enqueue(current);

            while (possibleSolutions.Count != 0)
            {
                current = possibleSolutions.Dequeue();
                foreach (var item in cipher)
                {
                    if (current.Left.StartsWith(item.Key))
                    {
                        Decode temp = new Decode();
                        temp.Solved = current.Solved + item.Value;
                        temp.Left = current.Left.Remove(0, item.Key.Length);

                        if (temp.Left.Length == 0)
                        {
                            results.Add(temp.Solved);
                        }
                        else
                        {
                            possibleSolutions.Enqueue(temp);
                        }
                    }
                }
            }

            results.Sort();

            Console.WriteLine(results.Count);
            foreach (var item in results)
            {
                Console.WriteLine(item);
            }
        }

        public class Decode
        {
            public string Solved { get; set; }

            public string Left { get; set; }
        }
    }
}