#include <iostream>
#include <cstdio>
#include <algorithm>
#include <vector>
#include <string.h>
#include <queue>
using namespace std;
typedef int lld;

struct VRTX
{
    lld stone, dim;
};
struct STN
{
    lld x, y;
};
struct QWE
{
    lld on, dist, prev;
};

VRTX GetVrtx(lld stone, lld dim)
{
    VRTX ret;
    ret.stone = stone;
    ret.dim = dim;
    return ret;
}
STN GetStn(lld x, lld y)
{
    STN ret;
    ret.x = x; ret.y = y;
    return ret;
}
QWE GetQwe(lld on, lld dist, lld prev)
{
    QWE ret;
    ret.on = on; ret.dist = dist; ret.prev = prev;
    return ret;
}


lld n, m, p;
vector<lld> Graph[2002];
vector<STN> stone[2002];

vector<lld> on[552][552];
lld sfrom[552];

void Input(lld *beg, lld *tar)
{
    scanf("%d %d %d", &n, &m, &p);
    m *= m;

    lld bx, by, bd, tx, ty, td;

    for (lld i=1; i<=p; i++)
    {
        lld x, y, d;

        scanf("%d %d %d", &x, &y, &d);
        x++; y++; d++;

        stone[d].push_back( GetStn(x, y) );
    }

    scanf("%d %d %d", &bx, &by, &bd);
    scanf("%d %d %d", &tx, &ty, &td);
    bx++; by++; bd++; tx++; ty++; td++;

    sfrom[1] = 1;
    for (lld i=2; i<=n; i++)
    {
        sfrom[i] = sfrom[i-1] + stone[i-1].size();
    }
    for (lld i=1; i<=n; i++)
    {
        for (lld j=0; j<stone[i].size(); j++)
        {
            on[stone[i][j].x][stone[i][j].y].push_back( sfrom[i] + j );

            if (stone[i][j].x == bx && stone[i][j].y == by && i == bd)
            {
                *beg = sfrom[i] + j;
            }
            if (stone[i][j].x == tx && stone[i][j].y == ty && i == td)
            {
                *tar = sfrom[i] + j;
            }
        }
    }
}

lld eabs(lld num)
{
    if (num < 0) return -num;
    return num;
}
lld Dist(STN a, STN b)
{
    lld u1 = eabs(a.x - b.x), u2 = eabs(a.y - b.y);

    return (u1*u1 + u2*u2);
}

void ConnectGraph()
{
    for (lld i=1; i<=n; i++)
    {
        for (lld j=1; j<=n; j++)
        {
            for (lld ii=0; ii<on[i][j].size(); ii++)
            {
                for (lld jj=ii+1; jj<on[i][j].size(); jj++)
                {
                    Graph[ on[i][j][ii] ]. push_back( on[i][j][jj] );
                    Graph[ on[i][j][jj] ]. push_back( on[i][j][ii] );
                }
            }
        }
    }

    for (lld i=1; i<=n; i++) /// dims
    {
        for (lld ii=0; ii<stone[i].size(); ii++)
        {
            for (lld jj=ii+1; jj<stone[i].size(); jj++)
            {
                if (Dist(stone[i][ii], stone[i][jj]) > m) continue;

                Graph[ sfrom[i]+ii ].push_back( sfrom[i]+jj );
                Graph[ sfrom[i]+jj ].push_back( sfrom[i]+ii );
            }
        }
    }
}

vector < QWE > q;
vector<lld> path;
bool TFO[2002];

lld GetPath(lld from, lld to)
{
    QWE cur, hpr;
    lld indr=0;

    q.push_back( GetQwe(from, 1, -1) );
    TFO[from] = true;

    while (indr < q.size())
    {
        cur = q[indr];
        indr++;

        if (cur.on == to)
        {
            lld sv = cur.dist;
            while (true)
            {
                path.push_back(cur.on);
                if (cur.prev == -1) break;
                cur = q[cur.prev];
            }

            reverse(path.begin(), path.end());

            return sv;
        }

        for (lld i=0; i<Graph[cur.on].size(); i++)
        {
            if (TFO[Graph[cur.on][i]]) continue;

            TFO[Graph[cur.on][i]] = true;
            q.push_back( GetQwe(Graph[cur.on][i], cur.dist+1, indr-1) );
        }
    }

    return 0;
}

void Print(lld st)
{
    lld l=1, r=n, mid;
    lld last=-1;

    while (l <= r)
    {
        mid = (l+r)/2;

        if (sfrom[mid] > st)
        {
            r = mid-1;
            continue;
        }

        last = mid;
        l = mid+1;
    }

    if (last == -1)
    {
        cout<<5/0;
        return;
    }

    lld from = sfrom[last];
    printf("%d %d %d\n", stone[last][st-from].x-1, stone[last][st-from].y-1, last-1);
}

int main ()
{
    freopen("dimensions.in", "r", stdin);
    freopen("dimensions.out", "w", stdout);

    lld beg, tar, ans;

    Input(&beg, &tar);
    ConnectGraph();
    ans = GetPath(beg, tar);

    printf("%d\n", ans);
    if (ans == 0) return 0;

    for (lld i=0; i<path.size(); i++)
    {
        Print(path[i]);
    }
}