Problem: Taro got a driver’s license with a great effort in his campus days, but unfortunately there had been no opportunities for him to drive. He ended up obtaining a gold license.

One day, he and his friends made a plan to go on a trip to Kyoto with you. At the end of their meeting, they agreed to go around by car, but there was a big problem; none of his friends was able to drive a car. Thus he had no choice but to become the driver.

The day of our departure has come. He is going to drive but would never turn to the right for fear of crossing an opposite lane (note that cars keep left in Japan). Furthermore, he cannot U-turn for the lack of his technique. The car is equipped with a car navigation system, but the system cannot search for a route without right turns. So he asked to you: “I hate right turns, so, could you write a program to find the shortest left-turn-only route to the destination, using the road map taken from this navigation system?”



Input

The input consists of multiple data sets. The first line of the input contains the number of data sets. Each data set is described in the format below:


m n
name1 x1 y1
...
namem xm ym
p1 q1
...
pn qn
src dst


m is the number of intersections. n is the number of roads. namei is the name of the i-th intersection. (xi, yi) are the integer coordinates of the i-th intersection, where the positive x goes to the east, and the positive y goes to the north. pj and qj are the intersection names that represent the endpoints of the j-th road. All roads are bidirectional and either vertical or horizontal. src and dst are the names of the source and destination intersections, respectively.

You may assume all of the followings:

* 2 ≤ m ≤ 1000, 0 ≤ xi ≤ 10000, and 0 ≤ yi ≤ 10000;
* each intersection name is a sequence of one or more alphabetical characters at most 25 character long;
* no intersections share the same coordinates;
* no pair of roads have common points other than their endpoints;
* no road has intersections in the middle;
* no pair of intersections has more than one road;
* Taro can start the car in any direction; and
* the source and destination intersections are different.



Note that there may be a case that an intersection is connected to less than three roads in the input data; the rode map may not include smaller roads which are not appropriate for the non-local people. In such a case, you still have to consider them as intersections when you go them through.

Output

For each data set, print how many times at least Taro needs to pass intersections when he drive the route of the shortest distance without right turns. The source and destination intersections must be considered as “passed” (thus should be counted) when Taro starts from the source or arrives at the destination. Also note that there may be more than one shortest route possible.

Print “impossible” if there is no route to the destination without right turns.

Example

Input

2 1
KarasumaKitaoji 0 6150
KarasumaNanajo 0 0
KarasumaNanajo KarasumaKitaoji
KarasumaKitaoji KarasumaNanajo
3 2
KujoOmiya 0 0
KujoAburanokoji 400 0
OmiyaNanajo 0 1150
KujoOmiya KujoAburanokoji
KujoOmiya OmiyaNanajo
KujoAburanokoji OmiyaNanajo
10 12
KarasumaGojo 745 0
HorikawaShijo 0 870
ShijoKarasuma 745 870
ShijoKawaramachi 1645 870
HorikawaOike 0 1700
KarasumaOike 745 1700
KawaramachiOike 1645 1700
KawabataOike 1945 1700
KarasumaMarutamachi 745 2445
KawaramachiMarutamachi 1645 2445
KarasumaGojo ShijoKarasuma
HorikawaShijo ShijoKarasuma
ShijoKarasuma ShijoKawaramachi
HorikawaShijo HorikawaOike
ShijoKarasuma KarasumaOike
ShijoKawaramachi KawaramachiOike
HorikawaOike KarasumaOike
KarasumaOike KawaramachiOike
KawaramachiOike KawabataOike
KarasumaOike KarasumaMarutamachi
KawaramachiOike KawaramachiMarutamachi
KarasumaMarutamachi KawaramachiMarutamachi
KarasumaGojo KawabataOike
8 9
NishikojiNanajo 0 0
NishiojiNanajo 750 0
NishikojiGojo 0 800
NishiojiGojo 750 800
HorikawaGojo 2550 800
NishiojiShijo 750 1700
Enmachi 750 3250
HorikawaMarutamachi 2550 3250
NishikojiNanajo NishiojiNanajo
NishikojiNanajo NishikojiGojo
NishiojiNanajo NishiojiGojo
NishikojiGojo NishiojiGojo
NishiojiGojo HorikawaGojo
NishiojiGojo NishiojiShijo
HorikawaGojo HorikawaMarutamachi
NishiojiShijo Enmachi
Enmachi HorikawaMarutamachi
HorikawaGojo NishiojiShijo
0 0


Output

2
impossible
13
4

Solution (in CPP):

Solution:
#include <iostream>
#include <algorithm>
#include <vector>
#include <queue>
#include <cstring>
#include <map>
#include <string>
using namespace std;

const int INF = 1<<29;

typedef pair<int,int> P;

class State{
public:
  int cost,node,x,y,dir,now;

  State(int c, int n, int _x, int _y, int d, int n2){
    cost = c;
    node = n;
    x = _x;
    y = _y;
    dir = d;
    now = n2;
  }

  bool operator < (const State& s) const {
    if(cost == s.cost) return node > s.node;
    return cost > s.cost;
  }
};

int V,E;
vector<int> G[1001];
vector<P>v;
P d[1001][4];

void dijkstra(int s){
  priority_queue<State>que;
  int X = v[s].first, Y = v[s].second;
  for(int i=0; i<4; i++){
    State t(0,1,X,Y,i,s);
    d[s][i].first = d[s][i].second = 0;
    que.push(t);
  }

  while(!que.empty()){
    State tmp = que.top();
    que.pop();
    int cost = tmp.cost;
    int x = tmp.x, y = tmp.y;
    int node = tmp.node;
    int dir = tmp.dir;
    int now = tmp.now;

    if(d[now][dir].first < cost) continue;

    for(int i=0; i<G[now].size(); i++){
      int index = G[now][i];
      int nx = v[index].first, ny = v[index].second;
      if(dir == 0 && y == ny && x > nx){
	if(d[index][3].first >= cost + x - nx){
	  d[index][3].first = cost + x - nx;
	  d[index][3].second = min(d[index][3].second,node + 1);
	  que.push(State(d[index][3].first,d[index][3].second,nx,ny,3,index));
	}
      }

      if(dir == 1 && x == nx && y < ny){
	if(d[index][0].first >= cost + ny - y){
	  d[index][0].first = cost + ny - y;
	  d[index][0].second = min(d[index][0].second,node + 1);
	  que.push(State(d[index][0].first,d[index][0].second,nx,ny,0,index));
	}
      }

      if(dir == 2 && y == ny && x < nx){

	if(d[index][1].first >= cost + nx - x){
	  d[index][1].first = cost + nx - x;
	  d[index][1].second = min(d[index][1].second,node + 1);
	  que.push(State(d[index][1].first,d[index][1].second,nx,ny,1,index));
	}
      }

      if(dir == 3 && x == nx && y > ny){
	if(d[index][2].first >= cost + y - ny){
	  d[index][2].first = cost + y - ny;
	  d[index][2].second = min(d[index][2].second,node + 1);
	  que.push(State(d[index][2].first,d[index][2].second,nx,ny,2,index));
	}
      }


      //straight

      if(dir == 0 && nx == x && ny > y){
	if(d[index][dir].first >= cost + ny - y){
	  d[index][dir].first = cost + ny - y;
	  d[index][dir].second = min(d[index][dir].second,node + 1);
	  que.push(State(d[index][dir].first,d[index][dir].second,nx,ny,dir,index));
	}
      }

      if(dir == 1 && ny == y && nx > x){
	if(d[index][dir].first >= cost + nx - x){
	  d[index][dir].first = cost + nx - x;
	  d[index][dir].second = min(d[index][dir].second,node + 1);
	  que.push(State(d[index][dir].first,d[index][dir].second,nx,ny,dir,index));
	}
      }
      
      if(dir == 2 && nx == x && ny < y){
	if(d[index][dir].first >= cost + y - ny){
	  d[index][dir].first = cost + y - ny;
	  d[index][dir].second = min(d[index][dir].second,node + 1);
	  que.push(State(d[index][dir].first,d[index][dir].second,nx,ny,dir,index));
	}
      }
      
      if(dir == 3 && ny == y && nx < x){
	if(d[index][dir].first >= cost + x - nx){
	  d[index][dir].first = cost + x - nx;
	  d[index][dir].second = min(d[index][dir].second,node + 1);
	  que.push(State(d[index][dir].first,d[index][dir].second,nx,ny,dir,index));
	}

      }

    }
  }
}
int main(){

  while(cin >> V >> E,V|E){

    for(int i=0; i<1001; i++)
      for(int j=0; j<4; j++) d[i][j].first = d[i][j].second = INF;

    for(int i=0; i<1001; i++)G[i].clear();
    v.clear();

    string s;
    int x,y;
    map<string,int>m;
    for(int i=0; i<V; i++){
      cin >> s >> x >> y;
      v.push_back(P(x,y));
      m[s] = i;
    }

    string from,to;
    for(int i=0; i<E; i++){
      cin >> from >> to;
      G[m[from]].push_back(m[to]);
      G[m[to]].push_back(m[from]);
    }

    string start,des;
    cin >> start >> des;

    dijkstra(m[start]);

    int MinCost = INF, ans = INF;

    for(int i=0; i<4; i++){
      if(MinCost > d[m[des]][i].first){
	MinCost = d[m[des]][i].first;
	ans = d[m[des]][i].second;
      } else if(MinCost == d[m[des]][i].first){
	ans = min(ans,d[m[des]][i].second);
      }
    }

    if(MinCost == INF) cout << "impossible" << endl;
    else cout << ans << endl;
  }
  return 0;
}