小园丁 Mr. S 负责看管一片田野，田野可以看作一个二维平面。田野上有 nn 棵许愿树，编号 1,2,3,…,n1,2,3,…,n，每棵树可以看作平面上的一个点，其中第 ii 棵树 （1≤i≤n1≤i≤n） 位于坐标 (xi,yi)(xi,yi)。任意两棵树的坐标均不相同。

　　老司机 Mr. P 从原点 (0,0)(0,0) 驾车出发，进行若干轮行动。每一轮，Mr. P 首先选择任意一个满足以下条件的方向：

　　为左、右、上、左上 45∘45∘ 、右上 45∘45∘ 五个方向之一。

　　沿此方向前进可以到达一棵他尚未许愿过的树。

　　完成选择后，Mr. P 沿该方向直线前进，必须到达该方向上距离最近的尚未许愿的树，在树下许愿并继续下一轮行动。如果没有满足条件的方向可供选择，则停止行动。他会采取最优策略，在尽可能多的树下许愿。若最优策略不唯一，可以选择任意一种。

　　不幸的是，小园丁 Mr. S 发现由于田野土质松软，老司机 Mr. P 的小汽车在每轮行进过程中，都会在田野上留下一条车辙印，一条车辙印可看作以两棵树（或原点和一棵树）为端点的一条线段。

　　在 Mr. P 之后，还有很多许愿者计划驾车来田野许愿，这些许愿者都会像 Mr. P 一样任选一种最优策略行动。Mr. S 认为非左右方向（即上、左上 45∘45∘ 、右上 45∘45∘ 三个方向）的车辙印很不美观，为了维护田野的形象，他打算租用一些轧路机，在这群许愿者到来之前夯实所有“可能留下非左右方向车辙印”的地面。

　　“可能留下非左右方向车辙印”的地面应当是田野上的若干条线段，其中每条线段都包含在某一种最优策略的行进路线中。每台轧路机都采取满足以下三个条件的工作模式：

　　从原点或任意一棵树出发。

　　只能向上、左上 45∘45∘ 、右上 45∘45∘ 三个方向之一移动，并且只能在树下改变方向或停止。

　　只能经过“可能留下非左右方向车辙印”的地面，但是同一块地面可以被多台轧路机经过。

　　现在 Mr. P 和 Mr. S 分别向你提出了一个问题:

　　请给 Mr .P 指出任意一条最优路线。

　　请告诉 Mr. S 最少需要租用多少台轧路机。

　　接下来 n 行，第 i+1 行包含 2个整数 xi,yi，中间用单个空格隔开，表示第 i 棵许愿树的坐标。

　　输出文件包括 3 行。

　　输出文件的第 1 行输出 1 个整数 m，表示 Mr. P 最多能在多少棵树下许愿。

　　输出文件的第 2 行输出 m 个整数，相邻整数之间用单个空格隔开，表示 Mr. P 应该依次在哪些树下许愿。

　　输出文件的第 3 行输出 1 个整数，表示 Mr. S 最少需要租用多少台轧路机。

#include<cstdio>

#include<cstring>

#include<algorithm>

#include<vector>

using namespace std;

inline int read()

{

    int x,f=;char c;

    while((c=getchar())<''||c>'')if(c=='-')f=;

    for(x=c-'';(c=getchar())>=''&&c<='';)x=x*+c-'';

    return f?x:-x;

}

#define MN 50000

#define MV 50002

#define ME 250000

#define S MV+1

#define T MV+2

#define INF 0x3FFFFFFF

struct node{int x,y,id;}p[MN+];

bool cmp1(const node&a,const node&b){return a.x+a.y==b.x+b.y?a.y<b.y:a.x+a.y<b.x+b.y;}

bool cmp2(const node&a,const node&b){return a.x-a.y==b.x-b.y?a.y<b.y:a.x-a.y<b.x-b.y;}

bool cmp3(const node&a,const node&b){return a.x==b.x?a.y<b.y:a.x<b.x;}

bool cmp4(const node&a,const node&b){return a.y==b.y?a.x<b.x:a.y<b.y;}

int s[MN+],t1[MN+],t2[MN+],t3[MN+],l[MN+],r[MN+],f[MN+],ff[MN+],lf[MN+],rf[MN+],a[MN+],an;

vector<int> v,t[MN+];

namespace maxFlow

{

    struct edge{int nx,t,w;}e[ME*+];

    int h[MV+],en=,d[MV+],c[MV+],q[MV+],qn;

    inline void ins(int x,int y,int w)

    {

        e[++en]=(edge){h[x],y,w};h[x]=en;

        e[++en]=(edge){h[y],x,};h[y]=en;

    }

    bool bfs()

    {

        int i,j;

        memset(d,,sizeof(d));

        for(d[q[i=qn=]=S]=;i<=qn;++i)for(j=c[q[i]]=h[q[i]];j;j=e[j].nx)

            if(e[j].w&&!d[e[j].t])d[q[++qn]=e[j].t]=d[q[i]]+;

        return d[T];

    }

    int dfs(int x,int r)

    {

        if(x==T)return r;

        int k,u=;

        for(int&i=c[x];i;i=e[i].nx)if(e[i].w&&d[e[i].t]==d[x]+)

        {

            k=dfs(e[i].t,min(e[i].w,r-u));

            u+=k;e[i].w-=k;e[i^].w+=k;

            if(u==r)return u;

        }

        return d[x]=,u;

    }

    int dinic(){int res=;while(bfs())res+=dfs(S,INF);return res;}

}

void upd(int x,int y)

{

    if(ff[y]+>f[x])f[x]=ff[y]+,t[x].clear();

    if(ff[y]+==f[x])t[x].push_back(y);

}

void get_ans(int x)

{

    a[++an]=x;

    int i,j,u=;

    if(f[x]==ff[x]){u=;if(p[x].id)get_ans(t[x][]);}

    for(i=l[x];u&&i<x;++i)if(f[i]+x-l[x]==ff[x])

    {

        u=;

        for(j=x;--j>i;)a[++an]=j;

        for(j=l[x];j<=i;++j)a[++an]=j;

        if(p[i].id)get_ans(t[i][]);

    }

    for(i=r[x];u&&i>x;--i)if(f[i]+r[x]-x==ff[x])

    {

        u=;

        for(j=x;++j<i;)a[++an]=j;

        for(j=r[x];j>=i;--j)a[++an]=j;

        if(p[i].id)get_ans(t[i][]);

    }

}

int d[MN+],u[MN+],c[MN+];

inline void ins(int x,int y){maxFlow::ins(x,y,INF);++c[x];--c[y];}

void dfs(int x)

{

    if(d[x])return;

    int i,j;d[x]=;

    if(f[x]==ff[x]&&!u[x])for(u[x]=,i=;i<t[x].size();++i)ins(t[x][i],x),dfs(t[x][i]);

    for(i=l[x];i<x;++i)if(f[i]+x-l[x]==ff[x]&&!u[i])for(u[i]=,j=;j<t[i].size();++j)ins(t[i][j],i),dfs(t[i][j]);

    for(i=r[x];i>x;--i)if(f[i]+r[x]-x==ff[x]&&!u[i])for(u[i]=,j=;j<t[i].size();++j)ins(t[i][j],i),dfs(t[i][j]);

}

int main()

{

    int n=read(),i,j,ans=;

    for(i=;i<=n;++i)p[i].x=read(),p[i].y=read(),p[i].id=i;

    sort(p,p+n+,cmp1);

    for(i=;i<n;++i)if(p[i].x+p[i].y==p[i+].x+p[i+].y)t1[p[i].id]=p[i+].id;

    sort(p,p+n+,cmp2);

    for(i=;i<n;++i)if(p[i].x-p[i].y==p[i+].x-p[i+].y)t2[p[i].id]=p[i+].id;

    sort(p,p+n+,cmp3);

    for(i=;i<n;++i)if(p[i].x==p[i+].x)t3[p[i].id]=p[i+].id;

    sort(p,p+n+,cmp4);

    for(i=;i<=n;++i)s[p[i].id]=i;

    memset(f,,sizeof(f));f[s[]]=;

    for(i=;i<=n;i=r[i]+)

    {

        for(l[i]=r[i]=i;r[i]<n&&p[r[i]+].y==p[r[i]].y;++r[i]);

        for(j=l[i];++j<=r[i];)l[j]=l[i],r[j]=r[i];

        for(lf[l[i]]=-INF,j=l[i];++j<=r[i];)lf[j]=max(lf[j-],f[j-]);

        for(rf[r[i]]=-INF,j=r[i];--j>=l[i];)rf[j]=max(rf[j+],f[j+]);

        for(j=l[i];j<=r[i];++j)

        {

            ff[j]=max(f[j],max(lf[j]+j-l[i],rf[j]+r[i]-j));

            if(t1[p[j].id])upd(s[t1[p[j].id]],j);

            if(t2[p[j].id])upd(s[t2[p[j].id]],j);

            if(t3[p[j].id])upd(s[t3[p[j].id]],j);

            if(ff[j]>ans)ans=ff[j],v.clear();

            if(ff[j]==ans)v.push_back(j);

        }

    }

    printf("%d\n",ans);

    get_ans(v[]);

    for(i=an;--i;)printf("%d ",p[a[i]].id);puts("");

    for(i=;i<v.size();++i)dfs(v[i]);

    for(i=;i<=n;++i)

    {

        if(c[i]<)maxFlow::ins(S,i,-c[i]);else maxFlow::ins(i,T,c[i]);

        maxFlow::ins(MN+,i,INF);maxFlow::ins(i,MN+,INF);

    }

    maxFlow::dinic();

    maxFlow::ins(MN+,MN+,INF);

    printf("%d",maxFlow::dinic());

}