using System;

using System.Collections;

using System.Collections.Generic;

using System.Linq;

​

public class Programm

{

    public static void Main(string[] args)

    {

        int mode =8;//int.Parse(args[0]);

        int take =1;//int.Parse(args[1]);

        int index = 0;

​

        IEnumerable<int> intersection = null;

​

        foreach (char c in Convert.ToString(mode, 2).Reverse())

        {

            ++index;

            if (c == '0')

                continue;

​

            switch (index)

            {

                case 1: intersection = _join(intersection, OEIS1()); break;

                case 2: intersection = _join(intersection, OEIS2()); break;

                case 3: intersection = _join(intersection, OEIS3()); break;

                case 4: intersection = _join(intersection, OEIS4(), true); break;

​

                default: throw new ArgumentException();

            }

        }

        if (intersection == null)

            return;

​

        bool first = true;

        foreach (int i in intersection.Take(take))

        {

            if (first) first = false;

            else Console.Write(",");

​

            Console.Write(i);

        }

​

        Console.ReadKey();

    }

​

    private static IEnumerable<int> _join(IEnumerable<int> intersection, IEnumerable<int> newSequence, bool hof = false)

    {

        if (intersection == null)

            foreach (int n in newSequence) yield return n;

​

​

​

        int generation = 0;

        int generationMax = 1;

        foreach (int i in intersection)

        {

            Dictionary<int, HashSet<int>> generationCache = hof ? new Dictionary<int, HashSet<int>>() : null;

            int count = 0;

            foreach (int n in newSequence)

            {

                if (!hof)

                {

                    if (i < n)

                        break;

                }

                else

                {

                    if (!generationCache.ContainsKey(generation))

                        generationCache.Add(generation, new HashSet<int>());

​

                    generationCache[generation].Add(n);

​

                    if (generationCache.Count == 1)

                    {

                        int lowerBound = generationCache[generation].OrderBy(gi => gi).Take(2).Sum();

                        if (i < lowerBound)

                            break;

                    }

                    else

                    {

                        int lowerBound = generationCache[generation].Concat(generationCache[generation - 1]).OrderBy(gi => gi).Take(2).Sum();

                        if (i < lowerBound)

                            break;

                    }

​

                    if (++count == generationMax)

                    {

                        generation++;

                        generationMax = (int)Math.Pow(2, generation);

                    }

                }

​

                if (i == n)

                {

                    yield return i;

                    break;

                }

            }

        }

    }

​

​

    static IEnumerable<int> OEIS1()

    {

        int position = 0;

        for (int i = 0; i < int.MaxValue; i++)

            foreach (char c in Convert.ToString(i, 2))

            {

                if (c == '0')

                    yield return position;

                position++;

            }

    }

​

    static IEnumerable<int> OEIS2()

    {

        int take = 1;

        int skip = 0;

        bool doTake = true;

        using (IEnumerator<int> enumerator = Enumerable.Range(0, int.MaxValue).GetEnumerator())

        {

            while (enumerator.MoveNext())

            {

                if (doTake)

                {

                    if (skip == 0)

                        skip = take + 1;

                    yield return enumerator.Current;

                    if (--take == 0)

                        doTake = false;

                }

                else

                {

                    if (take == 0)

                        take = skip + 1;

                    if (--skip == 0)

                        doTake = true;

                }

            }

        }

    }

​

    static IEnumerable<int> OEIS3()

    {

        for (int i = 0; i < int.MaxValue; i++)

        {

            string s = Convert.ToString(i, 2);

            if (_isPowerOfTwo(s.Count(c => c == '0')) && _isPowerOfTwo(s.Count(c => c == '1')))

                yield return i;

        }

    }

​

    static bool _isPowerOfTwo(int number)

    {

        return (number != 0) && ((number & (number - 1)) == 0);

    }

​

    static IEnumerable<int> OEIS4()

    {

        return Enumerable.Range(1, int.MaxValue).Select(HofstadterQ);

    }

​

    static Dictionary<int, int> _hofstadterQCache = new Dictionary<int, int>();

​

    static int HofstadterQ(int n)

    {

        int result;

        if (!_hofstadterQCache.TryGetValue(n, out result))

        {

            if (n < 3)

                result = 1;

            else

                result = HofstadterQ(n - HofstadterQ(n - 1)) + HofstadterQ(n - HofstadterQ(n - 2));

​

            _hofstadterQCache.Add(n, result);

        }

        return result;

    }

}