#include <bits/stdc++.h>
typedef long long ll;
typedef long double ld;
using namespace std;
typedef pair<ld,ll> kaugusJaIndeks;

/**
Klass, mis hoiab kõiki sisendi raadiusega ringe, kusjuures Delta ja Kaarsild on raadiusega 0
*/
struct Ring {
    ll x,y,r;
    string nimi;
    Ring(ll x,ll y,ll r,string nimi):x(x),y(y),r(r),nimi(nimi){}
};

/**
Funktsioon kahe ringi vahelise kauguse arvutamiseks
*/
ld ringideKaugus(const Ring& A, const Ring& B){
    ld dx = A.x - B.x;
    ld dy = A.y - B.y;
    ld d = sqrt(dx*dx + dy*dy) - (A.r + B.r);
    return max(d, (ld)0);
}

/**
Lahendusfunktsioon põhineb Dijkstra algoritmil
*/
vector<pair<Ring,Ring>> luhimTee(const vector<Ring>& punktid,int algus,int lopp){
    int N=punktid.size();

    vector<ld>kaugusAlgusest(N,numeric_limits<ld>::max());//Hoiame meeles iga punkti jooksvat kaugust alguspunktist
    kaugusAlgusest[algus]=0;//alguspunkti kaugus endast on 0

    vector<int>eelmineTippTeekonnal(N,-1);
    //Lõpus lühima teekonna väljastamiseks hoiame jooksvalt meeles, mis punktist me igasse punkti liikusime,
    //oluline on just vahetult eelnev punkt

    priority_queue<kaugusJaIndeks,vector<kaugusJaIndeks>,greater<kaugusJaIndeks>>pq;
    //Dijkstra algoritmi töövoogu hoiame priority_queue's, mis tagastab meile igal sammul alguspunktile lähima punkti
    pq.push({0,algus});//Algtipu kohta on kohe teada, et ta on kaugusel 0

    while(!pq.empty()){
        auto vahim=pq.top();pq.pop();//leiame alguspunktile lähima punkti
        int U=vahim.second;//see on tema indeks punktide vektoris

        if(vahim.first != kaugusAlgusest[U])//Selleks hetkeks on tipu kaugus algusest juba lõplikult kindel,
                                            //kuid queues võib olla ka suurema kaugusega selle punkti esitusi mida ignoreerime
            continue;

        for(int V=0;V<N;V++){//Vaatame läbi kõik ülejäänud punktid
            ld kaugusUV = ringideKaugus(punktid[U],punktid[V]);//Kui kaugel on punktid U ja V üksteisest

            if(kaugusAlgusest[U]+kaugusUV<kaugusAlgusest[V]){//Kas teekond algusest puntki V saaks lühem,
                                                             //kui läheksime lühimat teed mööda algusest puntki U ja sealt otse punkti V
                kaugusAlgusest[V]=kaugusAlgusest[U]+kaugusUV;//Jah, uuendame kaugust
                eelmineTippTeekonnal[V]=U;                   //Tulime tipust U
                pq.push({kaugusAlgusest[V],V});              //Lisame uuenduse töövoogu
            }
        }
    }

    vector<pair<Ring,Ring>> vastus;

    while(eelmineTippTeekonnal[lopp]!=-1){//Liigume samm-sammult lõpp-punktist algusesse ja lisame vihma käes olekud vastusesse
        int U=eelmineTippTeekonnal[lopp],V=lopp;
        ld kaugusUV=ringideKaugus(punktid[U],punktid[V]);
        if(kaugusUV != 0){//Olime vihma käes, järelikult lisame lõigu vastusesse
            vastus.push_back({punktid[U],punktid[V]});
        }
        lopp=eelmineTippTeekonnal[lopp];
    }
    reverse(vastus.begin(),vastus.end());//Liikusime tsükliga lõpust algusesse, seega pöörame vastuse ümber ja tagastame selle
    return vastus;
}
int main()
{ios_base::sync_with_stdio(0);cin.tie(0);cout.tie(0);
    vector<Ring>ringid;//Salvestame kõik sisend punktid ühte vektorisse

    ll x,y;
    cin>>x>>y;
    ringid.push_back(Ring(x,y,0,"Kaarsild"));//Kaarsild ja Delta on meie vaates raadiusega 0 ringid
    cin>>x>>y;
    ringid.push_back(Ring(x,y,0,"Delta"));//Lisame mõlemad vektori algussse

    int N;
    cin>>N;
    for(int i=1;i<=N;i++){//Seejärel loeme sisendist puuvõrad ehk ülejäänud ringid
        ll x,y,r;
        cin>>x>>y>>r;
        ringid.push_back(Ring(x,y,r,to_string(i)));
    }

    auto vastus=luhimTee(ringid,0,1);//Leiame lühima tee ja väljastame selle lõikude kaupa
    cout<<vastus.size()<<endl;
    for(auto loik:vastus){
        cout<<loik.first.nimi<<" "<<loik.second.nimi<<endl;
    }
    return 0;
}
