uva1635

            /*  哑元  组合数的递推整除判断_________________________________________________________________________________

                #include <iostream>

                #include <map>

                #include <cmath>

                #include <vector>

                #include <cstdio>

                #include <string>

                #include <cstring>

                #include <algorithm>

                using namespace std;

                #define fir first

                #define sec second

                #define pb(x) push_back(x)

                #define mem(A, X) memset(A, X, sizeof A)

                #define REP(i,l,u) for(int (i)=(int)(l);(i)<=(int)(u);++(i))

                #define rep(i,l,u) for(int (i)=(int)(l);(i)>=(int)(u);--(i))

                #define foreach(e,x) for(__typeof(x.begin()) e=x.begin();e!=x.end();++e)

                typedef int LL;

                typedef unsigned long long ull;

                typedef pair<long,long>  pll;

                LL T,n;

                const int mod=1e9+7;

                const int maxn=1e5+10;

                void pre(LL mm,vector <LL> & mf,map<LL,LL> &fp)//prime_resolve ( mm>=1  )mf m_factor,  fp factor_power  put all  the 素因子(即素数)2  ... of m  to  the  factor,且在factor按照从小到大存储.

                                            {

                                                mf.clear(); fp.clear();

                                                if(mm==1) {mf.pb(1); fp[1]=1;}

                                                else

                                                    {

                                                        for(int i=2;i*i<=mm;i++)

                                                        {

                                                            if(mm%i==0)

                                                            {

                                                                mf.push_back(i);

                                                                while(mm%i==0)            //除干净某个因子.

                                                                    {

                                                                        mm/=i;

                                                                        fp[i]++;

                                                                    }

                                                            }

                                                        }

                                                        if(mm!=1)

                                                            {

                                                              mf.push_back(mm);  //如果m 是素数 放进去

                                                              fp[mm]++;

                                                            }

                                                    }

                                            }

                int main()

                {

                     freopen("in.txt","r",stdin);

                     //while(cin>>n)

                     int n,m;

                     while(cin>>n>>m)

                     {

                         vector<int> ans;

                         if(m==1)

                             { REP(i,1,n) ans.pb(i);}

                         else

                         {

                       //REP(kase,1,T)  { }

                         vector<int> dm;

                         map<int ,int > pm;

                         pre(m,dm,pm);

                         vector<int> curd;

                         map<int,int > curp;

                         REP(i,1,(n+1)/2)

                         {

                             vector<int> td; map<int,int>tp;

                             if(i==1) {td.pb(1);tp[1]=1;}

                             else

                             {

                                 pre(n-i+1,td,tp);

                                 vector<int> tempd; map<int,int> tempp;

                                 pre(i-1,tempd,tempp);

                                 REP(j,0,tempd.size()-1)

                                 {

                                     int key=tempd[j];

                                     tp[key]-=tempp[key];

                                 }

                             }

                             map<int,int> ::iterator it;

                             for(it=tp.begin();it!=tp.end();it++)

                                 curp[it->fir]+=it->sec;

                             int ok=1;

                             for(it=pm.begin();it!=pm.end();it++)

                                 {

                                     //cout << "-----"<<it->first << endl;

                                     if(it->sec>curp[it->fir]){

//cout<<"i:"<<i<<endl;

                                      ok=0;break;}//

                                 }

                             if(ok)

                             {

                                 //cout<<"i :"<<i<<endl;

                                 ans.pb(i);

                                 if(i!=n-i+1) ans.pb(n-i+1);

                             }

                         }

                         sort(ans.begin(),ans.end());

                     }

                         cout<<ans.size()<<"\n";

                         if(!ans.empty())

                         {

                                 cout<<ans[0];

                                 REP(j,1,ans.size()-1) cout<<" "<<ans[j];

                         }

                         cout<<"\n";

                     }

                  return 0;

                }

               /*

                  note    :   组合数的大数字整除递推 C（n,k）=C(n,k-1)(n-k+1)/k，如果递推式没有除法可以直接进行余数的递推，但是这个里面的递推式中的分母是k，模是某个值m，

                                  而k,m不一定互素，所以不一定可逆。但是极端的去想：如果给的m是一个素数的话可以利用这个性质推出2 到 k-1项。

                  debug   :   pe了好几次    最后是当没有哑元的时候也要输出一个空行。

                  optimize:

                */