#include<bits/stdc++.h>
#include<ext/pb_ds/assoc_container.hpp>
#include<ext/pb_ds/tree_policy.hpp>

#define endl '\n'
#define fi first
#define se second

using namespace std;

using namespace __gnu_pbds;

typedef tree<int,null_type,less<int>,rb_tree_tag,tree_order_statistics_node_update> ordered_set;


const int MAXN=1e5+5;

int n,r;
long long R;
pair<int,int> p[MAXN];
vector<int> adj[MAXN];
bool g[5005][5005];

int cnt[MAXN];
pair<int,int> pt[MAXN];
int id[MAXN];

set<int> poss;
ordered_set clq;
bool used[MAXN];

int bestSz=0;
vector<int> bestClq;

long long dist(pair<int,int> a,pair<int,int> b)
{
    long long dx=a.fi-b.fi;
    long long dy=a.se-b.se;
    return dx*dx+dy*dy;
}

bool intersect(int ind1,int ind2)
{
    if(dist(p[ind1], p[ind2])<R*R) return 1;
    return 0;
}

void updBest()
{
    bestSz=clq.size();
    bestClq.clear();
    for(auto x: clq) bestClq.push_back(x);
}

void clearClq()
{
    for(int i=1;i<=n;i++) used[i]=0;
    clq.clear();
    for(int i=1;i<=n;i++) poss.insert(i);
}

void addVert(int v)
{
    used[v]=1;
    clq.insert(v);
    poss.erase(v);
    for(auto u: adj[v])
    {
        if(poss.count(u)>0) poss.erase(u);
    }
}

void removeVert(int ind)
{
    auto it=clq.find_by_order(ind);
    int v=(*it);
    used[v]=0;
    clq.erase(it);
    poss.insert(v);
    for(auto u: adj[v])
    {
        bool fl=0;
        for(auto x: clq)
        {
            if(g[u][x])
            {
                fl=1;
                break;
            }
        }
        if(!fl) poss.insert(u);
    }
}


struct Point
{
    int x,y;
    int num;
};

Point p1[MAXN];
deque<int> q;
vector<int> cur;
vector<int> ans;

long long dist1(Point a,Point b)
{
    long long dx=a.x-b.x;
    long long dy=a.y-b.y;
    return dx*dx+dy*dy;
}

bool intersect1(int ind1,int ind2)
{
    if(dist1(p1[ind1], p1[ind2])<R*R) return 1;
    return 0;
}

void add(int ind)
{
    cur.push_back(p1[ind].num);
    q.push_back(ind);
}

void sort1()
{
    sort(p1+1,p1+n+1, [](Point a,Point b)
        {
            if(a.x==b.x) return a.y<b.y;
            return a.x<b.x;
        });
}

void sort2()
{
    sort(p1+1,p1+n+1, [](Point a,Point b)
        {
            if(a.x==b.x) return a.y>b.y;
            return a.x>b.x;
        });
}

int main()
{
ios::sync_with_stdio(false);
cin.tie(NULL);
cout.tie(NULL);

freopen("mars.in","r",stdin);
freopen("mars.out","w",stdout);

cin>>n>>r;
for(int i=1;i<=n;i++)
{
    cin>>p[i].fi>>p[i].se;
    p1[i].x=p[i].fi; p1[i].y=p[i].se;
    p1[i].num=i;
}
R=2*r;

if(n<=5000)
{
    for(int i=1;i<n;i++)
    {
        for(int j=i+1;j<=n;j++)
        {
            if(intersect(i,j))
            {
                cnt[i]++;
                cnt[j]++;
            }
        }
    }
    iota(id+1,id+n+1,1);
    sort(id+1,id+n+1,[](int a,int b)
         {
             return cnt[a]<cnt[b];
         });
    for(int i=1;i<=n;i++)
    {
        pt[i]=p[id[i]];
    }
    for(int i=1;i<=n;i++) p[i]=pt[i];
    for(int i=1;i<n;i++)
    {
        for(int j=i+1;j<=n;j++)
        {
            if(intersect(i,j))
            {
                adj[i].push_back(j);
                adj[j].push_back(i);
                g[i][j]=g[j][i]=1;
            }
        }
    }

    for(int i=1;i<=n;i++) poss.insert(i);
    while(!poss.empty())
    {
        addVert((*poss.begin()));
    }
    updBest();

    int ITER=16000;
    for(int i=0;i<ITER;i++)
    {
        int ind1=rand()%clq.size();
        int ind2=rand()%clq.size();
        while(ind2==ind1) ind2=rand()%clq.size();
        if(ind1>ind2) swap(ind1,ind2);
        removeVert(ind1);
        removeVert(ind2-1);

        while(!poss.empty())
        {
            addVert((*poss.begin()));
        }

        if(clq.size()>bestSz) updBest();
    }

    clearClq();
    for(auto x: bestClq) addVert(x);

    while(true)
    {
        bool fl=0;
        for(int i=0;i<bestSz;i++)
        {
            removeVert(i);
            while(!poss.empty())
            {
                addVert((*poss.begin()));
            }

            if(clq.size()>bestSz)
            {
                bestSz=clq.size();
                fl=1;
                break;
            }
        }
        if(!fl) break;
    }
    updBest();
}


for(int dr=0;dr<2;dr++)
{
    if(dr==0) sort1();
    else sort2();

    int ITER;
    if(n<=5000) ITER=n;
    else ITER=200;
    for(int ii=1;ii<=ITER;ii++)
    {
        cur.clear();
        while(!q.empty()) q.pop_front();
        add(ii);
        for(int i=ii+1;i<=n;i++)
        {
            if(!dr)
                while(!q.empty() && p1[q.front()].x<=p1[i].x-R) q.pop_front();
            else
                while(!q.empty() && p1[q.front()].x>=p1[i].x+R) q.pop_front();
            bool fl=1;
            for(int j=0;j<q.size();j++)
            {
                if(intersect1(i,q[j]))
                {
                    fl=0;
                    break;
                }
            }
            if(fl) add(i);
        }
        if(cur.size()>ans.size()) ans=cur;
    }
}

if(ans.size()>bestSz)
{
    cout<<ans.size()<<endl;
    for(auto x: ans) cout<<x<<" ";
}
else
{
    cout<<bestSz<<endl;
    for(auto x: bestClq) cout<<id[x]<<" ";
}
cout<<endl;

return 0;
}