#include<bits/stdc++.h>
  #define ll long long
  using namespace std;
  ll n,r,br=1,endtime,maxsize=0;
//  bool dn4[100005],dn5[100005];
  struct tacka{
    int x;/**X coordinate**/
    int y;/**Y coordinate**/
    int idx;/**Initial index**/
    double avgdis;/**Average distance of a center from all the other centers**/
  }t[100005];
  bool stop;
  vector<int>v;
  void unos(){
    scanf("%lld %lld",&n,&r);
    for(int i=1;i<=n;i++){
      scanf("%d %d",&t[i].x,&t[i].y);
      t[i].idx=i;
    }
  }
   ll distanca(int x,int y,int x2,int y2){
    ll raz1=abs(x-x2);
    ll raz2=abs(y-y2);

    ll dis=((raz1*raz1)+(raz2*raz2));
    return dis;

  }
  bool CompareCentersX(tacka a,tacka b){
  return a.x<b.x;
  }

  vector<tacka>MORE;
  void NsquaredX(){
    sort(t+1,t+n+1,CompareCentersX);
    bool stop;
    MORE.push_back(t[1]);
    v.push_back(t[1].idx);
    for(int i=2;i<=n;i++){
    stop=false;
     for(int j=0;j<MORE.size();j++){
      if(distanca(t[i].x,t[i].y,MORE[j].x,MORE[j].y)<4*r*r){
        stop=true;
      }
       if(stop)break;
     }
     if(!stop){
      MORE.push_back(t[i]);
      v.push_back(t[i].idx);
     }

    }
  }


vector<tacka>MORE2;
 vector<int>v2;
bool CompareCentersY(tacka a,tacka b){
    return a.y<b.y;
}
bool CompareCentersDecreasingX(tacka a,tacka b){
return a.x>b.x;}
bool CompareCentersDecreasingY(tacka a,tacka b){
return a.y>b.y;}

void NsquaredY(){

    sort(t+1,t+n+1,CompareCentersY);
    bool stop2;
    MORE2.push_back(t[1]);
    v2.push_back(t[1].idx);
    for(int i=2;i<=n;i++){
    stop2=false;
     for(int j=0;j<MORE2.size();j++){
      if(distanca(t[i].x,t[i].y,MORE2[j].x,MORE2[j].y)<4*r*r){
        stop2=true;

       if(stop2)break;}
     }
     if(!stop2){
      MORE2.push_back(t[i]);
      v2.push_back(t[i].idx);
     }
    }
}
vector<tacka>MORE3;
vector<int>v3;
void NsquaredDecreasingX(){
    sort(t+1,t+n+1,CompareCentersDecreasingX);
    bool stop3;
    MORE3.push_back(t[1]);
    v3.push_back(t[1].idx);
    for(int i=2;i<=n;i++){
    stop3=false;
     for(int j=0;j<MORE3.size();j++){
      if(distanca(t[i].x,t[i].y,MORE3[j].x,MORE3[j].y)<4*r*r){
        stop3=true;
      }
       if(stop3)break;
     }
     if(!stop3){
      MORE3.push_back(t[i]);
      v3.push_back(t[i].idx);
     }
    }}
vector<tacka>MORE4;
vector<int>v4;
void NsquaredDecreasingY(){
 sort(t+1,t+n+1,CompareCentersDecreasingY);
    bool stop4;
    MORE4.push_back(t[1]);
    v4.push_back(t[1].idx);
//    dn4[t[1].idx]=true;
    for(int i=2;i<=n;i++){
    stop4=false;
     for(int j=0;j<MORE4.size();j++){
      if(distanca(t[i].x,t[i].y,MORE4[j].x,MORE4[j].y)<4*r*r){
        stop4=true;
      }
       if(stop4)break;
     }
     if(!stop4){
      MORE4.push_back(t[i]);
      v4.push_back(t[i].idx);
//      dn4[t[i].idx]=true;
     }

}
}
bool ReturnToIniatial(tacka a, tacka b){return a.idx<b.idx;}
vector<tacka>finale;
vector<int>findexi;
void RandShuffle(){
            vector<tacka>malci;
            vector<int>indexi;
            malci.clear();
            indexi.clear();
            malci.push_back(t[1]);
            indexi.push_back(t[1].idx);
        for(int j=2;j<=n;j++){
                bool stop=false;

                for(int k=0;k<malci.size();k++){
                    if(distanca(t[j].x,t[j].y,malci[k].x,malci[k].y)<4*r*r){
                        stop=true;

                    }
                     if(stop)break;
                }
                if(!stop){
                    malci.push_back(t[j]);
                    indexi.push_back(t[j].idx);
                }

        }
        if(malci.size()>=maxsize){
            finale.clear();
            findexi.clear();
            for(int l=0;l<malci.size();l++){
                finale.push_back(malci[l]);
                findexi.push_back(indexi[l]);
            }
            maxsize=malci.size();
                    }

}
void CalcAvgDistance(){
   for(int i=1;i<=n;i++){
      for(int j=1;j<=n;j++){
         if(i!=j){
            t[i].avgdis+=(double)sqrt(distanca(t[i].x,t[i].y,t[j].x,t[j].y));
         }
      }
      t[i].avgdis/=(n-1);
   }
}
bool CompareDistances(tacka a, tacka b){
   return a.avgdis > b.avgdis;
}
vector<tacka>ez;
vector<int>v9;
void NsquaredDistance(){
   sort(t+1,t+n+1,CompareDistances);
   ez.push_back(t[1]);
   v9.push_back(t[1].idx);
   for(int i=2;i<=n;i++){
         bool stop =false;
      for(int j=0;j<ez.size();j++){
         if(distanca(t[i].x,t[i].y,ez[j].x,ez[j].y)<4*r*r)stop=true;
         if(stop)break;
      }
   if(!stop){
      ez.push_back(t[i]);
      v9.push_back(t[i].idx);
   }
   }


}
tacka kells;
 bool CompareByDiscFrom(tacka a, tacka b){return distanca(a.x,a.y,kells.x,kells.y)>distanca(b.x,b.y,kells.x,kells.y);}
vector<tacka>gg;
vector<int>wp;
void SortByDistance(){
    sort(t+1,t+n+1,CompareCentersX);
 kells=t[1];

    sort(t+1,t+n+1,CompareByDiscFrom);
    gg.push_back(kells);
    wp.push_back(kells.idx);
    for(int i=1;i<n;i++){
        bool stop=false;
        for(int j=0;j<gg.size();j++){
            if(distanca(t[i].x,t[i].y,gg[j].x,gg[j].y)<4*r*r){stop=true;break;}
        }
        if(!stop){
            gg.push_back(t[i]);
            wp.push_back(t[i].idx);
        }
    }


}
void IspisDisc(){
printf("%d\n",gg.size());
for(int i=0;i<wp.size();i++)printf("%d ",wp[i]);
}
void ezspis(){
   printf("%d\n",ez.size());
   for(int i=0;i<v9.size();i++)printf("%d ",v9[i]);
}
void malispis(){
    printf("%d\n",finale.size());
    for(int i=0;i<findexi.size();i++)printf("%d ",findexi[i]);
}
vector<tacka>finale4;
vector<int>findexi4;
void NCubedX(){
    int maxsize=0;

    sort(t+1,t+n+1,CompareCentersX);
    for(int i=1;i<=n;i++){
            vector<tacka>malci4;
            vector<int>indexi4;
            malci4.clear();
            indexi4.clear();
            malci4.push_back(t[i]);
            indexi4.push_back(t[i].idx);
        for(int j=1;j<=n;j++){
                bool stop=false;
            if(j!=i){
                for(int k=0;k<malci4.size();k++){
                    if(distanca(t[j].x,t[j].y,malci4[k].x,malci4[k].y)<4*r*r){
                        stop=true;
                    }
                    if(stop)break;
                }
                if(!stop){
                    malci4.push_back(t[j]);
                    indexi4.push_back(t[j].idx);
                }
            }
        }
        if(malci4.size()>=maxsize){
            finale4.clear();
            findexi4.clear();
            for(int l=0;l<malci4.size();l++){
                finale4.push_back(malci4[l]);
                findexi4.push_back(indexi4[l]);
            }
            maxsize=malci4.size();
                    }
    }
}
void malispis4(){
printf("%d\n",finale4.size());
for(int i=0;i<findexi4.size();i++)printf("%d ",findexi4[i]);
}
vector<tacka>finale3;
vector<int>findexi3;
void NCubedDecreasingY(){
    int maxsize=0;

    sort(t+1,t+n+1,CompareCentersDecreasingY);
    for(int i=1;i<=n;i++){
            vector<tacka>malci3;
            vector<int>indexi3;
            malci3.clear();
            indexi3.clear();
            malci3.push_back(t[i]);
            indexi3.push_back(t[i].idx);
        for(int j=1;j<=n;j++){
                bool stop=false;
            if(j!=i){
                for(int k=0;k<malci3.size();k++){
                    if(distanca(t[j].x,t[j].y,malci3[k].x,malci3[k].y)<4*r*r){
                        stop=true;
                    }
                    if(stop)break;
                }
                if(!stop){
                    malci3.push_back(t[j]);
                    indexi3.push_back(t[j].idx);
                }
            }
        }
        if(malci3.size()>=maxsize){
            finale3.clear();
            findexi3.clear();
            for(int l=0;l<malci3.size();l++){
                finale3.push_back(malci3[l]);
                findexi3.push_back(indexi3[l]);
            }
            maxsize=malci3.size();
                    }
    }
}
void malispis3(){
    printf("%d\n",finale3.size());
    for(int i=0;i<findexi3.size();i++)printf("%d ",findexi3[i]);
}

vector<tacka>MORE5;
vector<int>v5;
void TakeTheLastX(){
 sort(t+1,t+n+1,CompareCentersX);
    bool stop5;
    MORE5.push_back(t[n]);
    v5.push_back(t[n].idx);
//    dn5[t[n].idx]=true;
    for(int i=1;i<n;i++){
    stop5=false;
     for(int j=0;j<MORE5.size();j++){
      if(distanca(t[i].x,t[i].y,MORE5[j].x,MORE5[j].y)<4*r*r){
        stop5=true;
      }
      if(stop5)break;
     }
     if(!stop5){
      MORE5.push_back(t[i]);
      v5.push_back(t[i].idx);
//      dn5[t[i].idx]=true;
     }

}
}
vector<tacka>MORE6;
vector<int>v6;
void ThirdFront(){
    sort(t+1,t+n+1,CompareCentersX);
    MORE6.push_back(t[3]);
    v6.push_back(t[3].idx);
    for(int i=1;i<=n;i++){
            bool stop=false;
        if(i==3)continue;
        for(int j=0;j<MORE6.size();j++){
            if(distanca(t[i].x,t[i].y,MORE6[j].x,MORE6[j].y)<4*r*r)stop=true;
            if(stop)break;
            }
            if(!stop){
        MORE6.push_back(t[i]);
        v6.push_back(t[i].idx);
    }
    }

}
vector<tacka>MORE10;
vector<int>v10;
void ThirdFromBehind(){
    sort(t+1,t+n+1,CompareCentersX);
    MORE10.push_back(t[n-2]);
    v10.push_back(t[n-2].idx);
    for(int i=1;i<=n;i++){
            bool stop=false;
        if(i==n-2)continue;
        for(int j=0;j<MORE10.size();j++){
            if(distanca(t[i].x,t[i].y,MORE10[j].x,MORE10[j].y)<4*r*r)stop=true;
            if(stop)break;
            }
            if(!stop){
        MORE10.push_back(t[i]);
        v10.push_back(t[i].idx);
    }
    }

}
void ispis10(){
printf("%d\n",MORE10.size());
for(int i=0;i<=v10.size();i++)printf("%d ",v10[i]);
}
void ispis5(){
     printf("%d\n",MORE5.size());
    for(int i=0;i<v5.size();i++)printf("%d ",v5[i]);
}
void ispis3(){
 printf("%d\n",MORE3.size());
    for(int i=0;i<v3.size();i++)printf("%d ",v3[i]);
}
void ispis2(){
 printf("%d\n",MORE2.size());
    for(int i=0;i<v2.size();i++)printf("%d ",v2[i]);
}
void ispis4(){
 printf("%d\n",MORE4.size());
    for(int i=0;i<v4.size();i++)printf("%d ",v4[i]);
}
  void ispis(){
    printf("%d\n",MORE.size());
    for(int i=0;i<v.size();i++)printf("%d ",v[i]);

  }
  vector<tacka>finale2;
vector<int>findexi2;
    void NCubedY(){
                int maxsize=0;
            sort(t+1,t+n+1,CompareCentersY);
            for(int i=1;i<=n;i++){
                    vector<tacka>malci2;
                    vector<int>indexi2;
                    malci2.clear();
                    indexi2.clear();
                    malci2.push_back(t[i]);
                    indexi2.push_back(t[i].idx);
                for(int j=1;j<=n;j++){
                        bool stop=false;
                    if(j!=i){
                        for(int k=0;k<malci2.size();k++){
                            if(distanca(t[j].x,t[j].y,malci2[k].x,malci2[k].y)<4*r*r){
                                stop=true;
                            }
                            if(stop)break;
                        }
                        if(!stop){
                            malci2.push_back(t[j]);
                            indexi2.push_back(t[j].idx);
                        }
                    }
                }
                if(malci2.size()>=maxsize){
                    finale2.clear();
                    findexi2.clear();
                    for(int l=0;l<malci2.size();l++){
                        finale2.push_back(malci2[l]);
                        findexi2.push_back(indexi2[l]);
                    }
                    maxsize=malci2.size();
                            }
            }
    }
    void malispis2(){
    printf("%d\n",finale2.size());
    for(int i=0;i<findexi2.size();i++)printf("%d ",findexi2[i]);
}
void ispis6(){
    printf("%d\n",MORE6.size());
    for(int i=0;i<v6.size();i++)printf("%d ",v6[i]);
}
vector<tacka>momir;
vector<int>kosovka;
void SecondToLastX(){
    sort(t+1,t+n+1,CompareCentersX);
    momir.push_back(t[n-1]);
    kosovka.push_back(t[n-1].idx);
    for(int i=1;i<=n;i++){
            bool stop=false;
        if(i==n-1)continue;
        for(int j=0;j<momir.size();j++){
            if(distanca(t[i].x,t[i].y,momir[j].x,momir[j].y)<4*r*r)stop=true;
            if(stop)break;
            }
        if(!stop){
        momir.push_back(t[i]);
        kosovka.push_back(t[i].idx);
    }
    }

}
void mispis(){
printf("%d\n",momir.size());
for(int i=0;i<kosovka.size();i++)printf("%d ",kosovka[i]);
}
vector<tacka>leri;
vector<int>lero;
void LeftRight(){
sort(t+1,t+n+1,CompareCentersX);
leri.push_back(t[1]);
lero.push_back(t[1].idx);
int l=2;
int r2=n;
int st=1;
while(l<r2){
        bool stop=false;
    if(st){
        for(int j=0;j<leri.size();j++){
            if(distanca(t[r2].x,t[r2].y,leri[j].x,leri[j].y)<4*r*r)stop=true;
            if(stop)break;
        }
        if(!stop){
            leri.push_back(t[r2]);
            lero.push_back(t[r2].idx);
        }
        st=0;
        r2--;
    }
    else {
        for(int j=0;j<leri.size();j++){
            if(distanca(t[l].x,t[l].y,leri[j].x,leri[j].y)<4*r*r)stop=true;
            if(stop)break;
        }
        if(!stop){
            leri.push_back(t[l]);
            lero.push_back(t[l].idx);
        }
        st=1;
        l++;
    }

}
}
void lrispis(){
    printf("%d\n",leri.size());
    for(int i=0;i<lero.size();i++)printf("%d ",lero[i]);
}
  int main(){
      endtime=clock()+4*CLOCKS_PER_SEC;
    freopen("mars.in","r",stdin);
    freopen("mars.out","w",stdout);
    unos();
    if(n<=100){
       while(clock()<endtime){
        random_shuffle(t+1,t+n+1);
        RandShuffle();

       }
       malispis();
       return 0;
       }

       if(n<=2500){
       NCubedY();
       NCubedDecreasingY();
       NCubedX();
       int maxina=max(finale2.size(),max(finale3.size(),finale4.size()));
        if(maxina==finale2.size())malispis2();
        else if(maxina==finale3.size())malispis3();
        else malispis4();
        return 0;
    }

    NsquaredX();
    NsquaredY();
    NsquaredDecreasingX();
    NsquaredDecreasingY();
    TakeTheLastX();
    ThirdFront();
    ThirdFromBehind();
    SecondToLastX();
    LeftRight();
    SortByDistance();
//    obraditelo();
if(n<=75000){
      CalcAvgDistance();
    NsquaredDistance();}
    int maxi=max(MORE.size(),max(MORE2.size(),max(MORE3.size(),max(MORE5.size(),max(MORE4.size(),max(MORE6.size(),max(ez.size(),max(MORE10.size(),max(leri.size(),max(momir.size(),gg.size()))))))))));
    if(maxi==MORE.size())
    ispis();
    else if(maxi==gg.size())IspisDisc();
    else if(maxi==leri.size())lrispis();
    else if(maxi==MORE2.size())ispis2();
    else if(maxi==MORE3.size())ispis3();
    else if(maxi==MORE4.size())ispis4();
    else if(maxi==MORE6.size())ispis6();
    else if(maxi==ez.size())ezspis();
    else if(maxi==MORE10.size())ispis10();
    else if (maxi==momir.size())mispis();
    else ispis5();
  return 0;
  }