#include <bits/stdc++.h>
using namespace std;

typedef int64_t Time;
struct Flight;
struct Airport;

constexpr Time infinity=1ll<<60ll;

struct Flight{
  Time s;
  Time t;
  Airport *from;
  Airport *dest;
  int id;

  bool operator<(Flight const &a)const{
    return s!=a.s? s<a.s
         : t!=a.t? t<a.t
         : from!=a.from? from<a.from
         : dest!=a.dest? dest<a.dest
         : id<a.id;
  }
};

struct Airport{
  string name;
  set<Flight> edges;
};

Airport *get_airport(string name){
  static map<string,Airport*> existent;
  if (not existent.count(name)){
    return existent[name]=new Airport{name,{}};
  }else{
    return existent[name];
  }
}

Time parse_time(string s){
  Time res=0;
  stringstream ss(s);
  assert(getline(ss,s,'d')); res=res+stoi(s);
  assert(getline(ss,s,':')); res=res*24+stoi(s);
  assert(getline(ss,s,':')); res=res*60+stoi(s);
  return res;
}

Time dijkstra(Airport *source,Time st,Airport *sink){
  map<Airport*,Time> at={{source,st}};
  priority_queue<pair<Time,Airport*>,vector<pair<Time,Airport*>>,greater<pair<Time,Airport*>>> todo;
  todo.push({st,source});
  while (not todo.empty()){
    Time w=todo.top().first;
    Airport *a=todo.top().second;
    //cerr<<"  go "<<a->name<<" @ "<<w<<endl;
    todo.pop();
    if (w!=at[a]) continue;
    for (auto e: a->edges){
      if (e.s>=w and (not at.count(e.dest) or e.t<at[e.dest])){
        at[e.dest]=e.t;
        todo.push({e.t,e.dest});
      }
    }
  }
  if (not at.count(sink)){
    //cerr<<"impossible"<<endl;
    return infinity;
  }
  //cerr<<"result="<<at[sink]<<endl;
  return at[sink];
}

int main(){
  vector<Flight> all_flights;

  int m; cin>>m;
  while (m--){
    string a,b,c,d; cin>>a>>b>>c>>d;
    //cerr<<"! "<<a<<" "<<b<<" "<<c<<" "<<d<<endl;
    all_flights.push_back({parse_time(b),parse_time(d),get_airport(a),get_airport(c),m});
    all_flights.back().from->edges.insert(all_flights.back());
  }


  int64_t ideal=0,worst=0;
  int n; cin>>n;
  vector<Flight> my_flights(n);
  for (auto &i: my_flights){
    int id; cin>>id; --id; i=all_flights[id];
    ideal=max(ideal,i.t);
  }
  //cerr<<" n = "<<n<<endl;
  for (auto const &i: my_flights){
    i.from->edges.erase(i);
    worst=max(worst,dijkstra(i.from,i.s,my_flights.back().dest));
    i.from->edges.insert(i);
  }

  if (worst==infinity){
    cout<<"stranded"<<endl;
  }else{
    cout<<max(worst,ideal)-ideal<<endl;
  }
  return 0;
}