public static class KeyUtility
{
    static KeyUtility()
    {
        Alphabet = new[] {
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H',
            'J', 'K', 'L', 'M', 'N', 'P', 'R', 'S',
            'T', 'U', 'V', 'X', 'Y', 'Z', '0', '1',
                    '2', '3', '4', '5', '6', '7', '8', '9'
        };

        ReverseAlphabet = Alphabet
            .Select((c, i) => new { Char = c, Value = i })
            .ToDictionary(k => k.Char, v => (byte) v.Value);
    }

    internal static char[] Alphabet;
    private static IDictionary<char, byte> ReverseAlphabet;

    public static string ToKey(byte[] key, int groupSize)
        {
            int i = 0, part = 0;

            var buffer = new KeyBuilder(key.Length, groupSize);
            while(true)
            {
                buffer.Append(key[i] >> 3);

                part = key[i++] & 7;
                if (i == key.Length)
                    break;

                buffer.Append((part << 2) | (key[i] >> 6));
                buffer.Append((key[i] & 62) >> 1);

                part = key[i++] & 1;
                if (i == key.Length)
                    break;

                buffer.Append((part << 4) | (key[i] >> 4));

                part = key[i++] & 15;
                if (i == key.Length)
                    break;

                buffer.Append((part << 1) | (key[i] >> 7));
                buffer.Append((key[i] & 124) >> 2);

                part = key[i++] & 3;
                if (i == key.Length)
                    break;

                buffer.Append((part << 3) | (key[i] >> 5));
                buffer.Append(key[i++] & 31);
            }

            buffer.Append(part);

            return buffer.ToString();
        }

    public static byte[] FromKey(string key)
    {
        var bytes = new List<byte>();
                foreach (var c in key)
                {
                    if (!Char.IsLetterOrDigit(c))
                            continue;

                    byte value;
                    if (!ReverseAlphabet.TryGetValue(Char.ToUpper(c), out value))
                            return null;

                    bytes.Add(value);
                }

                int i = 0, part = 0;

                var result = new List<byte>();
                while (true)
                {
                    part = bytes[i++] << 3;
                    if (i == bytes.Count)
                            break;

                    result.Add((byte) (part | (bytes[i] >> 2)));

                    part = bytes[i++] << 6;
                    if (i == bytes.Count)
                    {
                            result[result.Count - 1] = (byte)((bytes[i - 2] << 3) | bytes[i - 1]);
                            break;
                    }

                    part |= bytes[i++] << 1;
                    if (i == bytes.Count)
                            break;

                    result.Add((byte) (part | (bytes[i] >> 4)));

                    part = bytes[i++] << 4;
                    if (i == bytes.Count)
                            break;

                    result.Add((byte) (part | (bytes[i] >> 1)));

                    part = bytes[i++] << 7;
                    if (i == bytes.Count)
                    {
                            result[result.Count - 1] = (byte) ((bytes[i - 2] << 4) | bytes[i - 1]);
                            break;
                    }

                    part |= bytes[i++] << 2;
                    if (i == bytes.Count)
                            break;

                    result.Add((byte) (part | (bytes[i] >> 3)));

                    part = bytes[i++] << 5;
                    if (i == bytes.Count)
                    {
                            result[result.Count - 1] = (byte)((bytes[i - 3] << 7) | (bytes[i -2] << 2) | bytes[i - 1]);
                            break;
                    }

                    result.Add((byte)(part | bytes[i++]));
                }

                return result.ToArray();
    }
}