#include <stdio.h>
#include <cmath>
#include <algorithm>
#include <stack>
 
using namespace std;
 
struct Point{
    double x,y;
};
 
int main(){
 
    int n,m,checkTable[101],path[101],id,start,goal,count,min_index;
    double distance[101][101],x,y,calc[101][101],min_value;
    bool canGO[101];
    Point table[101];
    stack<int> S;
 
    while(true){
        scanf("%d",&n);
        if(n == 0)break;
 
        for(int i=1; i <= n; i++){
            scanf("%d %lf %lf",&id,&x,&y);
            table[id].x = x;
            table[id].y = y;
        }
 
        for(int i = 1; i <= n; i++){
            for(int k = 1; k <= n; k++){
                distance[i][k] = sqrt((table[i].x-table[k].x)*(table[i].x-table[k].x)+(table[i].y-table[k].y)*(table[i].y-table[k].y));
            }
        }
 
        scanf("%d",&m);
 
        for(int i = 1; i <= m; i++){
            scanf("%d %d",&start,&goal);
 
            for(int k = 1; k <= n; k++){
                checkTable[k] = 0;
                if(distance[start][k] < 50 || fabs(distance[start][k] - 50) < 0.00000001){
                    canGO[k] = true;
                }else{
                    canGO[k] = false;
                }
                path[k] = start;
                for(int p = 1; p <= n; p++)calc[k][p] = distance[k][p];
            }
 
            count = 1;
            checkTable[start] = 1;
 
            while(count < n){
                min_value = 1000000000;
 
                for(int k = 1; k <= n; k++){
                    if(checkTable[k] == 0 && canGO[k] == true && calc[start][k] < min_value){
                        min_value = calc[start][k];
                        min_index = k;
                    }
                }
 
                if(min_value == 1000000000)break;
 
                checkTable[min_index] = 1;
                count++;
 
                for(int p = 1; p <= n; p++){
                    if((canGO[p] == false || calc[start][p] > calc[start][min_index]+calc[min_index][p]) && (distance[min_index][p] < 50 || fabs(distance[min_index][p] - 50) < 0.00000001)){
                        calc[start][p] = calc[start][min_index]+calc[min_index][p];
                        canGO[p] = true;
                        path[p] = min_index;
                    }
                }
            }
 
            if(canGO[goal] == false)printf("NA\n");
            else{
                int t = goal;
                while(true){
                    S.push(t);
                    t = path[t];
                    if(t == start)break;
                }
                printf("%d",start);
                while(!S.empty()){
                    printf(" %d",S.top());
                    S.pop();
                }
                printf("\n");
            }
        }
    }
 
 
    return 0;
}
