#include <bits/stdc++.h>
using namespace std;

const int Maxn = 125;
const int N = 102;
const int dx[4] = {0, 0, 1, -1};
const int dy[4] = {1, -1, 0, 0};

struct node{
    int x, y;
    bool operator != (const node p){
        return x != p.x || y != p.y;
    }
} crs[Maxn], S, T;

int n, t;

int encoder(int x, int y){
    return x * N + y;
}
int encoder(node x){
    return encoder(x.x, x.y);
}
node decoder(int id){
    int x = id / N;
    int y = id - x * N;
    return (node) {x, y};
}

double sqr(int x){ return x * x; }
double getEdis(node A, node B){
    return sqrt(sqr(A.x - B.x) + sqr(A.y - B.y));
}

struct Dijkstra{
#define MaxN    50050
#define MaxM    8000500
    struct Qnode{
        int u, d;
        bool operator < (const Qnode p)const {
            return d < p.d;
        }
        bool operator > (const Qnode p)const {
            return d > p.d;
        }
    };
    priority_queue <Qnode, vector<Qnode>, greater<Qnode> > que;
    struct Edge{
        int v, w, eid, next;
    } edge[MaxM << 1];
    int first[MaxN], dis[MaxN], frm[MaxN], fwhich[MaxN], Top;
    void init(){
        Top = 1;
        memset(first, 0, sizeof first);
    }
    void add(int u, int v, int w, int eid = 0){
        edge[++Top] = (Edge) {v, w, eid, first[u]};
        first[u] = Top;
    }
    int dijkstra(int S, int T){
        memset(dis, 63, sizeof dis);
        while (que.size()) que.pop();
        dis[S] = 0, que.push((Qnode) {S, 0});
        while (que.size()){
            int u = que.top().u, d = que.top().d; que.pop();
            if (d > dis[u]) continue;
            for (int i = first[u]; i; i = edge[i].next){
                int v = edge[i].v, w = edge[i].w, eid = edge[i].eid;
                if (dis[v] == -1 || d + w < dis[v]){
                    dis[v] = d + w;
                    frm[v] = u;
                    fwhich[v] = eid;
                    que.push((Qnode) {v, dis[v]});
                }
            }
        }
        return dis[T];
    }
} G;

void build(){
    G.init();
    for (int i = 0; i <= 100; i++)
        for (int j = 0; j <= 100; j++)
            for (int k = 0; k < 4; k++){
                int tx = i + dx[k];
                int ty = j + dy[k];
                if (tx < 0 || ty < 0 || tx > 100 || ty > 100)
                    continue;
                G.add(encoder(i, j), encoder(tx, ty), 1);
            }
    for (int id = 1; id <= n; id++){
        int x = crs[id].x, y = crs[id].y;
        vector <int> vec; vec.clear();
        vec.push_back(encoder(x, y));
        for (int i = 0; i <= 100; i++){
            if (i != x) vec.push_back(encoder(i, y));
            if (i != y) vec.push_back(encoder(x, i));
        }
        for (int i = 0, si = vec.size(); i < si; i++)
            for (int j = i + 1; j < si; j++){
                G.add(vec[i], vec[j], t, id);
                G.add(vec[j], vec[i], t, id);
            }
    }
}

int main(){
    ios :: sync_with_stdio(false), cin.tie(0);
    cin >> n >> t;
    cin >> S.x >> S.y >> T.x >> T.y;
    for (int i = 1; i <= n; i++)
        cin >> crs[i].x >> crs[i].y;
    build();
    double dis1 = G.dijkstra(encoder(S), encoder(T));
    double dis2 = getEdis(S, T); 
    if (dis1 < dis2){
        cout << fixed << setprecision(10) << dis1 << endl;
        vector <node> ansnode; ansnode.clear();
        vector <int> ansedge; ansedge.clear();
        for (node cur = T; cur != S; cur = decoder(G.frm[encoder(cur)])){
            ansnode.push_back(cur);
            ansedge.push_back(G.fwhich[encoder(cur)]);
        }
        reverse(ansnode.begin(), ansnode.end());
        reverse(ansedge.begin(), ansedge.end());
        cout << ansnode.size() << endl;
        for (int i = 0, si = ansnode.size(); i < si; i++)
            cout << ansedge[i] << ' ' << ansnode[i].x << ' ' << ansnode[i].y << endl;
    } else {
        cout << fixed << setprecision(10) << dis2 << endl;
        cout << 1 << endl;
        cout << "0 " << T.x << ' ' << T.y << endl;
    }
    return 0;
}