public class PermutationString
    {
        public PermutationString()
        {
            m_string = "a";
        }

        private string m_string;

        public static PermutationString operator ++(PermutationString word)
        {
            word.m_string = word.next(word.m_string);
            return word;
        }

        public static implicit operator String(PermutationString word)
        {
            return word.m_string;
        }

        public string next()
        {
            return next(m_string);
        }


        private string next(string word)
        {
            return next(char_list(word),  0 );
        }


        private string next(List<char> chars, int depth)
        {
            int
                idx_last = chars.Count -  1 ,
                min =  97 ,
                max =  122 ;


            if (chars[idx_last - depth] < max)
            {
                chars[idx_last - depth]++;

                if (depth >  0 )
                {
                    for (int i = idx_last - depth +  1 ; i < chars.Count; i++)
                        chars[i] = 'a';
                }
            }
            else if (depth < idx_last)
            {
                return next(chars, ++depth);
            }
            else
            {
                reset(chars);
                chars.Insert( 0 , (char)min);
            }

            return chars_to_string(chars);
        }


        private string chars_to_string(List<char> chars)
        {
            string res = "";

            foreach (char smbl in chars)
                res += smbl;

            return res;
        }


        private void reset(List<char> chars)
        {
            for (int i =  0 ; i < chars.Count; i++)
                chars[i] = 'a';
        }



        private List<char> char_list(string word)
        {
            List<char> lst = new List<char>();

            for (int i =  0 ; i < word.Length; i++)
                lst.Add(word[i]);

            return lst;
        }
    }