Problem: It's unbelievable, but an exam period has started at the OhWord University. It's even more unbelievable, that Valera got all the tests before the exam period for excellent work during the term. As now he's free, he wants to earn money by solving problems for his groupmates. He's made a list of subjects that he can help with. Having spoken with n of his groupmates, Valera found out the following information about them: what subject each of them passes, time of the exam and sum of money that each person is ready to pay for Valera's help.

Having this data, Valera's decided to draw up a timetable, according to which he will solve problems for his groupmates. For sure, Valera can't solve problems round the clock, that's why he's found for himself an optimum order of day and plans to stick to it during the whole exam period. Valera assigned time segments for sleep, breakfast, lunch and dinner. The rest of the time he can work.

Obviously, Valera can help a student with some subject, only if this subject is on the list. It happened, that all the students, to whom Valera spoke, have different, but one-type problems, that's why Valera can solve any problem of subject listi in ti minutes.

Moreover, if Valera starts working at some problem, he can break off only for sleep or meals, but he can't start a new problem, not having finished the current one. Having solved the problem, Valera can send it instantly to the corresponding student via the Internet.

If this student's exam hasn't started yet, he can make a crib, use it to pass the exam successfully, and pay Valera the promised sum. Since Valera has little time, he asks you to write a program that finds the order of solving problems, which can bring Valera maximum profit.

Input

The first line contains integers m, n, k (1 ≤ m, n ≤ 100, 1 ≤ k ≤ 30) — amount of subjects on the list, amount of Valera's potential employers and the duration of the exam period in days.

The following m lines contain the names of subjects listi (listi is a non-empty string of at most 32 characters, consisting of lower case Latin letters). It's guaranteed that no two subjects are the same.

The (m + 2)-th line contains m integers ti (1 ≤ ti ≤ 1000) — time in minutes that Valera spends to solve problems of the i-th subject. Then follow four lines, containing time segments for sleep, breakfast, lunch and dinner correspondingly.

Each line is in format H1:M1-H2:M2, where 00 ≤  H1, H2 ≤ 23, 00 ≤  M1, M2 ≤ 59. Time H1:M1 stands for the first minute of some Valera's action, and time H2:M2 stands for the last minute of this action. No two time segments cross. It's guaranteed that Valera goes to bed before midnight, gets up earlier than he has breakfast, finishes his breakfast before lunch, finishes his lunch before dinner, and finishes his dinner before midnight. All these actions last less than a day, but not less than one minute. Time of the beginning and time of the ending of each action are within one and the same day. But it's possible that Valera has no time for solving problems.

Then follow n lines, each containing the description of students. For each student the following is known: his exam subject si (si is a non-empty string of at most 32 characters, consisting of lower case Latin letters), index of the exam day di (1 ≤ di ≤ k), the exam time timei, and sum of money ci (0 ≤ ci ≤ 106, ci — integer) that he's ready to pay for Valera's help. Exam time timei is in the format HH:MM, where 00 ≤  HH ≤ 23, 00 ≤  MM ≤ 59. Valera will get money, if he finishes to solve the problem strictly before the corresponding student's exam begins.

Output

In the first line output the maximum profit that Valera can get. The second line should contain number p — amount of problems that Valera is to solve. In the following p lines output the order of solving problems in chronological order in the following format: index of a student, to whom Valera is to help; index of the time, when Valera should start the problem; time, when Valera should start the problem (the first minute of his work); index of the day, when Valera should finish the problem; time, when Valera should finish the problem (the last minute of his work). To understand the output format better, study the sample tests.

Examples

Input

3 3 4
calculus
algebra
history
58 23 15
00:00-08:15
08:20-08:35
09:30-10:25
19:00-19:45
calculus 1 09:36 100
english 4 21:15 5000
history 1 19:50 50


Output

150
2
1 1 08:16 1 09:29
3 1 10:26 1 10:40


Input

2 2 1
matan
codeforces
1 2
00:00-08:00
09:00-09:00
12:00-12:00
18:00-18:00
codeforces 1 08:04 2
matan 1 08:02 1


Output

3
2
2 1 08:01 1 08:01
1 1 08:02 1 08:03


Input

2 2 1
matan
codeforces
2 2
00:00-08:00
09:00-09:00
12:00-12:00
18:00-18:00
codeforces 1 08:04 2
matan 1 08:03 1


Output

2
1
1 1 08:01 1 08:02

Solution (in CPP):

Solution:
#include <bits/stdc++.h>
using namespace std;
using namespace std;
;
int n, m, k;
char s[101];
string rev[101];
int subjectTime[101];
map<string, int> mp;
int id = 0;
int convert(int d, int h, int m) { return d * 24 * 60 + h * 60 + m; }
const int maxt = 30 * 24 * 60 + 24 * 60 + 60 + 10;
struct Entry {
  int subject;
  int deadline;
  int takes;
  int price;
  int index;
  Entry(int subject, int deadline, int price, int index) {
    this->subject = subject;
    this->deadline = deadline;
    this->price = price;
    this->takes = subjectTime[subject];
    this->index = index;
  }
  bool operator<(const Entry& o) const {
    if (deadline == o.deadline) return index < o.index;
    return deadline < o.deadline;
  }
};
int F[maxt];
int busy[maxt];
vector<Entry> tasks;
int dp[101][maxt];
int getDelay(int start, int plus) {
  int lo = start, hi = maxt - 1;
  int ans = 1 << 30;
  while (lo <= hi) {
    int mid = lo + (hi - lo) / 2;
    int tot = mid - start + 1;
    tot -= busy[mid];
    if (start != 0) tot += busy[start - 1];
    if (tot >= plus)
      ans = mid, hi = mid - 1;
    else
      lo = mid + 1;
  }
  return ans;
}
int solve(int ind, int curr_t) {
  if (curr_t > maxt) return -(1 << 28);
  if (ind == ((int)((tasks).size()))) return 0;
  int& ret = dp[ind][curr_t];
  if (ret != -1) return ret;
  ret = 0;
  ret = max(ret, solve(ind + 1, curr_t));
  int d = getDelay(curr_t, tasks[ind].takes);
  if (d < tasks[ind].deadline) {
    ret = max(ret, tasks[ind].price + solve(ind + 1, d + 1));
  }
  return ret;
}
struct Response {
  int ind;
  int end, start;
  int start_day, start_hour, start_min;
  int end_day, end_hour, end_min;
  int a;
  Response(int ind, int start, int end) {
    this->ind = ind;
    this->end = end;
    this->start = start;
    a = start;
    go();
  }
  void go() {
    start_day = start / (1440);
    start %= 1440;
    start_hour = start / 60;
    start_min = start % 60;
    end_day = end / (1440);
    end %= 1440;
    end_hour = end / 60;
    end_min = end % 60;
  }
  bool operator<(const Response& o) const {
    if (a == o.a) return ind < o.ind;
    return start < o.start;
  }
};
vector<Response> responses;
void trace(int ind, int curr_t) {
  if (ind == ((int)((tasks).size()))) return;
  int ret = dp[ind][curr_t];
  ret = 0;
  int opt = solve(ind, curr_t);
  ret = max(ret, solve(ind + 1, curr_t));
  if (opt == ret) {
    trace(ind + 1, curr_t);
    return;
  }
  int d = getDelay(curr_t, tasks[ind].takes);
  if (d < tasks[ind].deadline) {
    ret = max(ret, tasks[ind].price + solve(ind + 1, d + 1));
    responses.push_back(Response(tasks[ind].index, F[curr_t], d));
    trace(ind + 1, d + 1);
  }
}
int main() {
  scanf("%d %d %d", &n, &m, &k);
  for (int i = 0; i < n; ++i) {
    string str;
    cin >> str;
    mp[str] = i;
    rev[i] = str;
  }
  for (int i = 0; i < n; ++i) {
    scanf("%d", &subjectTime[i]);
  }
  int h1, m1, h2, m2;
  for (int i = 0; i < 4; ++i) {
    scanf("%d:%d-%d:%d", &h1, &m1, &h2, &m2);
    for (int k = 0; k < 30; ++k) {
      int L = convert(k, h1, m1);
      int R = convert(k, h2, m2);
      busy[L]++;
      busy[R + 1]--;
    }
  }
  for (int i = 1; i < maxt; ++i) {
    busy[i] += busy[i - 1];
  }
  int lst = -1;
  for (int i = maxt - 1; i >= 0; --i) {
    if (!busy[i]) lst = i;
    if (lst != -1) {
      F[i] = lst;
    }
  }
  for (int i = 1; i < maxt; ++i) busy[i] += busy[i - 1];
  scanf("%d:%d-%d:%d", &h1, &m1, &h2, &m2);
  int p;
  int day;
  for (int i = 0; i < m; ++i) {
    string str;
    cin >> str;
    scanf("%d %d:%d %d", &day, &h1, &m1, &p);
    --day;
    if (mp.find(str) == mp.end()) continue;
    int t = convert(day, h1, m1);
    tasks.push_back(Entry(mp[str], t, p, i));
  }
  sort((tasks).begin(), (tasks).end());
  memset(dp, -1, sizeof(dp));
  cout << solve(0, 0) << "\n";
  trace(0, 0);
  printf("%d\n", ((int)((responses).size())));
  for (int i = 0; i < ((int)((responses).size())); i++) {
    printf("%d %d %02d:%02d %d %02d:%02d\n", responses[i].ind + 1,
           responses[i].start_day + 1, responses[i].start_hour,
           responses[i].start_min, responses[i].end_day + 1,
           responses[i].end_hour, responses[i].end_min);
  }
}