/* Cell Towers, MCPC 2009 Problem I, by Gabriel Foust
 *
 * Check each mile post to see which is the strongest tower
 * Report each time it changes
 */

#include <cmath>
#include <fstream>
#include <iostream>
#include <limits>
using namespace std;

ifstream fin( "cell.in" );

struct Point
{
    double x, y;
    Point() :
        x( 0 ), y( 0 )
    {
    }
    Point( double x, double y ) :
        x( x ), y( y )
    {
    }
};

int T;
Point towers[10];
double powers[10];
int R;
Point roads[11];

double ptDistance( Point p, Point q )
{
    double d1= p.x - q.x;
    double d2= p.y - q.y;
    return sqrt( d1 * d1 + d2 * d2 );
}

int dataset= 0;
bool getDataSet()
{
    fin >> T;
    if (T <= 0)
        return false;
    fin >> R;

    for (int i= 0; i < T; i++)
        fin >> towers[i].x >> towers[i].y >> powers[i];

    for (int i= 0; i < R + 1; i++)
        fin >> roads[i].x >> roads[i].y;

    cerr << "Data Set " << ++dataset << endl;
    return true;
}

int towerForPoint( Point p )
{
    int tower= 0;
    double d= ptDistance( towers[0], p );
    double realS= powers[0] / d / d;
    int s= round( realS );
    int strength= s;

    // realStrength at nextStrength are only used to keep track of the difference
    // between the winner and the runner up - wanted to watch out for close calls
    // Not relevant to the solution
    double realStrength= realS;
    double nextStrength= -1e6;

    for (int t= 1; t < T; t++)
    {
        d= ptDistance( towers[t], p );
        realS= powers[t] / d / d;
        s= round( realS );
        if (s == strength)
        {
            if (t < tower)
            {
                tower= t;
                strength= s;
            }

            if (round( realStrength ) == round( nextStrength ))
            {
                if (realS > realStrength)
                    realStrength= realS;
                else if (realS < nextStrength)
                    nextStrength= realS;
            }
            else
            {
                if (realS > realStrength)
                {
                    nextStrength= realStrength;
                    realStrength= realS;
                }
                else
                {
                    nextStrength= realS;
                }
            }
        }
        else if (s > strength)
        {
            tower= t;
            strength= s;
            nextStrength= realStrength;
            realStrength= realS;
        }
        else if (realS > nextStrength)
        {
            nextStrength= realS;
        }
    }

    double realDiff= realStrength - nextStrength;
    if (realDiff < 2.5 && realDiff > 0.1)
    {
        cerr << '(' << p.x << ',' << p.y << ") = " << realStrength << " vs. " << nextStrength << endl;
    }

    return tower;
}

void tracePath()
{
    int tower= towerForPoint( roads[0] );
    cout << "(0," << (char)('A' + tower) << ")";

    int mile= 0;
    double distance= 0;

    for (int r= 0; r < R; r++)
    {
        double length= ptDistance( roads[r], roads[r + 1] );
        double dx= roads[r + 1].x - roads[r].x;
        double dy= roads[r + 1].y - roads[r].y;

        while (distance < length)
        {
            Point p;
            if (dx == 0)
            {
                p.x= roads[r].x;
                p.y= roads[r].y + (dy >= 0 ? distance : -distance);
            }
            else if (dy == 0)
            {
                p.x= roads[r].x + (dx >= 0 ? distance : -distance);
                p.y= roads[r].y;
            }
            else
            {
                double m= fabs( dx / dy );

                double yside= sqrt( distance * distance / (m * m + 1) );
                double xside= m * yside;

                p.x= roads[r].x + (dx >= 0 ? xside : -xside);
                p.y= roads[r].y + (dy >= 0 ? yside : -yside);
            }

            int t= towerForPoint( p );
            if (t != tower)
            {
                tower= t;
                cout << " (" << mile << "," << (char)('A' + tower) << ")";
            }

            mile++;
            distance++;
        }

        distance-= length;
    }

    if (distance < .5)
    {
        int t= towerForPoint( roads[R] );
        if (t != tower)
        {
            tower= t;
            cout << " (" << mile << "," << (char)('A' + tower) << ")";
        }
    }

    cout << endl;
}

int main()
{
    while (getDataSet())
        tracePath();
    return 0;
}