/*
ID: espr1t
TASK: 
KEYWORDS: 
*/

#include <cstdio>
#include <cstring>
#include <algorithm>
#include <queue>
#include <vector>
#include <cmath>

using namespace std;
FILE *in; FILE *out;

const int MAX = 1024;
const int INF = 1000000001;

struct Point {
    int idx;
    int x, y, z;
    bool operator == (const Point& r) const {
        return x == r.x && y == r.y && z == r.z;
    }
};

struct Edge {
    int to;
    double price;
    Edge(int to_ = 0, double price_ = 0.0) : to(to_), price(price_) {}
    bool operator < (const Edge& r) const {
        return price > r.price;
    }
};

int findDist(const Point& p1, const Point& p2) {
    if (p1.z != p2.z) {
        if (p1.x == p2.x && p1.y == p2.y)
            return 1;
        return INF;
    }
    return (p1.x - p2.x) * (p1.x - p2.x) + (p1.y - p2.y) * (p1.y - p2.y);
}

int n, s, d;
Point a[MAX];
vector <Edge> v[MAX];
double dist[MAX]; int prv[MAX]; bool vis[MAX];

void dijkstra(int origin, int destination) {
    if (origin == -1 || destination == -1) {
        fprintf(out, "0\n");
        return;
    }

    for (int i = 0; i < n; i++)
        dist[i] = INF, prv[i] = -1, vis[i] = false;

    dist[origin] = 0.0;
    priority_queue <Edge> q;
    q.push(Edge(origin, 0.0));

    while (!q.empty()) {
        int node = q.top().to; q.pop();
        if (node == destination)
            break;
        if (vis[node])
            continue;
        vis[node] = true;
        
        for (int i = 0; i < (int)v[node].size(); i++) if (!vis[v[node][i].to]) {
            double price = dist[node] + v[node][i].price;
            if (dist[v[node][i].to] > price) {
                dist[v[node][i].to] = price;
                prv[v[node][i].to] = node;
                q.push(Edge(v[node][i].to, price));
            }
        }
    }

    if (dist[destination] >= INF) {
        fprintf(out, "0\n");
        return;
    }
    
    vector <int> ans;
    for (int node = destination; node != -1; node = prv[node]) {
        ans.push_back(node);
    }
    reverse(ans.begin(), ans.end());
    fprintf(out, "%d\n", (int)ans.size());
    for (int i = 0; i < (int)ans.size(); i++)
        fprintf(out, "%d %d %d\n", a[ans[i]].x, a[ans[i]].y, a[ans[i]].z);
}

int main(void) {
	in = stdin; out = stdout;
	in = fopen("dimensions.in", "rt"); out = fopen("dimensions.out", "wt");
	
	fscanf(in, "%d %d %d", &s, &d, &n);
	for (int i = 0; i < n; i++) {
	    a[i].idx = i;
	    fscanf(in, "%d %d %d", &a[i].x, &a[i].y, &a[i].z);
	}
	Point origin, destination;
	fscanf(in, "%d %d %d", &origin.x, &origin.y, &origin.z);
	fscanf(in, "%d %d %d", &destination.x, &destination.y, &destination.z);
	
	int origIdx = -1, destIdx = -1;
	for (int i = 0; i < n; i++) {
	    if (a[i] == origin)
	        origIdx = i;
	    if (a[i] == destination)
	        destIdx = i;

	    for (int c = i + 1; c < n; c++) {
	        if (findDist(a[i], a[c]) <= d * d) {
	            double dist = sqrt((double)findDist(a[i], a[c]));
	            v[i].push_back(Edge(c, dist));
	            v[c].push_back(Edge(i, dist));
	        }
	    }
	}
	
	dijkstra(origIdx, destIdx);
	
	return 0;
}