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

typedef int Airport;
typedef int Time;

Airport read_airport(){
  static map<string,int> airport_codes;
  static char code[100];
  scanf(" %s",code);
  string scode=code;
  if (not airport_codes.count(scode))
    return airport_codes[scode]=airport_codes.size();
  else
    return airport_codes[scode];
}

Time read_time(){
  int d,h,m; scanf("%d%*c%d%*c%d",&d,&h,&m);
  assert(0<=d and d<=365);
  assert(0<=h and h<=23);
  assert(0<=m and m<=59);
  return m+60*(h+24*(d));
}

typedef pair<int,int> pl_t;

map<int,vector<int>> times_at;
map<pl_t,set<pl_t>> edges;
map<pl_t,set<pl_t>> redges;
vector<pair<pl_t,pl_t>> flights;

int main(){
  int n; scanf("%d",&n);

  for (int i=0; i<n; i++){
    int a=read_airport();
    int t1=read_time();
    int b=read_airport();
    int t2=read_time();
    flights.push_back({{t1,a},{t2,b}});
    assert(t1<t2);
  }

  int m; scanf("%d",&m);
  vector<int> itinerary(m);
  set<int> itinerary_s;
  for (auto &i: itinerary){
    scanf("%d",&i); --i;
    itinerary_s.insert(i);
  }
  for (int i=1,j=0; i<m; j=i++){
    assert(flights[itinerary[j]].second.first<=flights[itinerary[i]].first.first);
  }
  int destination=flights[itinerary.back()].second.second;

  for (int i=0; i<n; i++){
    int &a=flights[i].first.second;
    int &t1=flights[i].first.first;
    int &b=flights[i].second.second;
    int &t2=flights[i].second.first;

    // Adjust departure time to be after arrival time,
    // but one less if this is part of the itinerary
    // as we need to be able to skip past it in the list.
    if (itinerary_s.count(i)){
      t1=t1*3+1;
    }else{
      t1=t1*3+2;
    }
    t2*=3;

    edges[{t1,a}].insert({t2,b});
    redges[{t2,b}].insert({t1,a});
    times_at[a].push_back(t1);
    times_at[b].push_back(t2);
  }

  for (auto &it: times_at){
    sort(it.second.begin(),it.second.end());
    for (int j=1; j<it.second.size(); j++){
      if (it.second[j]!=it.second[j-1]){
         edges[{it.second[j-1],it.first}].insert({it.second[j  ],it.first});
        redges[{it.second[j  ],it.first}].insert({it.second[j-1],it.first});
      }
    }
  }

  map<pl_t,int> eta;
  for (auto it=redges.rbegin(); it!=redges.rend(); it++){
    if (it->first.second==destination){
      eta[it->first]=it->first.first;
    }
    if (eta.count(it->first)){
      for (auto j: it->second){
        assert(j!=it->first);
        if (not eta.count(j) or eta[j]>eta[it->first]){
          eta[j]=eta[it->first];
        }
      }
    }
  }

  int planned_time=flights[itinerary.back()].second.first;
  int worst_case=planned_time;
  for (auto f: itinerary){
    int airport=flights[f].first.second;
    int when=flights[f].first.first;

    auto &times=times_at[airport];
    auto it=upper_bound(times.begin(),times.end(),when);
    if (it==times.end()){
      cout<<"stranded"<<endl;
      return 0;
    }

    pair<int,int> situation={*it,airport};

    if (not eta.count(situation)){
      cout<<"stranded"<<endl;
      return 0;
    }
    int result=eta[situation];
    worst_case=max(worst_case,result);
  }
  cout<<(worst_case/3)-(planned_time/3)<<endl;
}