#include <cstdlib>
#include <iostream>
#include <stdio.h>
#include <cstring>
#include <vector>
#include <algorithm>
#include <utility>
#include <queue>
#include <map>
#include <stack>
#include <cmath>
#include <set>

#define INF 99999999
#define rep(i, a, b) for (int i = int(a); i < int(b); i++)
#define TRvii(c, it) for (vii::iterator it = (c).begin(); it != (c).end(); it++)
#define tr(it, s)  for ( typeof ( s.begin( ) ) it=s.begin( ); it!=s.end( ); it++ )
#define pb push_back
#define clr(a) memset((a),0,sizeof(a))
#define pi 3.1415926535897932384626433832795028841971

using namespace std;

typedef long long ll;
typedef pair < int, int >  ii;
typedef vector < int >  vi;
typedef vector < ii >  vii;


map<string, int> mp;
vector<pair<int, string> > adj[4099];
vector<pair<int, int> > list[104444];

int calc_p(char a){

     return a-'a' + 1;
}

int calc_v(int a, int d){

     return 26*a + d;
}

int dijkstra (int s, int fim)  // inicio  -  destino
{
     vector<int> dist(104009+1, INF);
     dist[s] = 0;


     priority_queue<ii> pq;
     pq.push(ii(0, s));

     while (!pq.empty()) {

          ii top = pq.top(); pq.pop();
          int d = -top.first, u = top.second;

          if (d == dist[u]){
               for(vector<pair<int,int> > :: iterator it = list[u].begin(); it != list[u].end(); it++){
              // tr (it, list[u]) {
                    int v = it->first, weight_u_v = it->second;
                    if (dist[u] + weight_u_v < dist[v]) {
                         dist[v] = dist[u] + weight_u_v;
                         pq.push(ii(-dist[v], v));
                    }
               }
          }

          if(u == fim) return dist[fim];
     }

     return INF;
}


int main(){

     char ini[55], fim[55], x[55], y[55], c[55];
     int n;

     while(scanf("%d",&n) && n){

          getchar();
          mp.clear();
          scanf("%s%s",ini,fim);
          int qt = 1;

          rep(i,0,n){

               scanf("%s%s%s",&x,&y,&c);
               if(!mp[x]) mp[x] = qt++;
               if(!mp[y]) mp[y] = qt++;

               adj[mp[x]].pb(make_pair(mp[y],c));
               adj[mp[y]].pb(make_pair(mp[x],c));
          }

          if(!mp[ini] || !mp[fim])
               printf("impossivel\n");
          else{

               rep(i,1,qt){

                      int tam = adj[i].size();
                      rep(j,0,tam){

                              int pos = calc_p(adj[i][j].second[0]); // pos da letra ( 1(a) ... 26(z) )
                              int vtx = calc_v(i-1, pos); // id unico (vertice)
                              int vty = calc_v(adj[i][j].first-1, pos);  // mesma letra (n conecta)
                              int oky = vty - (adj[i][j].second[0] - 'a');  // comeco do intervalo da ID

                              int custo = adj[i][j].second.size();

                              rep(k,oky,oky+26){  // itero todo intervalo do vertice, (a at? z)

                                   if(k != vty)   //  conecto se for diferente da primeira letra atual
                                        list[vtx].pb(ii(k,custo));
                              }
                      }
               }

               int vini = (mp[ini]-1) * 26  +1;
               int vfim = (mp[fim]-1) * 26  +1;

               rep(i,0,26)
                    list[0].pb(ii(vini+i,0));

               rep(i,0,26)
                    list[vfim+i].pb(ii(26*qt+30,0));

               int ans = dijkstra(0,26*qt+30);

               if(ans == INF)
                    printf("impossivel\n");
               else
                    printf("%d\n",ans);

          }

          rep(i,0,qt)
               adj[i].clear();

          int limit = qt*26+30;

          rep(i,0,limit)
               list[i].clear();

     }

     return 0;
}